summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/binding.h253
-rw-r--r--src/client.h68
-rw-r--r--src/clientlx.c829
-rw-r--r--src/mga.h608
-rw-r--r--src/mga_arc.c225
-rw-r--r--src/mga_common.h152
-rw-r--r--src/mga_dac3026.c1288
-rw-r--r--src/mga_dacG.c1187
-rw-r--r--src/mga_dga.c459
-rw-r--r--src/mga_dh.c518
-rw-r--r--src/mga_dri.c1418
-rw-r--r--src/mga_dri.h122
-rw-r--r--src/mga_dripriv.h51
-rw-r--r--src/mga_driver.c4166
-rw-r--r--src/mga_esc.c791
-rw-r--r--src/mga_g450pll.c523
-rw-r--r--src/mga_halmod.c38
-rw-r--r--src/mga_hwcurs.c41
-rw-r--r--src/mga_macros.h118
-rw-r--r--src/mga_map.h17
-rw-r--r--src/mga_merge.c960
-rw-r--r--src/mga_merge.h19
-rw-r--r--src/mga_reg.h482
-rw-r--r--src/mga_sarea.h222
-rw-r--r--src/mga_shadow.c254
-rw-r--r--src/mga_storm.c2703
-rw-r--r--src/mga_ucode.h11610
-rw-r--r--src/mga_video.c1280
-rw-r--r--src/mgareg_flags.h931
29 files changed, 31333 insertions, 0 deletions
diff --git a/src/binding.h b/src/binding.h
new file mode 100644
index 0000000..f44de3e
--- /dev/null
+++ b/src/binding.h
@@ -0,0 +1,253 @@
+/**************************************************************************************
+
+ @doc MGA MGA_STRUCT
+
+ @module MGA Structures | Structure of The MGA Layer
+ @normal Copyright © 1997, Matrox Graphics Inc.
+
+ All Rights Reserved.
+
+ @head3 MGA Structures |
+ @index struct | MGA_STRUCT
+
+ @end
+
+***************************************************************************************/
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/HALlib/binding.h,v 1.5 2000/12/06 20:39:52 dawes Exp $ */
+
+#ifndef _BINDING
+#define _BINDING
+
+#ifndef _INTERNALBINDING
+
+#define BINDING_NOERROR 0x00000000
+#define BINDING_ERROR 0x90000000
+#define FAR
+#define DECL
+
+typedef void VOID;
+typedef void FAR *LPVOID;
+typedef void FAR *LPBOARDHANDLE;
+
+typedef long LONG;
+typedef unsigned long ULONG;
+typedef unsigned long FLONG;
+typedef unsigned long FAR *LPULONG;
+
+typedef char CHAR;
+typedef unsigned char UCHAR;
+typedef unsigned char FAR*LPUCHAR;
+
+typedef struct TAGCLIENTTABLE{
+ ULONG (DECL *ClientReadConfigSpaceByte )(LPVOID , ULONG, LPVOID );
+ ULONG (DECL *ClientReadConfigSpaceDword )(LPVOID , ULONG, LPVOID );
+ ULONG (DECL *ClientWriteConfigSpaceByte )(LPVOID , ULONG, UCHAR);
+ ULONG (DECL *ClientWriteConfigSpaceDword )(LPVOID , ULONG, ULONG);
+ ULONG (DECL *ClientOpenRegisterBase )(LPVOID , ULONG, ULONG);
+ ULONG (DECL *ClientCloseRegisterBase )(LPVOID );
+ ULONG (DECL *ClientReadRegisterByte )(LPVOID , ULONG, LPVOID );
+ ULONG (DECL *ClientReadRegisterDword )(LPVOID , ULONG, LPVOID );
+ ULONG (DECL *ClientWriteRegisterByte )(LPVOID , ULONG, UCHAR);
+ ULONG (DECL *ClientWriteRegisterDword )(LPVOID , ULONG, ULONG);
+ ULONG (DECL *ClientOpenMemoryBase )(LPVOID , ULONG, ULONG);
+ ULONG (DECL *ClientCloseMemoryBase )(LPVOID );
+ ULONG (DECL *ClientReadMemoryByte )(LPVOID , ULONG, LPVOID );
+ ULONG (DECL *ClientReadMemoryDword )(LPVOID , ULONG, LPVOID );
+ ULONG (DECL *ClientWriteMemoryByte )(LPVOID , ULONG, UCHAR);
+ ULONG (DECL *ClientWriteMemoryDword )(LPVOID , ULONG, ULONG);
+ ULONG (DECL *ClientOpenSystemDevice )(LPVOID , ULONG, ULONG);
+ ULONG (DECL *ClientCloseSystemDevice )(LPVOID );
+ ULONG (DECL *ClientReadSystemDeviceByte )(LPVOID , ULONG, LPVOID );
+ ULONG (DECL *ClientReadSystemDeviceDword )(LPVOID , ULONG, LPVOID );
+ ULONG (DECL *ClientWriteSystemDeviceByte )(LPVOID , ULONG, UCHAR);
+ ULONG (DECL *ClientWriteSystemDeviceDword )(LPVOID , ULONG, ULONG);
+ ULONG (DECL *ClientWait )(LPVOID , ULONG);
+ ULONG (DECL *ClientGetBiosInfo ) (LPVOID, LPVOID, LPVOID);
+ ULONG (DECL *ClientReadDDCEdid ) (LPVOID, LPVOID, ULONG);
+#ifdef DEBUG
+ ULONG (DECL *ClientDebug ) (LPVOID, ULONG, LPVOID, ULONG, LPVOID);
+#endif
+} CLIENTTABLE, FAR *LPCLIENTTABLE;
+
+#endif /* _INTERNALBINDING */
+
+/***************************************************************************************************
+ MGAHWINFO STRUCTURE
+ ***************************************************************************************************
+ @struct MGAHWINFO | Public MGA Board Information
+ @field OUT ULONG | ulCapsFirstOutput | Capabilities of firts output
+ @flag Bit 0 | Analog output supported on primary CRTC
+ @flag Bit 1 | Digital output supported on primary CRTC
+ @flag Bit 2 | TV output supported on primary CRTC
+ @flag Bit 3 | Analog output supported on second CRTC
+ @flag Bit 4 | Digital output supported on second CRTC
+ @flag Bit 5 | TV output supported on second CRTC
+ @flag Bit 6 | VGA output supported
+ @field OUT ULONG | ulCapsSecondOutput | Capabilities of second output
+ @flag Bit 0 | Analog output supported on primary CRTC
+ @flag Bit 1 | Digital output supported on primary CRTC
+ @flag Bit 2 | TV output supported on primary CRTC
+ @flag Bit 3 | Analog output supported on second CRTC
+ @flag Bit 4 | Digital output supported on second CRTC
+ @flag Bit 5 | TV output supported on second CRTC
+ @flag Bit 6 | VGA output supported
+ @field OUT ULONG | ulVideoMemory | Total number of video memory in bytes
+ @end
+ **************************************************************************************************/
+typedef struct TAGMGAHWINFO {
+ ULONG ulCapsFirstOutput;
+ ULONG ulCapsSecondOutput;
+ ULONG ulVideoMemory;
+} MGAHWINFO, FAR *LPMGAHWINFO;
+
+/***************************************************************************************************
+ MGAMODEINFO STRUCTURE
+ ***************************************************************************************************
+ @struct MGAMODEINFO | Mode Information
+ @field IN FLONG | flOutput | Where we want to apply this parameters
+ @flag Bit 0 | Use second CRTC
+ @flag Bit 1 | Use primary analog output
+ @flag Bit 2 | Use secondary analog output
+ @flag Bit 3 | Use primary digital output
+ @flag Bit 4 | Use secondary digital output
+ @flag Bit 5 | Force a particular frame buffer pitch
+ @flag Bit 6 | Force a particular display origin
+ @flag Bit 7-31 | Reserved
+ @field IN ULONG | ulDispWidth | Display Width in pixels
+ @field IN ULONG | ulDispHeight | Display Height in pixels
+ @field IN ULONG | ulDeskWidth | Desktop Width in pixels
+ @field IN ULONG | ulDeskHeight | Desktop Height in pixels
+ @field IN OUT ULONG | ulFBPitch | Frame Buffer Pitch in pixel
+ @field IN ULONG | ulBpp | Bits Per Pixels and input format
+ @flag lower 16 bit | Bits per pixel
+ <nl><tab> 8, 15, 16, 24 or 32
+ @flag upper 16 bit | Input format
+ <nl><tab> 0 RGB
+ <nl><tab> 1 RGBA
+ <nl><tab> 2 YcbCr 4:2:0 3 Planes
+ <nl><tab> 3 YcbCr 4:2:0 4 Planes
+ <nl><tab> 4 YcbCr 4:2:2-UYVY
+ <nl><tab> 5 YcbCr 4:2:2-YUY2
+ <nl><tab> 6-10 none interleave mode
+ <nl><tab> 6 NI RGBA
+ <nl><tab> 7 NI YcbCr 4:2:0 3 Planes
+ <nl><tab> 8 NI YcbCr 4:2:0 4 Planes
+ <nl><tab> 9 NI YcbCr 4:2:2-UYVY
+ <nl><tab> 10 NI YcbCr 4:2:2-YUY2
+ @field IN ULONG | ulZoom | Zoom factor
+ @flag 1x (1), 2x (2) or 4x (4)|
+ @field IN OUT FLONG | flSignalMode | Signal Mode
+ @flag Bit 0 | Interlace (0 : Non-interlace / 1: Interlace)
+ @flag Bit 1 | Overscan (0 : No Overscan / 1 : Overscan)
+ @flag Bit 2 | Horizontal Sync Polarity (0 : Negative / 1 : Positive)
+ @flag Bit 3 | Vertical Sync Polarity (0 : Negative / 1 : Positive)
+ @flag Bit 4-7 | Standard TV output
+ <nl><tab>000 - PAL B G H
+ <nl><tab>001 - NTSC M
+ <nl><tab>010..111 - Reserved
+ @flag Bit 8-31 | Reserved for future use
+ @field IN OUT ULONG | ulRefreshRate | Vertical Refresh Rate in Hz
+ @field IN OUT ULONG | ulHorizRate | Horizontal Refresh Rate in KHz
+ @field IN OUT ULONG | ulPixClock | Pixel Clock in kHz
+ @field IN OUT ULONG | ulHFPorch | Horizontal front porch in pixels
+ @field IN OUT ULONG | ulHSync | Horizontal Sync in pixels
+ @field IN OUT ULONG | ulHBPorch | Horizontal back porch in pixels
+ @field IN OUT ULONG | ulVFPorch | Vertical front porch in lines
+ @field IN OUT ULONG | ulVSync | Vertical Sync in lines
+ @field IN OUT ULONG | ulVBPorch | Vertical back Porch in lines
+ @field IN OUT ULONG | ulDisplayOrg | Origin of the display Offset(pixels)
+ @field IN OUT ULONG | ulDstOrg | Origin of the drawing Offset in the frame (pixels)
+ @field IN OUT ULONG | ulPanXGran | Panning in X granularity in pixel
+ @field IN OUT ULONG | ulPanYGran | Panning in Y granularity in pixel
+ @field IN OUT ULONG | ulTVStandard | TV Standard
+ @field IN OUT ULONG | ulCableType | Cable Type
+ @end
+ **************************************************************************************************/
+typedef struct TAGMAGMODEINFO {
+ FLONG flOutput; /* Where we want to apply this parameters */
+ ULONG ulDispWidth; /* Display Width in pixels */
+ ULONG ulDispHeight; /* Display Height in pixels */
+ ULONG ulDeskWidth; /* Desktop Width in pixels */
+ ULONG ulDeskHeight; /* Desktop Height in pixels */
+ ULONG ulFBPitch; /* Frame Buffer Pitch in pixel */
+ ULONG ulBpp; /* Bits Per Pixels / input format */
+ ULONG ulZoom; /* Zoom factor */
+ FLONG flSignalMode; /* Signal Mode */
+ ULONG ulRefreshRate; /* Vertical Refresh Rate in Hz */
+ ULONG ulHorizRate; /* Horizontal Refresh Rate in KHz */
+ ULONG ulPixClock; /* Pixel Clock in kHz */
+ ULONG ulHFPorch; /* Horizontal front porch in pixels */
+ ULONG ulHSync; /* Horizontal Sync in pixels */
+ ULONG ulHBPorch; /* Horizontal back porch in pixels */
+ ULONG ulVFPorch; /* Vertical front porch in lines */
+ ULONG ulVSync; /* Vertical Sync in lines */
+ ULONG ulVBPorch; /* Vertical back Porch in lines */
+ ULONG ulDisplayOrg; /* Origin of the display Offset(bytes) */
+ ULONG ulDstOrg; /* Origin of the drawing Offset in the frame (bytes) */
+ ULONG ulPanXGran; /* Panning in X granularity in pixel */
+ ULONG ulPanYGran; /* Panning in Y granularity in pixel */
+ ULONG ulTVStandard; /* TV Standard */
+ ULONG ulCableType; /* Cable Type */
+} MGAMODEINFO, FAR *LPMGAMODEINFO;
+
+#define MGAHWINFOCAPS_CRTC1_ANALOG 1L
+#define MGAHWINFOCAPS_CRTC1_DIGITAL (1L << 1)
+#define MGAHWINFOCAPS_CRTC1_TV (1L << 2)
+#define MGAHWINFOCAPS_CRTC2_ANALOG (1L << 3)
+#define MGAHWINFOCAPS_CRTC2_DIGITAL (1L << 4)
+#define MGAHWINFOCAPS_CRTC2_TV (1L << 5)
+#define MGAHWINFOCAPS_OUTPUT_VGA (1L << 6)
+#define MGAHWINFOCAPS_CRTC2 (MGAHWINFOCAPS_CRTC2_ANALOG | MGAHWINFOCAPS_CRTC2_DIGITAL | MGAHWINFOCAPS_CRTC2_TV)
+#define MGAHWINFOCAPS_OUTPUT_ANALOG (MGAHWINFOCAPS_CRTC1_ANALOG | MGAHWINFOCAPS_CRTC2_ANALOG)
+#define MGAHWINFOCAPS_OUTPUT_DIGITAL (MGAHWINFOCAPS_CRTC1_DIGITAL | MGAHWINFOCAPS_CRTC2_DIGITAL)
+#define MGAHWINFOCAPS_OUTPUT_TV (MGAHWINFOCAPS_CRTC1_TV | MGAHWINFOCAPS_CRTC2_TV)
+
+#define MGAMODEINFO_SECOND_CRTC 1L
+#define MGAMODEINFO_ANALOG1 (1L << 1)
+#define MGAMODEINFO_ANALOG2 (1L << 2)
+#define MGAMODEINFO_DIGITAL1 (1L << 3)
+#define MGAMODEINFO_DIGITAL2 (1L << 4)
+#define MGAMODEINFO_FORCE_PITCH (1L << 5)
+#define MGAMODEINFO_FORCE_DISPLAYORG (1L << 6)
+#define MGAMODEINFO_TV (1L << 7)
+#define MGAMODEINFO_TESTONLY 0x80000000
+
+/* Cable Type */
+#define TV_YC_COMPOSITE 0
+#define TV_SCART_RGB 1
+#define TV_SCART_COMPOSITE 2
+#define TV_SCART_TYPE2 3
+
+/* TV Standard */
+
+#define TV_PAL 0
+#define TV_NTSC 1
+
+#if defined(__cplusplus)
+ extern "C" {
+#endif
+
+ULONG MGACloseLibrary(LPBOARDHANDLE pBoard);
+ULONG MGAValidateMode(LPBOARDHANDLE pBoard, LPMGAMODEINFO pMgaModeInfo);
+ULONG MGAValidateVideoParameters(LPBOARDHANDLE pBoard, LPMGAMODEINFO pMgaModeInfo);
+ULONG MGASetMode(LPBOARDHANDLE pBoard, LPMGAMODEINFO pMgaModeInfo);
+ULONG MGASetTVMode(LPBOARDHANDLE pBoard, LPMGAMODEINFO pMgaModeInfo);
+ULONG MGASetVgaMode(LPBOARDHANDLE pBoard);
+ULONG MGASaveVgaState(LPBOARDHANDLE pBoard);
+ULONG MGARestoreVgaState(LPBOARDHANDLE pBoard);
+ULONG MGAInitHardware(LPBOARDHANDLE pBoard);
+ULONG MGAGetVideoParameters(LPBOARDHANDLE pBoard, LPMGAMODEINFO pMgaModeInfo, ULONG ulRefresh);
+ULONG MGAGetHardwareInfo(LPBOARDHANDLE pBoard, LPMGAHWINFO pMgaHwInfo);
+LPVOID MGAGetClientPointer(LPBOARDHANDLE pBoard);
+ULONG MGAOpenLibrary(LPBOARDHANDLE pBoard, LPVOID lpClient, ULONG ulClientSize);
+ULONG MGAGetBOARDHANDLESize(void);
+ULONG MGASetTVStandard(LPBOARDHANDLE pBoard, ULONG ulTVStandard);
+ULONG MGASetTVCableType(LPBOARDHANDLE pBoard, ULONG ulCableType);
+
+#if defined(__cplusplus)
+ }
+#endif
+
+#endif /* _BINDING */
+
+
diff --git a/src/client.h b/src/client.h
new file mode 100644
index 0000000..8348b64
--- /dev/null
+++ b/src/client.h
@@ -0,0 +1,68 @@
+#ifndef _CLIENT
+#define _CLIENT
+
+#include "binding.h"
+
+#if defined(__cplusplus)
+ extern "C" {
+#endif
+
+typedef void* LPBIOSREGS;
+#define ASSERT_HANDLER(pBoard)
+
+typedef struct TAGCLIENTDATA
+{
+ ULONG ulFrameBufferBase;
+ ULONG ulRegisterBase;
+ pointer pMga;
+} CLIENTDATA, *LPCLIENTDATA;
+
+extern ULONG DECL ClientReadConfigSpaceByte(LPBOARDHANDLE, ULONG, LPUCHAR);
+extern ULONG DECL ClientReadConfigSpaceDword(LPBOARDHANDLE , ULONG, LPULONG );
+extern ULONG DECL ClientWriteConfigSpaceByte (LPBOARDHANDLE , ULONG, UCHAR);
+extern ULONG DECL ClientWriteConfigSpaceDword(LPBOARDHANDLE , ULONG, ULONG);
+extern ULONG DECL ClientOpenRegisterBase(LPBOARDHANDLE , ULONG, ULONG);
+extern ULONG DECL ClientCloseRegisterBase (LPBOARDHANDLE );
+extern ULONG DECL ClientReadRegisterByte(LPBOARDHANDLE , ULONG, LPUCHAR );
+extern ULONG DECL ClientReadRegisterDword(LPBOARDHANDLE , ULONG, LPULONG );
+extern ULONG DECL ClientWriteRegisterByte (LPBOARDHANDLE , ULONG, UCHAR);
+extern ULONG DECL ClientWriteRegisterDword(LPBOARDHANDLE , ULONG, ULONG);
+extern ULONG DECL ClientOpenMemoryBase(LPBOARDHANDLE , ULONG, ULONG);
+extern ULONG DECL ClientCloseMemoryBase(LPBOARDHANDLE );
+extern ULONG DECL ClientReadMemoryByte(LPBOARDHANDLE , ULONG, LPUCHAR );
+extern ULONG DECL ClientReadMemoryDword (LPBOARDHANDLE , ULONG, LPULONG );
+extern ULONG DECL ClientWriteMemoryByte(LPBOARDHANDLE , ULONG, UCHAR);
+extern ULONG DECL ClientWriteMemoryDword (LPBOARDHANDLE , ULONG, ULONG);
+extern ULONG DECL ClientOpenSystemDevice (LPBOARDHANDLE , ULONG, ULONG);
+extern ULONG DECL ClientCloseSystemDevice (LPBOARDHANDLE );
+extern ULONG DECL ClientReadSystemDeviceByte(LPBOARDHANDLE , ULONG, LPUCHAR );
+extern ULONG DECL ClientReadSystemDeviceDword(LPBOARDHANDLE , ULONG, LPULONG );
+extern ULONG DECL ClientWriteSystemDeviceByte(LPBOARDHANDLE , ULONG, UCHAR);
+extern ULONG DECL ClientWriteSystemDeviceDword (LPBOARDHANDLE , ULONG, ULONG);
+extern ULONG DECL ClientWait (LPBOARDHANDLE , ULONG);
+extern ULONG DECL ClientLocateFirstTwisterOfQuad(ULONG);
+extern ULONG DECL ClientSearchDevNode(ULONG, UCHAR, UCHAR);
+extern ULONG DECL ClientGetBiosInfo(LPBOARDHANDLE, LPUCHAR, LPULONG );
+extern ULONG DECL ClientDebug (LPBOARDHANDLE , ULONG, LPUCHAR, ULONG, LPVOID);
+extern ULONG DECL ClientCallBiosInt10(LPBOARDHANDLE, LPBIOSREGS);
+extern ULONG DECL ClientReadDDCEdid(LPBOARDHANDLE, LPUCHAR, ULONG);
+extern ULONG DECL ClientCustomCall(LPBOARDHANDLE, ULONG, LPVOID, LPVOID);
+extern ULONG DECL ClientApplyEpromPatch(LPBOARDHANDLE);
+extern ULONG DECL ClientDetectHostInterface(LPBOARDHANDLE, LPULONG);
+extern ULONG DECL ClientHSLPatchFunction(LPBOARDHANDLE, ULONG, ULONG, LPUCHAR);
+extern ULONG DECL InitClientFunctions(LPBOARDHANDLE, ULONG);
+extern ULONG DECL ClientInitTimeBase(LPBOARDHANDLE);
+extern ULONG DECL ClientOpenDMABase(LPBOARDHANDLE, ULONG, ULONG);
+extern ULONG DECL ClientReadDMAByte(LPBOARDHANDLE, ULONG, LPUCHAR);
+extern ULONG DECL ClientReadBIOS(LPBOARDHANDLE, ULONG, ULONG, ULONG, ULONG, LPUCHAR);
+extern ULONG DECL ClientWriteBIOS(LPBOARDHANDLE, ULONG, ULONG, ULONG, ULONG);
+
+#if defined(__cplusplus)
+ }
+#endif
+
+#define ESC_CUSTOM_SET_FUNCTION_PTR 0x80000200
+#define ESC_CUSTOM_GET_FUNCTION_PTR 0x80000201
+#define ESC_CUSTOM_PATCH_HSL 0x80000202
+
+#endif
diff --git a/src/clientlx.c b/src/clientlx.c
new file mode 100644
index 0000000..706c125
--- /dev/null
+++ b/src/clientlx.c
@@ -0,0 +1,829 @@
+/******************************************************************************\
+
+ clientlx.c
+
+ Copyright © 1997, Matrox Graphics Inc.
+
+ All Rights Reserved.
+
+\******************************************************************************/
+#include "xf86_OSproc.h"
+#include "xf86Pci.h"
+#include "xf86_ansic.h"
+#include "client.h"
+#include "mga.h"
+
+CLIENTTABLE ClientFunctions = {
+ (ULONG (DECL *)(LPVOID,ULONG,LPVOID)) ClientReadConfigSpaceByte,
+ (ULONG (DECL *)(LPVOID,ULONG,LPVOID)) ClientReadConfigSpaceDword,
+ (ULONG (DECL *)(LPVOID,ULONG,UCHAR)) ClientWriteConfigSpaceByte,
+ (ULONG (DECL *)(LPVOID,ULONG,ULONG)) ClientWriteConfigSpaceDword,
+ (ULONG (DECL *)(LPVOID,ULONG,ULONG)) ClientOpenRegisterBase,
+ (ULONG (DECL *)(LPVOID)) ClientCloseRegisterBase,
+ (ULONG (DECL *)(LPVOID,ULONG,LPVOID)) ClientReadRegisterByte,
+ (ULONG (DECL *)(LPVOID,ULONG,LPVOID)) ClientReadRegisterDword,
+ (ULONG (DECL *)(LPVOID,ULONG,UCHAR)) ClientWriteRegisterByte,
+ (ULONG (DECL *)(LPVOID,ULONG,ULONG)) ClientWriteRegisterDword,
+ (ULONG (DECL *)(LPVOID,ULONG,ULONG)) ClientOpenMemoryBase,
+ (ULONG (DECL *)(LPVOID)) ClientCloseMemoryBase,
+ (ULONG (DECL *)(LPVOID,ULONG,LPVOID)) ClientReadMemoryByte,
+ (ULONG (DECL *)(LPVOID,ULONG,LPVOID)) ClientReadMemoryDword,
+ (ULONG (DECL *)(LPVOID,ULONG,UCHAR)) ClientWriteMemoryByte,
+ (ULONG (DECL *)(LPVOID,ULONG,ULONG)) ClientWriteMemoryDword,
+ (ULONG (DECL *)(LPVOID,ULONG,ULONG)) ClientOpenSystemDevice,
+ (ULONG (DECL *)(LPVOID)) ClientCloseSystemDevice,
+ (ULONG (DECL *)(LPVOID,ULONG,LPVOID)) ClientReadSystemDeviceByte,
+ (ULONG (DECL *)(LPVOID,ULONG,LPVOID)) ClientReadSystemDeviceDword,
+ (ULONG (DECL *)(LPVOID,ULONG,UCHAR)) ClientWriteSystemDeviceByte,
+ (ULONG (DECL *)(LPVOID,ULONG,ULONG)) ClientWriteSystemDeviceDword,
+ (ULONG (DECL *)(LPVOID,ULONG)) ClientWait,
+ (ULONG (DECL *)(LPVOID,LPVOID,LPVOID)) ClientGetBiosInfo,
+ (ULONG (DECL *)(LPVOID,LPVOID,ULONG)) ClientReadDDCEdid
+};
+
+/******************************************************************************\
+
+ Function : ClientReadConfigSpaceByte
+
+ Description : Read a Byte from the configuration space.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specifib board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ UCHAR *pucByte | pointer to a byte that will receive
+ the data
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientReadConfigSpaceByte(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ UCHAR *pucByte)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+ MGAPtr pMga = (MGAPtr)pClientStruct->pMga;
+
+ ASSERT_HANDLER(pBoard);
+
+ *pucByte = pciReadByte(pMga->PciTag,ulOffset);
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientReadConfigSpaceDword
+
+ Description : Read a Dword from the configuration space.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ ULONG *pulDword | Dword to receive the data
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientReadConfigSpaceDword(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ ULONG *pulDword)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+ MGAPtr pMga = (MGAPtr)pClientStruct->pMga;
+
+ ASSERT_HANDLER(pBoard);
+
+ *pulDword = pciReadLong(pMga->PciTag,ulOffset);
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientWriteConfigSpaceByte
+
+ Description : Write a Byte from the configuration space.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ UCHAR ucByte | Byte to receive the data
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientWriteConfigSpaceByte(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ UCHAR ucByte)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+ MGAPtr pMga = (MGAPtr)pClientStruct->pMga;
+
+ ASSERT_HANDLER(pBoard);
+
+ pciWriteByte(pMga->PciTag,ulOffset, ucByte);
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientWriteConfigSpaceDword
+
+ Description : Write a Dword from the configuration space.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ ULONG ulDword | Dword containing the data to be written
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientWriteConfigSpaceDword(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ ULONG ulDword)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+ MGAPtr pMga = (MGAPtr)pClientStruct->pMga;
+
+ ASSERT_HANDLER(pBoard);
+
+ pciWriteLong(pMga->PciTag,ulOffset, ulDword);
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientOpenRegisterBase
+
+ Description : Map the register base for future call to ClientReadRegisterX
+ and ClientWriteRegisterX.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulAddress | Physical address of the Register aperture
+ ULONG ulSize | Size in Byte of the Register Aperture
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientOpenRegisterBase(LPBOARDHANDLE pBoard, ULONG ulAddress, ULONG ulSize)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+ MGAPtr pMga = (MGAPtr)pClientStruct->pMga;
+
+ ASSERT_HANDLER(pBoard);
+
+ pClientStruct->ulRegisterBase = (ULONG) pMga->IOBase;
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientCloseRegisterBase
+
+ Description : Unmap the register base address and free resources needed
+ to address it.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientCloseRegisterBase(LPBOARDHANDLE pBoard)
+{
+ ASSERT_HANDLER(pBoard);
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientReadRegisterByte
+
+ Description : Read a byte from the Register space.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure.
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ UCHAR *pucByte | pointer to the byte that will receive
+ the data.
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientReadRegisterByte(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ UCHAR *pucByte)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+
+ ASSERT_HANDLER(pBoard);
+
+ *pucByte = *((UCHAR *)(pClientStruct->ulRegisterBase + ulOffset));
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientReadRegisterDword
+
+ Description : Read a Dword from the Register space.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ ULONG *pulDword | pointer to the dword that will receive
+ the data.
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientReadRegisterDword(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ ULONG *pulDword)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+
+ ASSERT_HANDLER(pBoard);
+
+ *pulDword = *((ULONG *)(pClientStruct->ulRegisterBase + ulOffset));
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientWriteRegisterByte
+
+ Description : Write a Byte from the Register space.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ UCHAR ucByte | CHAR to receive the data.
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientWriteRegisterByte(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ UCHAR ucByte)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+
+ ASSERT_HANDLER(pBoard);
+
+ *((UCHAR *)(pClientStruct->ulRegisterBase + ulOffset)) = ucByte;
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientWriteRegisterSpaceDword
+
+ Description : Write a Dword from the Register space.
+
+ I/O Desc. : LPBOARDHANDLE *| pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ ULONG ulDword | Dword to receive the data
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientWriteRegisterDword(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ ULONG ulDword)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+
+ ASSERT_HANDLER(pBoard);
+
+ *((ULONG *)(pClientStruct->ulRegisterBase + ulOffset)) = ulDword;
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientOpenMemoryBase
+
+ Description : Map the Memory base for future call to ClientReadMemoryX
+ and ClientWriteMemoryX.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulAddress | Physical address of the Register aperture
+ ULONG ulSize | Size in Byte of the Register Aperture
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientOpenMemoryBase(LPBOARDHANDLE pBoard, ULONG ulAddress, ULONG ulSize)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+ MGAPtr pMga = (MGAPtr) pClientStruct->pMga;
+
+ ASSERT_HANDLER(pBoard);
+
+ pClientStruct->ulFrameBufferBase = (ULONG) pMga->FbBase;
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientCloseMemoryBase
+
+ Description : Unmap the Frame Buffer aperture and free resources
+ needed to address it.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientCloseMemoryBase(LPBOARDHANDLE pBoard)
+{
+ ASSERT_HANDLER(pBoard);
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientReadMemoryByte
+
+ Description : Read a Byte from the Frame Buffer space.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ UCHAR *ucByte | CHAR to receive the data
+
+ Return Val : ULONG
+\******************************************************************************/
+ULONG ClientReadMemoryByte(LPBOARDHANDLE pBoard, ULONG ulOffset, UCHAR *pucByte)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+
+ ASSERT_HANDLER(pBoard);
+
+ *pucByte = *((UCHAR *)(pClientStruct->ulFrameBufferBase + ulOffset));
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientReadMemoryDword
+
+ Description : Read a Dword from the Frame Buffer Space.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ ULONG *uDword | Dword to receive the data
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientReadMemoryDword(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ ULONG *pulDword)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+
+ ASSERT_HANDLER(pBoard);
+
+ *pulDword = *((ULONG *)(pClientStruct->ulFrameBufferBase + ulOffset));
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientWriteMemoryByte
+
+ Description : Write a Byte from the Frame Buffer space.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ UCHAR ucByte | CHAR to receive the data
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientWriteMemoryByte(LPBOARDHANDLE pBoard, ULONG ulOffset, UCHAR ucByte)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+
+ ASSERT_HANDLER(pBoard);
+
+ *((UCHAR *)(pClientStruct->ulFrameBufferBase + ulOffset)) = ucByte;
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientWriteMemoryDword
+
+ Description : Write a Dword from the Frame Buffer space.
+
+ I/O desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ ULONG ulDword | Dword to receive the data
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientWriteMemoryDword(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ ULONG ulDword)
+{
+ LPCLIENTDATA pClientStruct = MGAGetClientPointer(pBoard);
+
+ ASSERT_HANDLER(pBoard);
+
+ *((ULONG *)(pClientStruct->ulFrameBufferBase + ulOffset)) = ulDword;
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientOpenSystemDevice
+
+ Description : Map a System device aperture for future call to
+ ClientReadSystemDeviceX and ClientWriteSystemDeviceX.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulAddress | Physical address of the Register aperture
+ ULONG ulSize | Size in Byte of the Register Aperture
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientOpenSystemDevice(LPBOARDHANDLE pBoard, ULONG ulAddress,
+ ULONG ulSize)
+{
+ return 1;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientCloseSystemDevice
+
+ Description : Unmap the System Device aperture address and free
+ resources needed to address it.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientCloseSystemDevice (LPBOARDHANDLE pBoard)
+{
+ return 1;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientReadSystemDeviceByte
+
+ Description : Read a Byte from the device Space.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ ULONG pucByte | Byte to read the data
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientReadSystemDeviceByte(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ UCHAR *pucByte)
+{
+ return 1;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientReadSystemDeviceDword
+
+ Description : Read a Dword from the Frame Buffer Space
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ ULONG ulDword | Dword to Read the data
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientReadSystemDeviceDword(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ ULONG *pulDword)
+{
+ return 1;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientWriteSystemByte
+
+ Description : Write a Byte from the System Device Aperture
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ UCHAR ucByte | Byte to receive the data
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientWriteSystemDeviceByte(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ UCHAR ucByte)
+{
+ return 1;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientWriteSystemDword
+
+ Description : Write a Dword from the System Device Aperture.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulOffset | Offset of the Byte to be read.
+ ULONG uDword | Dword to receive the data
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientWriteSystemDeviceDword(LPBOARDHANDLE pBoard, ULONG ulOffset,
+ ULONG ulDword)
+{
+ return 1;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientWait
+
+ Description : Wait for ulDelayus micro-seconds.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ ULONG ulDelayus | Delay in uSec
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientWait (LPBOARDHANDLE pBoard, ULONG ulDelayus)
+{
+ int i;
+ ULONG ulTmp;
+
+ ASSERT_HANDLER(pBoard);
+
+ for(i = 0; i < ulDelayus * 3; i++)
+ {
+ ClientReadRegisterDword(pBoard,0x1e14,&ulTmp);
+ }
+
+ return 0;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientGetBiosInfo
+
+ Description : This function will be call if no PINS can be found
+ in physical EEPROM.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ LPUCHAR | Buffer where we copy bios pins.
+ ULONG | Bios version
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientGetBiosInfo(LPBOARDHANDLE pBoard, LPUCHAR pucPins,LPULONG pulBIOSVersion)
+{
+ Bool bNotFound = TRUE;
+ UCHAR ucBIOS[32768];
+ UCHAR ucTmpByte;
+ UCHAR ucCheckSum;
+ UCHAR ucPinsIndex;
+ UCHAR ucPinsSize;
+ ULONG ulTmpDword;
+ ULONG ulPinsOffset = 0;
+ ULONG ulPCIINFOffset;
+
+ ASSERT_HANDLER(pBoard);
+
+ xf86ReadBIOS(0xc0000,0,ucBIOS,32768);
+
+ if(ucBIOS[0] == 0x55)
+ {
+ if(ucBIOS[1] == 0xaa)
+ {
+ while((ulPinsOffset < 0x10000) && bNotFound)
+ {
+ ulTmpDword = *(ULONG *)(ucBIOS + ulPinsOffset);
+ ucPinsSize = (UCHAR) (ulTmpDword >> 16);
+ if(((ulTmpDword & 0x0000ffff) == 0x0000412e)
+ && ucPinsSize <= 128)
+ {
+ ucCheckSum = 0;
+ for(ucPinsIndex = 0;ucPinsIndex < ucPinsSize; ucPinsIndex++)
+ {
+ pucPins[ucPinsIndex] = ucBIOS[ulPinsOffset +
+ ucPinsIndex];
+ ucCheckSum += pucPins[ucPinsIndex];
+ }
+ if(ucCheckSum == 0)
+ {
+ bNotFound = FALSE;
+ }
+ }
+ ulPinsOffset++;
+ }
+
+ if(bNotFound)
+ {
+ return 1;
+ }
+
+ ulPCIINFOffset = *(ULONG *)(ucBIOS + 0x18);
+ ulPCIINFOffset &= 0x0000ffff;
+ ulTmpDword = *(ULONG *)(ucBIOS + ulPCIINFOffset);
+
+ if(ulTmpDword == 0x52494350) /* "PCIR" */
+ {
+ ulPCIINFOffset += 0x12;
+ ulTmpDword = *(ULONG *)(ucBIOS + ulPCIINFOffset);
+ *pulBIOSVersion = ((ULONG) ((ulTmpDword & 0xf0) >> 4) << 16) |
+ ((ulTmpDword &0xf) << 12) | ((ulTmpDword >> 8)
+ & 0xff);
+ }
+ else
+ {
+ return 1;
+ }
+ }
+ else
+ {
+ return 1;
+ }
+ }
+ else
+ {
+ return 1;
+ }
+
+ if(!*pulBIOSVersion)
+ {
+ ucTmpByte = ucBIOS[5];
+ *pulBIOSVersion = ((ULONG) (ucTmpByte >> 4) << 16) | ((ULONG)
+ (ucTmpByte & 0x0f) << 12);
+ }
+
+ return 0;
+}
+
+/******************************************************************************\
+
+ Function : ClientCallBiosInt10
+
+ Description : Call the BIOS Int10h with specified parameters.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ LPBIOSREGS pBiosRegs | Pointor to the Bios register
+ structure.
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientCallBiosInt10(LPBOARDHANDLE pBoard, LPBIOSREGS pBiosRegs)
+{
+ ASSERT_HANDLER(pBoard);
+
+ return 1;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientReadDDCEdid
+
+ Description : Not implemented.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ LPBIOSREGS pBiosRegs | Pointor to the Bios register
+ structure.
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientReadDDCEdid(LPBOARDHANDLE pBoard, LPUCHAR pEdid,
+ ULONG ulMonitorIndex)
+{
+ ASSERT_HANDLER(pBoard);
+
+ return 1;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientCustomCall
+
+ Description : Not implemented.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ LPBIOSREGS pBiosRegs | Pointor to the Bios register
+ structure.
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientCustomCall(LPBOARDHANDLE pBoard, ULONG ulServiceNumber,
+ LPVOID pInData, LPVOID pOutData)
+{
+ ASSERT_HANDLER(pBoard);
+
+ return 1;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientApplyEpromPatch
+
+ Description : Not implemented.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ LPBIOSREGS pBiosRegs | Pointor to the Bios register
+ structure.
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientApplyEpromPatch(LPBOARDHANDLE pBoard)
+{
+ ASSERT_HANDLER(pBoard);
+
+ return 1;
+}
+
+
+/******************************************************************************\
+
+ Function : ClientDetectHostInterface
+
+ Description : Not implemented.
+
+ I/O Desc. : LPBOARDHANDLE pBoard | Handle to the board structure
+ containing all the information about a specific board.
+ LPBIOSREGS pBiosRegs | Pointor to the Bios register
+ structure.
+
+ Return Val : ULONG
+
+\******************************************************************************/
+ULONG ClientDetectHostInterface(LPBOARDHANDLE pBoard, LPULONG pulData)
+{
+ ASSERT_HANDLER(pBoard);
+
+ return 1;
+}
+
diff --git a/src/mga.h b/src/mga.h
new file mode 100644
index 0000000..5cb9750
--- /dev/null
+++ b/src/mga.h
@@ -0,0 +1,608 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga.h,v 1.85 2002/12/16 16:19:17 dawes Exp $ */
+/*
+ * MGA Millennium (MGA2064W) functions
+ *
+ * Copyright 1996 The XFree86 Project, Inc.
+ *
+ * Authors
+ * Dirk Hohndel
+ * hohndel@XFree86.Org
+ * David Dawes
+ * dawes@XFree86.Org
+ */
+
+#ifndef MGA_H
+#define MGA_H
+
+#include "compiler.h"
+#include "xaa.h"
+#include "xf86Cursor.h"
+#include "vgaHW.h"
+#include "colormapst.h"
+#include "xf86DDC.h"
+#include "xf86xv.h"
+
+
+
+#ifdef XF86DRI
+#include "xf86drm.h"
+
+
+#define _XF86DRI_SERVER_
+#include "mga_dripriv.h"
+#include "dri.h"
+#include "GL/glxint.h"
+
+
+
+
+#include "xf86dri.h"
+#include "dri.h"
+
+
+
+#include "GL/glxint.h"
+#include "mga_dri.h"
+#endif
+
+
+
+#ifdef USEMGAHAL
+#include "client.h"
+#endif
+#include "mga_bios.h"
+
+typedef enum {
+ OPTION_SW_CURSOR,
+ OPTION_HW_CURSOR,
+ OPTION_PCI_RETRY,
+ OPTION_SYNC_ON_GREEN,
+ OPTION_NOACCEL,
+ OPTION_SHOWCACHE,
+ OPTION_OVERLAY,
+ OPTION_MGA_SDRAM,
+ OPTION_SHADOW_FB,
+ OPTION_FBDEV,
+ OPTION_COLOR_KEY,
+ OPTION_SET_MCLK,
+ OPTION_OVERCLOCK_MEM,
+ OPTION_VIDEO_KEY,
+ OPTION_ROTATE,
+ OPTION_TEXTURED_VIDEO,
+ OPTION_CRTC2HALF,
+ OPTION_CRTC2RAM,
+ OPTION_INT10,
+ OPTION_AGP_MODE,
+ OPTION_AGP_SIZE,
+ OPTION_DIGITAL1,
+ OPTION_DIGITAL2,
+ OPTION_TV,
+ OPTION_TVSTANDARD,
+ OPTION_CABLETYPE,
+ OPTION_USEIRQZERO,
+ OPTION_NOHAL,
+ OPTION_SWAPPED_HEAD,
+ OPTION_DRI,
+ OPTION_MERGEDFB,
+ OPTION_HSYNC2,
+ OPTION_VREFRESH2,
+ OPTION_MONITOR2POS,
+ OPTION_METAMODES
+} MGAOpts;
+
+
+#if !defined(EXTRADEBUG)
+#define INREG8(addr) MMIO_IN8(pMga->IOBase, addr)
+#define INREG16(addr) MMIO_IN16(pMga->IOBase, addr)
+#define INREG(addr) MMIO_IN32(pMga->IOBase, addr)
+#define OUTREG8(addr, val) MMIO_OUT8(pMga->IOBase, addr, val)
+#define OUTREG16(addr, val) MMIO_OUT16(pMga->IOBase, addr, val)
+#define OUTREG(addr, val) MMIO_OUT32(pMga->IOBase, addr, val)
+#else /* !EXTRADEBUG */
+CARD8 dbg_inreg8(ScrnInfoPtr,int,int);
+CARD16 dbg_inreg16(ScrnInfoPtr,int,int);
+CARD32 dbg_inreg32(ScrnInfoPtr,int,int);
+void dbg_outreg8(ScrnInfoPtr,int,int);
+void dbg_outreg16(ScrnInfoPtr,int,int);
+void dbg_outreg32(ScrnInfoPtr,int,int);
+#define INREG8(addr) dbg_inreg8(pScrn,addr,1)
+#define INREG16(addr) dbg_inreg16(pScrn,addr,1)
+#define INREG(addr) dbg_inreg32(pScrn,addr,1)
+#define OUTREG8(addr,val) dbg_outreg8(pScrn,addr,val)
+#define OUTREG16(addr,val) dbg_outreg16(pScrn,addr,val)
+#define OUTREG(addr,val) dbg_outreg32(pScrn,addr,val)
+#endif /* EXTRADEBUG */
+
+/*
+ * Read/write to the DAC via MMIO
+ */
+
+/*
+ * These were functions. Use macros instead to avoid the need to
+ * pass pMga to them.
+ */
+
+#define inMGAdreg(reg) INREG8(RAMDAC_OFFSET + (reg))
+
+#define outMGAdreg(reg, val) OUTREG8(RAMDAC_OFFSET + (reg), val)
+
+#define inMGAdac(reg) \
+ (outMGAdreg(MGA1064_INDEX, reg), inMGAdreg(MGA1064_DATA))
+
+#define outMGAdac(reg, val) \
+ (outMGAdreg(MGA1064_INDEX, reg), outMGAdreg(MGA1064_DATA, val))
+
+#define outMGAdacmsk(reg, mask, val) \
+ do { /* note: mask and reg may get evaluated twice */ \
+ unsigned char tmp = (mask) ? (inMGAdac(reg) & (mask)) : 0; \
+ outMGAdreg(MGA1064_INDEX, reg); \
+ outMGAdreg(MGA1064_DATA, tmp | (val)); \
+ } while (0)
+
+#define PORT_OFFSET (0x1F00 - 0x300)
+
+#define MGA_VERSION 4000
+#define MGA_NAME "MGA"
+#define MGA_C_NAME MGA
+#define MGA_MODULE_DATA mgaModuleData
+#define MGA_DRIVER_NAME "mga"
+#define MGA_MAJOR_VERSION 1
+#define MGA_MINOR_VERSION 1
+#define MGA_PATCHLEVEL 0
+
+typedef struct {
+ unsigned char ExtVga[6];
+ unsigned char DacClk[6];
+ unsigned char * DacRegs;
+ unsigned long crtc2[0x58];
+ unsigned char dac2[0x21];
+ CARD32 Option;
+ CARD32 Option2;
+ CARD32 Option3;
+ long Clock;
+ Bool PIXPLLCSaved;
+} MGARegRec, *MGARegPtr;
+
+/* For programming the second CRTC */
+typedef struct {
+ CARD32 ulDispWidth; /* Display Width in pixels*/
+ CARD32 ulDispHeight; /* Display Height in pixels*/
+ CARD32 ulBpp; /* Bits Per Pixels / input format*/
+ CARD32 ulPixClock; /* Pixel Clock in kHz*/
+ CARD32 ulHFPorch; /* Horizontal front porch in pixels*/
+ CARD32 ulHSync; /* Horizontal Sync in pixels*/
+ CARD32 ulHBPorch; /* Horizontal back porch in pixels*/
+ CARD32 ulVFPorch; /* Vertical front porch in lines*/
+ CARD32 ulVSync; /* Vertical Sync in lines*/
+ CARD32 ulVBPorch; /* Vertical back Porch in lines*/
+ CARD32 ulFBPitch; /* Pitch*/
+ CARD32 flSignalMode; /* Signal Mode*/
+} xMODEINFO;
+
+
+typedef struct {
+ int brightness;
+ int contrast;
+ Bool doubleBuffer;
+ unsigned char currentBuffer;
+ FBLinearPtr linear;
+ RegionRec clip;
+ CARD32 colorKey;
+ CARD32 videoStatus;
+ Time offTime;
+ Time freeTime;
+ int lastPort;
+} MGAPortPrivRec, *MGAPortPrivPtr;
+
+typedef struct {
+ Bool isHwCursor;
+ int CursorMaxWidth;
+ int CursorMaxHeight;
+ int CursorFlags;
+ int CursorOffscreenMemSize;
+ Bool (*UseHWCursor)(ScreenPtr, CursorPtr);
+ void (*LoadCursorImage)(ScrnInfoPtr, unsigned char*);
+ void (*ShowCursor)(ScrnInfoPtr);
+ void (*HideCursor)(ScrnInfoPtr);
+ void (*SetCursorPosition)(ScrnInfoPtr, int, int);
+ void (*SetCursorColors)(ScrnInfoPtr, int, int);
+ long maxPixelClock;
+ long MemoryClock;
+ MessageType ClockFrom;
+ MessageType MemClkFrom;
+ Bool SetMemClk;
+ void (*LoadPalette)(ScrnInfoPtr, int, int*, LOCO*, VisualPtr);
+ void (*PreInit)(ScrnInfoPtr);
+ void (*Save)(ScrnInfoPtr, vgaRegPtr, MGARegPtr, Bool);
+ void (*Restore)(ScrnInfoPtr, vgaRegPtr, MGARegPtr, Bool);
+ Bool (*ModeInit)(ScrnInfoPtr, DisplayModePtr);
+} MGARamdacRec, *MGARamdacPtr;
+
+
+typedef struct {
+ int bitsPerPixel;
+ int depth;
+ int displayWidth;
+ rgb weight;
+ Bool Overlay8Plus24;
+ DisplayModePtr mode;
+} MGAFBLayout;
+
+/* Card-specific driver information */
+
+typedef struct {
+ Bool update;
+ unsigned char red;
+ unsigned char green;
+ unsigned char blue;
+} MGAPaletteInfo;
+
+#define MGAPTR(p) ((MGAPtr)((p)->driverPrivate))
+
+/*avoids segfault by returning false if pMgaHwInfo not defined*/
+#define ISDIGITAL1(p) (p->pMgaHwInfo && ((p->pMgaHwInfo->ulCapsFirstOutput) & MGAHWINFOCAPS_OUTPUT_DIGITAL))
+#define ISDIGITAL2(p) (p->pMgaHwInfo && ((p->pMgaHwInfo->ulCapsSecondOutput) & MGAHWINFOCAPS_OUTPUT_DIGITAL))
+#define ISTV1(p) (p->pMgaHwInfo && ((p->pMgaHwInfo->ulCapsFirstOutput) & MGAHWINFOCAPS_OUTPUT_TV))
+#define ISTV2(p) (p->pMgaHwInfo && ((p->pMgaHwInfo->ulCapsSecondOutput) & MGAHWINFOCAPS_OUTPUT_TV))
+
+#ifdef DISABLE_VGA_IO
+typedef struct mgaSave {
+ pciVideoPtr pvp;
+ Bool enable;
+} MgaSave, *MgaSavePtr;
+#endif
+
+
+typedef enum {
+ mgaLeftOf,
+ mgaRightOf,
+ mgaAbove,
+ mgaBelow,
+ mgaClone
+} MgaScrn2Rel;
+
+typedef struct {
+ int lastInstance;
+#ifdef USEMGAHAL
+ LPCLIENTDATA pClientStruct;
+ LPBOARDHANDLE pBoard;
+ LPMGAHWINFO pMgaHwInfo;
+#endif
+ int refCount;
+ CARD32 masterFbAddress;
+ long masterFbMapSize;
+ CARD32 slaveFbAddress;
+ long slaveFbMapSize;
+ int mastervideoRam;
+ int slavevideoRam;
+ Bool directRenderingEnabled;
+ ScrnInfoPtr pScrn_1;
+ ScrnInfoPtr pScrn_2;
+} MGAEntRec, *MGAEntPtr;
+
+typedef struct {
+#ifdef USEMGAHAL
+ LPCLIENTDATA pClientStruct;
+ LPBOARDHANDLE pBoard;
+ LPMGAMODEINFO pMgaModeInfo;
+ LPMGAHWINFO pMgaHwInfo;
+#endif
+ EntityInfoPtr pEnt;
+ MGABiosInfo Bios;
+ MGABios2Info Bios2;
+ CARD8 BiosOutputMode;
+ pciVideoPtr PciInfo;
+ PCITAG PciTag;
+ xf86AccessRec Access;
+ int Chipset;
+ int ChipRev;
+ Bool Primary;
+ Bool Interleave;
+ int HwBpp;
+ int Roundings[4];
+ int BppShifts[4];
+ Bool HasFBitBlt;
+ Bool OverclockMem;
+ int YDstOrg;
+ int DstOrg;
+ int SrcOrg;
+ unsigned long IOAddress;
+ unsigned long FbAddress;
+ unsigned long ILOADAddress;
+ int FbBaseReg;
+ unsigned long BiosAddress;
+ MessageType BiosFrom;
+ unsigned char * IOBase;
+ unsigned char * FbBase;
+ unsigned char * ILOADBase;
+ unsigned char * FbStart;
+ long FbMapSize;
+ long FbUsableSize;
+ long FbCursorOffset;
+ MGARamdacRec Dac;
+ Bool HasSDRAM;
+ Bool NoAccel;
+ Bool SyncOnGreen;
+ Bool Dac6Bit;
+ Bool HWCursor;
+ Bool UsePCIRetry;
+ Bool ShowCache;
+ Bool Overlay8Plus24;
+ Bool ShadowFB;
+ unsigned char * ShadowPtr;
+ int ShadowPitch;
+ int MemClk;
+ int MinClock;
+ int MaxClock;
+ MGARegRec SavedReg;
+ MGARegRec ModeReg;
+ int MaxFastBlitY;
+ CARD32 BltScanDirection;
+ CARD32 FilledRectCMD;
+ CARD32 SolidLineCMD;
+ CARD32 PatternRectCMD;
+ CARD32 DashCMD;
+ CARD32 NiceDashCMD;
+ CARD32 AccelFlags;
+ CARD32 PlaneMask;
+ CARD32 FgColor;
+ CARD32 BgColor;
+ CARD32 MAccess;
+ int FifoSize;
+ int StyleLen;
+ XAAInfoRecPtr AccelInfoRec;
+ xf86CursorInfoPtr CursorInfoRec;
+ DGAModePtr DGAModes;
+ int numDGAModes;
+ Bool DGAactive;
+ int DGAViewportStatus;
+ CARD32 *Atype;
+ CARD32 *AtypeNoBLK;
+ void (*PreInit)(ScrnInfoPtr pScrn);
+ void (*Save)(ScrnInfoPtr, vgaRegPtr, MGARegPtr, Bool);
+ void (*Restore)(ScrnInfoPtr, vgaRegPtr, MGARegPtr, Bool);
+ Bool (*ModeInit)(ScrnInfoPtr, DisplayModePtr);
+ void (*PointerMoved)(int index, int x, int y);
+ CloseScreenProcPtr CloseScreen;
+ ScreenBlockHandlerProcPtr BlockHandler;
+ unsigned int (*ddc1Read)(ScrnInfoPtr);
+ void (*DDC1SetSpeed)(ScrnInfoPtr, xf86ddcSpeed);
+ Bool (*i2cInit)(ScrnInfoPtr);
+ I2CBusPtr I2C;
+ Bool FBDev;
+ int colorKey;
+ int videoKey;
+ int fifoCount;
+ int Rotate;
+ MGAFBLayout CurrentLayout;
+ Bool DrawTransparent;
+ int MaxBlitDWORDS;
+ Bool TexturedVideo;
+ MGAPortPrivPtr portPrivate;
+ unsigned char *ScratchBuffer;
+ unsigned char *ColorExpandBase;
+ int expandRows;
+ int expandDWORDs;
+ int expandRemaining;
+ int expandHeight;
+ int expandY;
+#ifdef XF86DRI
+ Bool directRenderingEnabled;
+ DRIInfoPtr pDRIInfo;
+ int drmFD;
+ int numVisualConfigs;
+ __GLXvisualConfig* pVisualConfigs;
+ MGAConfigPrivPtr pVisualConfigsPriv;
+ MGADRIServerPrivatePtr DRIServerInfo;
+
+ MGARegRec DRContextRegs;
+
+ Bool haveQuiescense;
+ void (*GetQuiescence)(ScrnInfoPtr pScrn);
+
+ int agpMode;
+ int agpSize;
+
+ int irq;
+ CARD32 reg_ien;
+#endif
+ XF86VideoAdaptorPtr adaptor;
+ Bool DualHeadEnabled;
+ Bool SecondCrtc;
+ Bool SecondOutput;
+ GDevPtr device;
+ /* The hardware's real SrcOrg */
+ int realSrcOrg;
+ MGAEntPtr entityPrivate;
+ void (*SetupForSolidFill)(ScrnInfoPtr pScrn, int color,
+ int rop, unsigned int planemask);
+ void (*SubsequentSolidFillRect)(ScrnInfoPtr pScrn,
+ int x, int y, int w, int h);
+ void (*RestoreAccelState)(ScrnInfoPtr pScrn);
+ int allowedWidth;
+ void (*VideoTimerCallback)(ScrnInfoPtr, Time);
+ void (*PaletteLoadCallback)(ScrnInfoPtr);
+ void (*RenderCallback)(ScrnInfoPtr);
+ Time RenderTime;
+ MGAPaletteInfo palinfo[256]; /* G400 hardware bug workaround */
+ FBLinearPtr LinearScratch;
+ Bool softbooted;
+#ifdef USEMGAHAL
+ Bool HALLoaded;
+#endif
+ OptionInfoPtr Options;
+/* Merged Framebuffer data */
+ Bool MergedFB;
+
+ /* Real values specific to monitor1, since the original ones are replaced */
+ DisplayModePtr M1modes; /* list of actual modes */
+ DisplayModePtr M1currentMode; /* current mode */
+ int M1frameX0; /* viewport position */
+ int M1frameY0;
+ int M1frameX1;
+ int M1frameY1;
+
+ ScrnInfoPtr pScrn2; /*pointer to second CRTC screeninforec,
+ if in merged mode */
+/* End of Merged Framebuffer Data */
+ int HALGranularityOffX, HALGranularityOffY;
+} MGARec, *MGAPtr;
+
+extern CARD32 MGAAtype[16];
+extern CARD32 MGAAtypeNoBLK[16];
+
+#define USE_RECTS_FOR_LINES 0x00000001
+#define FASTBLT_BUG 0x00000002
+#define CLIPPER_ON 0x00000004
+#define BLK_OPAQUE_EXPANSION 0x00000008
+#define TRANSC_SOLID_FILL 0x00000010
+#define NICE_DASH_PATTERN 0x00000020
+#define TWO_PASS_COLOR_EXPAND 0x00000040
+#define MGA_NO_PLANEMASK 0x00000080
+#define USE_LINEAR_EXPANSION 0x00000100
+#define LARGE_ADDRESSES 0x00000200
+
+#define MGAIOMAPSIZE 0x00004000
+#define MGAILOADMAPSIZE 0x00400000
+
+#define TRANSPARENCY_KEY 255
+#define KEY_COLOR 0
+
+
+/* Prototypes */
+
+void MGAAdjustFrame(int scrnIndex, int x, int y, int flags);
+Bool MGASwitchMode(int scrnIndex, DisplayModePtr mode, int flags);
+void MGAFillModeInfoStruct(ScrnInfoPtr pScrn, DisplayModePtr mode);
+Bool MGAGetRec(ScrnInfoPtr pScrn);
+void MGAProbeDDC(ScrnInfoPtr pScrn, int index);
+void MGASoftReset(ScrnInfoPtr pScrn);
+void MGAFreeRec(ScrnInfoPtr pScrn);
+void MGAReadBios(ScrnInfoPtr pScrn);
+void MGADisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode,
+ int flags);
+void MGAAdjustFrameCrtc2(int scrnIndex, int x, int y, int flags);
+void MGADisplayPowerManagementSetCrtc2(ScrnInfoPtr pScrn,
+ int PowerManagementMode,
+ int flags);
+void MGAAdjustGranularity(ScrnInfoPtr pScrn, int* x, int* y);
+
+
+void MGA2064SetupFuncs(ScrnInfoPtr pScrn);
+void MGAGSetupFuncs(ScrnInfoPtr pScrn);
+
+void MGAStormSync(ScrnInfoPtr pScrn);
+void MGAStormEngineInit(ScrnInfoPtr pScrn);
+Bool MGAStormAccelInit(ScreenPtr pScreen);
+Bool MGAHWCursorInit(ScreenPtr pScreen);
+
+Bool Mga8AccelInit(ScreenPtr pScreen);
+Bool Mga16AccelInit(ScreenPtr pScreen);
+Bool Mga24AccelInit(ScreenPtr pScreen);
+Bool Mga32AccelInit(ScreenPtr pScreen);
+
+void Mga8InitSolidFillRectFuncs(MGAPtr pMga);
+void Mga16InitSolidFillRectFuncs(MGAPtr pMga);
+void Mga24InitSolidFillRectFuncs(MGAPtr pMga);
+void Mga32InitSolidFillRectFuncs(MGAPtr pMga);
+
+void MGAPolyArcThinSolid(DrawablePtr, GCPtr, int, xArc*);
+
+Bool MGADGAInit(ScreenPtr pScreen);
+
+void MGARefreshArea(ScrnInfoPtr pScrn, int num, BoxPtr pbox);
+void MGARefreshArea8(ScrnInfoPtr pScrn, int num, BoxPtr pbox);
+void MGARefreshArea16(ScrnInfoPtr pScrn, int num, BoxPtr pbox);
+void MGARefreshArea24(ScrnInfoPtr pScrn, int num, BoxPtr pbox);
+void MGARefreshArea32(ScrnInfoPtr pScrn, int num, BoxPtr pbox);
+
+void Mga8SetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir,
+ int ydir, int rop, unsigned int planemask,
+ int trans);
+void Mga16SetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir,
+ int ydir, int rop, unsigned int planemask,
+ int trans);
+void Mga24SetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir,
+ int ydir, int rop, unsigned int planemask,
+ int trans);
+void Mga32SetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir,
+ int ydir, int rop, unsigned int planemask,
+ int trans);
+
+void Mga8SetupForSolidFill(ScrnInfoPtr pScrn, int color, int rop,
+ unsigned int planemask);
+void Mga16SetupForSolidFill(ScrnInfoPtr pScrn, int color, int rop,
+ unsigned int planemask);
+void Mga24SetupForSolidFill(ScrnInfoPtr pScrn, int color, int rop,
+ unsigned int planemask);
+void Mga32SetupForSolidFill(ScrnInfoPtr pScrn, int color, int rop,
+ unsigned int planemask);
+
+void MGAPointerMoved(int index, int x, int y);
+
+void MGAInitVideo(ScreenPtr pScreen);
+void MGAResetVideo(ScrnInfoPtr pScrn);
+
+#ifdef XF86DRI
+
+#define MGA_FRONT 0x1
+#define MGA_BACK 0x2
+#define MGA_DEPTH 0x4
+
+Bool MGADRIScreenInit( ScreenPtr pScreen );
+void MGADRICloseScreen( ScreenPtr pScreen );
+Bool MGADRIFinishScreenInit( ScreenPtr pScreen );
+
+Bool MGALockUpdate( ScrnInfoPtr pScrn, drmLockFlags flags );
+
+void MGAGetQuiescence( ScrnInfoPtr pScrn );
+void MGAGetQuiescenceShared( ScrnInfoPtr pScrn );
+
+void MGASelectBuffer(ScrnInfoPtr pScrn, int which);
+Bool MgaCleanupDma(ScrnInfoPtr pScrn);
+Bool MgaInitDma(ScrnInfoPtr pScrn, int prim_size);
+
+#define MGA_AGP_1X_MODE 0x01
+#define MGA_AGP_2X_MODE 0x02
+#define MGA_AGP_4X_MODE 0x04
+#define MGA_AGP_MODE_MASK 0x07
+
+#endif
+
+void MGACRTC2Set(ScrnInfoPtr pScrn, xMODEINFO *pModeInfo);
+void MGAEnableSecondOutPut(ScrnInfoPtr pScrn, xMODEINFO *pModeInfo);
+void MGACRTC2SetPitch(ScrnInfoPtr pSrcn, xMODEINFO *pModeInfo);
+void MGACRTC2SetDisplayStart(ScrnInfoPtr pScrn, xMODEINFO *pModeInfo, CARD32 base, CARD32 ulX, CARD32 ulY);
+
+void MGACRTC2Get(ScrnInfoPtr pScrn, xMODEINFO *pModeInfo);
+void MGACRTC2GetPitch(ScrnInfoPtr pSrcn, xMODEINFO *pModeInfo);
+void MGACRTC2GetDisplayStart(ScrnInfoPtr pScrn, xMODEINFO *pModeInfo, CARD32 base, CARD32 ulX, CARD32 ulY);
+
+double MGAG450SetPLLFreq(ScrnInfoPtr pScrn, long f_out);
+#ifdef DEBUG
+void MGAG450PrintPLL(ScrnInfoPtr pScrn);
+#endif
+long MGAG450SavePLLFreq(ScrnInfoPtr pScrn);
+void MGAprintDac(ScrnInfoPtr pScrn);
+
+#ifdef USEMGAHAL
+/************ ESC Call Definition ***************/
+typedef struct {
+ char *function;
+ void (*funcptr)(ScrnInfoPtr pScrn, unsigned long *param, char *out, DisplayModePtr pMode);
+} MGAEscFuncRec, *MGAEscFuncPtr;
+
+typedef struct {
+ char function[32];
+ unsigned long parameters[32];
+} EscCmdStruct;
+
+extern LPMGAMODEINFO pMgaModeInfo[2];
+extern MGAMODEINFO TmpMgaModeInfo[2];
+
+extern void MGAExecuteEscCmd(ScrnInfoPtr pScrn, char *cmdline , char *sResult, DisplayModePtr pMode);
+void MGAFillDisplayModeStruct(DisplayModePtr pMode, LPMGAMODEINFO pModeInfo);
+/************************************************/
+#endif
+
+#endif
diff --git a/src/mga_arc.c b/src/mga_arc.c
new file mode 100644
index 0000000..1045cfa
--- /dev/null
+++ b/src/mga_arc.c
@@ -0,0 +1,225 @@
+/************************************************************
+
+Copyright 1989, 1998 The Open Group
+
+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.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_arc.c,v 1.10 2001/12/14 19:59:51 dawes Exp $ */
+
+
+#include "X.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "regionstr.h"
+#include "Xprotostr.h"
+#include "miscstruct.h"
+#include "mizerarc.h"
+#include "mi.h"
+#include "scrnintstr.h"
+#include "xaa.h"
+#include "xaalocal.h"
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+
+#include "xf86Pci.h"
+
+#include "mga_bios.h"
+#include "mga.h"
+#include "mga_reg.h"
+#include "mga_macros.h"
+
+
+/*
+ This is only faster than cfb for stuff other than GXcopy.
+ And even then, only when pci_retries are on.
+*/
+
+
+#define DRAW_POINT(x, y) { \
+ tmp = x; \
+ OUTREG(MGAREG_FXBNDRY, (tmp) | (((tmp) + 1) << 16)); \
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, ((y) << 16) | 1); \
+}
+
+static void
+MGAZeroArc(
+ DrawablePtr pDraw,
+ GCPtr pGC,
+ xArc *arc
+){
+ int yoffset, dyoffset, x, y, a, b, d, mask, k1, k3, dx, dy, tmp;
+ XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+ MGAPtr pMga = MGAPTR(infoRec->pScrn);
+ miZeroArcRec info;
+ Bool do360;
+ DDXPointRec org, orgo;
+
+ CHECK_DMA_QUIESCENT( pMga, infoRec->pScrn );
+
+ (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel,
+ pGC->alu, pGC->planemask);
+
+ do360 = miZeroArcSetup(arc, &info, TRUE);
+ org.y = info.yorg + pDraw->y;
+ org.x = 0;
+ orgo.y = info.yorgo + pDraw->y;
+ orgo.x = 0;
+ info.xorg += pDraw->x;
+ info.xorgo += pDraw->x;
+
+ MIARCSETUP();
+ yoffset = y ? 1 : 0;
+ dyoffset = 0;
+ mask = info.initialMask;
+ if (!(arc->width & 1)) {
+ WAITFIFO(4);
+ if (mask & 2)
+ DRAW_POINT(info.xorgo, org.y);
+ if (mask & 8)
+ DRAW_POINT(info.xorgo, orgo.y);
+ }
+ if (!info.end.x || !info.end.y) {
+ mask = info.end.mask;
+ info.end = info.altend;
+ }
+ if (do360 && (arc->width == arc->height) && !(arc->width & 1)) {
+ int xoffset = 1;
+ DDXPointRec orghb, orgohb;
+
+ orghb.y = org.y + info.h;
+ orghb.x = org.x + info.xorg;
+ orgohb.y = orghb.y;
+ orgohb.x = orghb.x - info.h;
+
+ org.x += info.xorg;
+ orgo.x += info.xorg;
+ orghb.x += info.h;
+ while (1) {
+ WAITFIFO(16);
+ DRAW_POINT(org.x + x, org.y + yoffset);
+ DRAW_POINT(org.x - x, org.y + yoffset);
+ DRAW_POINT(orgo.x - x, orgo.y - yoffset);
+ DRAW_POINT(orgo.x + x, orgo.y - yoffset);
+ if (a < 0) break;
+ DRAW_POINT(orghb.x - y, orghb.y - xoffset);
+ DRAW_POINT(orgohb.x + y, orgohb.y - xoffset);
+ DRAW_POINT(orgohb.x + y, orgohb.y + xoffset);
+ DRAW_POINT(orghb.x - y, orghb.y + xoffset);
+ xoffset ++;
+ MIARCCIRCLESTEP(yoffset ++;);
+ }
+ org.x -= info.xorg;
+ orgo.x -= info.xorg;
+ x = info.w;
+ yoffset = info.h;
+ }
+ else if (do360) {
+ while (y < info.h || x < info.w) {
+ MIARCOCTANTSHIFT(dyoffset = 1;);
+ WAITFIFO(8);
+ DRAW_POINT(org.x + info.xorg + x, org.y + yoffset);
+ DRAW_POINT(org.x + info.xorgo - x, org.y + yoffset);
+ DRAW_POINT(orgo.x + info.xorgo - x, orgo.y - yoffset);
+ DRAW_POINT(orgo.x + info.xorg + x, orgo.y - yoffset);
+ MIARCSTEP(yoffset += dyoffset;, yoffset++;);
+ }
+ }
+ else {
+ while (y < info.h || x < info.w) {
+ MIARCOCTANTSHIFT(dyoffset = 1;);
+ if ((x == info.start.x) || (y == info.start.y)) {
+ mask = info.start.mask;
+ info.start = info.altstart;
+ }
+ WAITFIFO(8);
+ if (mask & 1)
+ DRAW_POINT(org.x + info.xorg + x, org.y + yoffset);
+ if (mask & 2)
+ DRAW_POINT(org.x + info.xorgo - x, org.y + yoffset);
+ if (mask & 4)
+ DRAW_POINT(orgo.x + info.xorgo - x, orgo.y - yoffset);
+ if (mask & 8)
+ DRAW_POINT(orgo.x + info.xorg + x, orgo.y - yoffset);
+ if ((x == info.end.x) || (y == info.end.y)) {
+ mask = info.end.mask;
+ info.end = info.altend;
+ }
+ MIARCSTEP(yoffset += dyoffset;, yoffset++;);
+ }
+ }
+ if ((x == info.start.x) || (y == info.start.y))
+ mask = info.start.mask;
+
+ WAITFIFO(4);
+ if (mask & 1)
+ DRAW_POINT(org.x + info.xorg + x, org.y + yoffset);
+ if (mask & 4)
+ DRAW_POINT(orgo.x + info.xorgo - x, orgo.y - yoffset);
+ if (arc->height & 1) {
+ WAITFIFO(4);
+ if (mask & 2)
+ DRAW_POINT(org.x + info.xorgo - x, org.y + yoffset);
+ if (mask & 8)
+ DRAW_POINT(orgo.x + info.xorg + x, orgo.y - yoffset);
+ }
+
+ SET_SYNC_FLAG(infoRec);
+}
+
+void
+MGAPolyArcThinSolid (
+ DrawablePtr pDraw,
+ GCPtr pGC,
+ int narcs,
+ xArc *parcs
+){
+ xArc *arc;
+ BoxRec box;
+ int i, x2, y2;
+ RegionPtr cclip;
+
+ cclip = pGC->pCompositeClip;
+
+ if(!REGION_NUM_RECTS(cclip))
+ return;
+
+ for (arc = parcs, i = narcs; --i >= 0; arc++) {
+ if (miCanZeroArc(arc)) {
+ box.x1 = arc->x + pDraw->x;
+ box.y1 = arc->y + pDraw->y;
+ x2 = box.x1 + (int)arc->width + 1;
+ box.x2 = x2;
+ y2 = box.y1 + (int)arc->height + 1;
+ box.y2 = y2;
+ if ( (x2 <= MAXSHORT) && (y2 <= MAXSHORT) &&
+ (RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN) )
+ MGAZeroArc (pDraw, pGC, arc);
+ else
+ miZeroPolyArc(pDraw, pGC, 1, arc);
+ }
+ else
+ miPolyArc(pDraw, pGC, 1, arc);
+ }
+}
+
diff --git a/src/mga_common.h b/src/mga_common.h
new file mode 100644
index 0000000..90f6b37
--- /dev/null
+++ b/src/mga_common.h
@@ -0,0 +1,152 @@
+/* mga_common.h -- common header definitions for MGA 2D/3D/DRM suite
+ *
+ * Copyright 2002 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Converted to common header format:
+ * Jens Owen <jens@tungstengraphics.com>
+ *
+ * $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_common.h,v 1.2 2002/12/16 16:19:18 dawes Exp $
+ *
+ */
+
+#ifndef _MGA_COMMON_H_
+#define _MGA_COMMON_H_
+
+/*
+ * WARNING: If you change any of these defines, make sure to change
+ * the kernel include file as well (mga_drm.h)
+ */
+
+#define DRM_MGA_IDLE_RETRY 2048
+#define DRM_MGA_NR_TEX_HEAPS 2
+
+typedef struct {
+ int installed;
+ unsigned long phys_addr;
+ int size;
+} drmMGAWarpIndex;
+
+/* Driver specific DRM command indices
+ * NOTE: these are not OS specific, but they are driver specific
+ */
+#define DRM_MGA_INIT 0x00
+#define DRM_MGA_FLUSH 0x01
+#define DRM_MGA_RESET 0x02
+#define DRM_MGA_SWAP 0x03
+#define DRM_MGA_CLEAR 0x04
+#define DRM_MGA_VERTEX 0x05
+#define DRM_MGA_INDICES 0x06
+#define DRM_MGA_ILOAD 0x07
+#define DRM_MGA_BLIT 0x08
+#define DRM_MGA_GETPARAM 0x09
+
+typedef struct {
+ enum {
+ MGA_INIT_DMA = 0x01,
+ MGA_CLEANUP_DMA = 0x02
+ } func;
+
+ unsigned long sarea_priv_offset;
+
+ int chipset;
+ int sgram;
+
+ unsigned int maccess;
+
+ unsigned int fb_cpp;
+ unsigned int front_offset, front_pitch;
+ unsigned int back_offset, back_pitch;
+
+ unsigned int depth_cpp;
+ unsigned int depth_offset, depth_pitch;
+
+ unsigned int texture_offset[DRM_MGA_NR_TEX_HEAPS];
+ unsigned int texture_size[DRM_MGA_NR_TEX_HEAPS];
+
+ unsigned long fb_offset;
+ unsigned long mmio_offset;
+ unsigned long status_offset;
+ unsigned long warp_offset;
+ unsigned long primary_offset;
+ unsigned long buffers_offset;
+} drmMGAInit;
+
+typedef enum {
+ DRM_MGA_LOCK_READY = 0x01, /* Wait until hardware is ready for DMA */
+ DRM_MGA_LOCK_QUIESCENT = 0x02, /* Wait until hardware quiescent */
+ DRM_MGA_LOCK_FLUSH = 0x04, /* Flush this context's DMA queue first */
+ DRM_MGA_LOCK_FLUSH_ALL = 0x08, /* Flush all DMA queues first */
+ /* These *HALT* flags aren't supported yet
+ -- they will be used to support the
+ full-screen DGA-like mode. */
+ DRM_MGA_HALT_ALL_QUEUES = 0x10, /* Halt all current and future queues */
+ DRM_MGA_HALT_CUR_QUEUES = 0x20 /* Halt all current queues */
+} drmMGALockFlags;
+
+typedef struct {
+ int context;
+ drmMGALockFlags flags;
+} drmMGALock;
+
+typedef struct {
+ int idx;
+ unsigned int dstorg;
+ unsigned int length;
+} drmMGAIload;
+
+typedef struct {
+ unsigned int flags;
+ unsigned int clear_color;
+ unsigned int clear_depth;
+ unsigned int color_mask;
+ unsigned int depth_mask;
+} drmMGAClearRec;
+
+typedef struct {
+ int idx; /* buffer to queue */
+ int used; /* bytes in use */
+ int discard; /* client finished with buffer? */
+} drmMGAVertex;
+
+typedef struct {
+ unsigned int planemask;
+ unsigned int srcorg;
+ unsigned int dstorg;
+ int src_pitch, dst_pitch;
+ int delta_sx, delta_sy;
+ int delta_dx, delta_dy;
+ int height, ydir; /* flip image vertically */
+ int source_pitch, dest_pitch;
+} drmMGABlit;
+
+/* 3.1: An ioctl to get parameters that aren't available to the 3d
+ * client any other way.
+ */
+#define MGA_PARAM_IRQ_NR 1
+
+typedef struct {
+ int param;
+ int *value;
+} drmMGAGetParam;
+
+#endif
diff --git a/src/mga_dac3026.c b/src/mga_dac3026.c
new file mode 100644
index 0000000..220ef1a
--- /dev/null
+++ b/src/mga_dac3026.c
@@ -0,0 +1,1288 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_dac3026.c,v 1.56 2001/04/05 21:29:14 dawes Exp $ */
+/*
+ * Copyright 1994 by Robin Cutshaw <robin@XFree86.org>
+ *
+ * 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 Robin Cutshaw not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Robin Cutshaw makes no representations
+ * about the suitability of this software for any purpose. It is provided
+ * "as is" without express or implied warranty.
+ *
+ * ROBIN CUTSHAW DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL ROBIN CUTSHAW 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.
+ *
+ *
+ * Modified for TVP3026 by Harald Koenig <koenig@tat.physik.uni-tuebingen.de>
+ *
+ * Modified for MGA Millennium by Xavier Ducoin <xavier@rd.lectra.fr>
+ *
+ * Doug Merritt <doug@netcom.com>
+ * 24bpp: fixed high res stripe glitches, clock glitches on all res
+ *
+ */
+
+
+/*
+ * This is a first cut at a non-accelerated version to work with the
+ * new server design (DHD).
+ */
+
+/* All drivers should typically include these */
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+
+/* Drivers for PCI hardware need this */
+#include "xf86PciInfo.h"
+
+/* Drivers that need to access the PCI config space directly need this */
+#include "xf86Pci.h"
+
+#include "mga_bios.h"
+#include "mga_reg.h"
+#include "mga.h"
+#include "mga_macros.h"
+
+#include "xf86DDC.h"
+
+/*
+ * Only change these bits in the Option register. Make sure that the
+ * vgaioen bit is never in this mask because it is controlled elsewhere
+ */
+#define OPTION_MASK 0xFFEFFEFF /* ~(eepromwt | vgaioen) */
+
+static void MGA3026LoadPalette(ScrnInfoPtr, int, int*, LOCO*, VisualPtr);
+static void MGA3026SavePalette(ScrnInfoPtr, unsigned char*);
+static void MGA3026RestorePalette(ScrnInfoPtr, unsigned char*);
+static void MGA3026RamdacInit(ScrnInfoPtr);
+static void MGA3026Save(ScrnInfoPtr, vgaRegPtr, MGARegPtr, Bool);
+static void MGA3026Restore(ScrnInfoPtr, vgaRegPtr, MGARegPtr, Bool);
+static Bool MGA3026Init(ScrnInfoPtr, DisplayModePtr);
+static Bool MGA3026_i2cInit(ScrnInfoPtr pScrn);
+
+
+/*
+ * implementation
+ */
+
+/*
+ * indexes to ti3026 registers (the order is important)
+ */
+const static unsigned char MGADACregs[] = {
+ 0x0F, 0x18, 0x19, 0x1A, 0x1C, 0x1D, 0x1E, 0x2A, 0x2B, 0x30,
+ 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
+ 0x06
+};
+
+/* note: to fix a cursor hw glitch, register 0x37 (blue color key) needs
+ to be set to magic numbers, even though they are "never" used because
+ blue keying disabled in 0x38.
+
+ Matrox sez:
+
+ ...The more precise statement of the software workaround is to insure
+ that bits 7-5 of register 0x37 (Blue Color Key High) and bits 7-5 of
+ register 0x38 (HZOOM)are the same...
+*/
+
+/* also note: the values of the MUX control register 0x19 (index [2]) can be
+ found in table 2-17 of the 3026 manual. If interlace is set, the values
+ listed here are incremented by one.
+*/
+
+#define DACREGSIZE sizeof(MGADACregs)
+/*
+ * initial values of ti3026 registers
+ */
+const static unsigned char MGADACbpp8[DACREGSIZE] = {
+ 0x06, 0x80, 0x4b, 0x25, 0x00, 0x00, 0x0C, 0x00, 0x1E, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0, 0x00,
+ 0x00
+};
+const static unsigned char MGADACbpp16[DACREGSIZE] = {
+ 0x07, 0x45, 0x53, 0x15, 0x00, 0x00, 0x2C, 0x00, 0x1E, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x10, 0, 0x00,
+ 0x00
+};
+/*
+ * [0] value was 0x07, but changed to 0x06 by Doug Merrit to fix high res
+ * stripe glitches and clock glitches at 24bpp.
+ */
+/* [0] value is now set inside of MGA3026Init, based on the silicon revision
+ It is still set to 7 or 6 based on the revision, though, since setting to
+ 8 as in the documentation makes (some?) revB chips get the colors wrong...
+ maybe BGR instead of RGB? This only applies to 24bpp, since it is the only
+ one documented as depending on revision.
+ */
+
+const static unsigned char MGADACbpp24[DACREGSIZE] = {
+ 0x06, 0x56, 0x5b, 0x25, 0x00, 0x00, 0x2C, 0x00, 0x1E, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x10, 0, 0x00,
+ 0x00
+};
+const static unsigned char MGADACbpp32[DACREGSIZE] = {
+ 0x07, 0x46, 0x5b, 0x05, 0x00, 0x00, 0x2C, 0x00, 0x1E, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x10, 0, 0x00,
+ 0x00
+};
+
+/* on at least some 2064Ws, the PSEL line flips at 4MB or so, so PSEL keying
+ has to be off in register 0x1e -> bit4 clear */
+
+const static unsigned char MGADACbpp8plus24[DACREGSIZE] = {
+ 0x07, 0x06, 0x5b, 0x05, 0x00, 0x00, 0x2C, 0x00, 0x1E, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x00,
+ 0x00
+};
+
+/*
+ * Read/write to the DAC via MMIO
+ */
+
+/*
+ * These were functions. Use macros instead to avoid the need to
+ * pass pMga to them.
+ */
+
+#define inTi3026dreg(reg) INREG8(RAMDAC_OFFSET + (reg))
+
+#define outTi3026dreg(reg, val) OUTREG8(RAMDAC_OFFSET + (reg), val)
+
+#define inTi3026(reg) \
+ (outTi3026dreg(TVP3026_INDEX, reg), inTi3026dreg(TVP3026_DATA))
+
+#define outTi3026(reg, mask, val) \
+ do { /* note: mask and reg may get evaluated twice */ \
+ unsigned char tmp = (mask) ? (inTi3026(reg) & (mask)) : 0; \
+ outTi3026dreg(TVP3026_INDEX, reg); \
+ outTi3026dreg(TVP3026_DATA, tmp | (val)); \
+ } while (0)
+
+
+/*
+ * MGATi3026CalcClock - Calculate the PLL settings (m, n, p).
+ *
+ * DESCRIPTION
+ * For more information, refer to the Texas Instruments
+ * "TVP3026 Data Manual" (document SLAS098B).
+ * Section 2.4 "PLL Clock Generators"
+ * Appendix A "Frequency Synthesis PLL Register Settings"
+ * Appendix B "PLL Programming Examples"
+ *
+ * PARAMETERS
+ * f_out IN Desired clock frequency.
+ * f_max IN Maximum allowed clock frequency.
+ * m OUT Value of PLL 'm' register.
+ * n OUT Value of PLL 'n' register.
+ * p OUT Value of PLL 'p' register.
+ *
+ * HISTORY
+ * January 11, 1997 - [aem] Andrew E. Mileski
+ * Split off from MGATi3026SetClock.
+ */
+
+/* The following values are in kHz */
+#define TI_MIN_VCO_FREQ 110000
+#define TI_MAX_VCO_FREQ 220000
+#define TI_MAX_MCLK_FREQ 100000
+#define TI_REF_FREQ 14318.18
+
+static double
+MGATi3026CalcClock (
+ long f_out, long f_max,
+ int *m, int *n, int *p
+){
+ int best_m = 0, best_n = 0;
+ double f_pll, f_vco;
+ double m_err, inc_m, calc_m;
+
+ /* Make sure that f_min <= f_out <= f_max */
+ if ( f_out < ( TI_MIN_VCO_FREQ / 8 ))
+ f_out = TI_MIN_VCO_FREQ / 8;
+ if ( f_out > f_max )
+ f_out = f_max;
+
+ /*
+ * f_pll = f_vco / 2 ^ p
+ * Choose p so that TI_MIN_VCO_FREQ <= f_vco <= TI_MAX_VCO_FREQ
+ * Note that since TI_MAX_VCO_FREQ = 2 * TI_MIN_VCO_FREQ
+ * we don't have to bother checking for this maximum limit.
+ */
+ f_vco = ( double ) f_out;
+ for ( *p = 0; *p < 3 && f_vco < TI_MIN_VCO_FREQ; ( *p )++ )
+ f_vco *= 2.0;
+
+ /*
+ * We avoid doing multiplications by ( 65 - n ),
+ * and add an increment instead - this keeps any error small.
+ */
+ inc_m = f_vco / ( TI_REF_FREQ * 8.0 );
+
+ /* Initial value of calc_m for the loop */
+ calc_m = inc_m + inc_m + inc_m;
+
+ /* Initial amount of error for an integer - impossibly large */
+ m_err = 2.0;
+
+ /* Search for the closest INTEGER value of ( 65 - m ) */
+ for ( *n = 3; *n <= 25; ( *n )++, calc_m += inc_m ) {
+
+ /* Ignore values of ( 65 - m ) which we can't use */
+ if ( calc_m < 3.0 || calc_m > 64.0 )
+ continue;
+
+ /*
+ * Pick the closest INTEGER (has smallest fractional part).
+ * The optimizer should clean this up for us.
+ */
+ if (( calc_m - ( int ) calc_m ) < m_err ) {
+ m_err = calc_m - ( int ) calc_m;
+ best_m = ( int ) calc_m;
+ best_n = *n;
+ }
+ }
+
+ /* 65 - ( 65 - x ) = x */
+ *m = 65 - best_m;
+ *n = 65 - best_n;
+
+ /* Now all the calculations can be completed */
+ f_vco = 8.0 * TI_REF_FREQ * best_m / best_n;
+ f_pll = f_vco / ( 1 << *p );
+
+#ifdef DEBUG
+ ErrorF( "f_out=%ld f_pll=%.1f f_vco=%.1f n=%d m=%d p=%d\n",
+ f_out, f_pll, f_vco, *n, *m, *p );
+#endif
+
+ return f_pll;
+}
+
+/*
+ * MGATi3026SetMCLK - Set the memory clock (MCLK) PLL.
+ *
+ * HISTORY
+ * January 11, 1997 - [aem] Andrew E. Mileski
+ * Written and tested.
+ */
+static void
+MGATi3026SetMCLK( ScrnInfoPtr pScrn, long f_out )
+{
+ double f_pll;
+ int mclk_m, mclk_n, mclk_p;
+ int pclk_m, pclk_n, pclk_p;
+ int mclk_ctl;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ f_pll = MGATi3026CalcClock(
+ f_out, TI_MAX_MCLK_FREQ,
+ & mclk_m, & mclk_n, & mclk_p
+ );
+
+ /* Save PCLK settings */
+ outTi3026( TVP3026_PLL_ADDR, 0, 0xfc );
+ pclk_n = inTi3026( TVP3026_PIX_CLK_DATA );
+ outTi3026( TVP3026_PLL_ADDR, 0, 0xfd );
+ pclk_m = inTi3026( TVP3026_PIX_CLK_DATA );
+ outTi3026( TVP3026_PLL_ADDR, 0, 0xfe );
+ pclk_p = inTi3026( TVP3026_PIX_CLK_DATA );
+
+ /* Stop PCLK (PLLEN = 0, PCLKEN = 0) */
+ outTi3026( TVP3026_PLL_ADDR, 0, 0xfe );
+ outTi3026( TVP3026_PIX_CLK_DATA, 0, 0x00 );
+
+ /* Set PCLK to the new MCLK frequency (PLLEN = 1, PCLKEN = 0 ) */
+ outTi3026( TVP3026_PLL_ADDR, 0, 0xfc );
+ outTi3026( TVP3026_PIX_CLK_DATA, 0, ( mclk_n & 0x3f ) | 0xc0 );
+ outTi3026( TVP3026_PIX_CLK_DATA, 0, mclk_m & 0x3f );
+ outTi3026( TVP3026_PIX_CLK_DATA, 0, ( mclk_p & 0x03 ) | 0xb0 );
+
+ /* Wait for PCLK PLL to lock on frequency */
+ while (( inTi3026( TVP3026_PIX_CLK_DATA ) & 0x40 ) == 0 ) {
+ ;
+ }
+
+ /* Output PCLK on MCLK pin */
+ mclk_ctl = inTi3026( TVP3026_MCLK_CTL );
+ outTi3026( TVP3026_MCLK_CTL, 0, mclk_ctl & 0xe7 );
+ outTi3026( TVP3026_MCLK_CTL, 0, ( mclk_ctl & 0xe7 ) | 0x08 );
+
+ /* Stop MCLK (PLLEN = 0 ) */
+ outTi3026( TVP3026_PLL_ADDR, 0, 0xfb );
+ outTi3026( TVP3026_MEM_CLK_DATA, 0, 0x00 );
+
+ /* Set MCLK to the new frequency (PLLEN = 1) */
+ outTi3026( TVP3026_PLL_ADDR, 0, 0xf3 );
+ outTi3026( TVP3026_MEM_CLK_DATA, 0, ( mclk_n & 0x3f ) | 0xc0 );
+ outTi3026( TVP3026_MEM_CLK_DATA, 0, mclk_m & 0x3f );
+ outTi3026( TVP3026_MEM_CLK_DATA, 0, ( mclk_p & 0x03 ) | 0xb0 );
+
+ /* Wait for MCLK PLL to lock on frequency */
+ while (( inTi3026( TVP3026_MEM_CLK_DATA ) & 0x40 ) == 0 ) {
+ ;
+ }
+
+ /* Output MCLK PLL on MCLK pin */
+ outTi3026( TVP3026_MCLK_CTL, 0, ( mclk_ctl & 0xe7 ) | 0x10 );
+ outTi3026( TVP3026_MCLK_CTL, 0, ( mclk_ctl & 0xe7 ) | 0x18 );
+
+ /* Stop PCLK (PLLEN = 0, PCLKEN = 0 ) */
+ outTi3026( TVP3026_PLL_ADDR, 0, 0xfe );
+ outTi3026( TVP3026_PIX_CLK_DATA, 0, 0x00 );
+
+ /* Restore PCLK (PLLEN = ?, PCLKEN = ?) */
+ outTi3026( TVP3026_PLL_ADDR, 0, 0xfc );
+ outTi3026( TVP3026_PIX_CLK_DATA, 0, pclk_n );
+ outTi3026( TVP3026_PIX_CLK_DATA, 0, pclk_m );
+ outTi3026( TVP3026_PIX_CLK_DATA, 0, pclk_p );
+
+ /* Wait for PCLK PLL to lock on frequency */
+ while (( inTi3026( TVP3026_PIX_CLK_DATA ) & 0x40 ) == 0 ) {
+ ;
+ }
+}
+
+/*
+ * MGATi3026SetPCLK - Set the pixel (PCLK) and loop (LCLK) clocks.
+ *
+ * PARAMETERS
+ * f_pll IN Pixel clock PLL frequencly in kHz.
+ * bpp IN Bytes per pixel.
+ *
+ * HISTORY
+ * January 11, 1997 - [aem] Andrew E. Mileski
+ * Split to simplify code for MCLK (=GCLK) setting.
+ *
+ * December 14, 1996 - [aem] Andrew E. Mileski
+ * Fixed loop clock to be based on the calculated, not requested,
+ * pixel clock. Added f_max = maximum f_vco frequency.
+ *
+ * October 19, 1996 - [aem] Andrew E. Mileski
+ * Commented the loop clock code (wow, I understand everything now),
+ * and simplified it a bit. This should really be two separate functions.
+ *
+ * October 1, 1996 - [aem] Andrew E. Mileski
+ * Optimized the m & n picking algorithm. Added maxClock detection.
+ * Low speed pixel clock fix (per the docs). Documented what I understand.
+ *
+ * ?????, ??, ???? - [???] ????????????
+ * Based on the TVP3026 code in the S3 driver.
+ */
+
+static void
+MGATi3026SetPCLK( ScrnInfoPtr pScrn, long f_out, int bpp )
+{
+ /* Pixel clock values */
+ int m, n, p;
+
+ /* Loop clock values */
+ int lm, ln, lp, lq;
+ double z;
+
+ /* The actual frequency output by the clock */
+ double f_pll;
+
+ long f_max = TI_MAX_VCO_FREQ;
+
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr pReg = &pMga->ModeReg;
+
+ /* Get the maximum pixel clock frequency */
+ if ( pMga->MaxClock > TI_MAX_VCO_FREQ )
+ f_max = pMga->MaxClock;
+
+ /* Do the calculations for m, n, and p */
+ f_pll = MGATi3026CalcClock( f_out, f_max, & m, & n, & p );
+
+ /* Values for the pixel clock PLL registers */
+ pReg->DacClk[ 0 ] = ( n & 0x3f ) | 0xc0;
+ pReg->DacClk[ 1 ] = ( m & 0x3f );
+ pReg->DacClk[ 2 ] = ( p & 0x03 ) | 0xb0;
+
+ /*
+ * Now that the pixel clock PLL is setup,
+ * the loop clock PLL must be setup.
+ */
+
+ /*
+ * First we figure out lm, ln, and z.
+ * Things are different in packed pixel mode (24bpp) though.
+ */
+ if ( pMga->CurrentLayout.bitsPerPixel == 24 ) {
+
+ /* ln:lm = ln:3 */
+ lm = 65 - 3;
+
+ /* Check for interleaved mode */
+ if ( bpp == 2 )
+ /* ln:lm = 4:3 */
+ ln = 65 - 4;
+ else
+ /* ln:lm = 8:3 */
+ ln = 65 - 8;
+
+ /* Note: this is actually 100 * z for more precision */
+ z = ( 11000 * ( 65 - ln )) / (( f_pll / 1000 ) * ( 65 - lm ));
+ }
+ else {
+ /* ln:lm = ln:4 */
+ lm = 65 - 4;
+
+ /* Note: bpp = bytes per pixel */
+ ln = 65 - 4 * ( 64 / 8 ) / bpp;
+
+ /* Note: this is actually 100 * z for more precision */
+ z = (( 11000 / 4 ) * ( 65 - ln )) / ( f_pll / 1000 );
+ }
+
+ /*
+ * Now we choose dividers lp and lq so that the VCO frequency
+ * is within the operating range of 110 MHz to 220 MHz.
+ */
+
+ /* Assume no lq divider */
+ lq = 0;
+
+ /* Note: z is actually 100 * z for more precision */
+ if ( z <= 200.0 )
+ lp = 0;
+ else if ( z <= 400.0 )
+ lp = 1;
+ else if ( z <= 800.0 )
+ lp = 2;
+ else if ( z <= 1600.0 )
+ lp = 3;
+ else {
+ lp = 3;
+ lq = ( int )( z / 1600.0 );
+ }
+
+ /* Values for the loop clock PLL registers */
+ if ( pMga->CurrentLayout.bitsPerPixel == 24 ) {
+ /* Packed pixel mode values */
+ pReg->DacClk[ 3 ] = ( ln & 0x3f ) | 0x80;
+ pReg->DacClk[ 4 ] = ( lm & 0x3f ) | 0x80;
+ pReg->DacClk[ 5 ] = ( lp & 0x03 ) | 0xf8;
+ } else {
+ /* Non-packed pixel mode values */
+ pReg->DacClk[ 3 ] = ( ln & 0x3f ) | 0xc0;
+ pReg->DacClk[ 4 ] = ( lm & 0x3f );
+ pReg->DacClk[ 5 ] = ( lp & 0x03 ) | 0xf0;
+ }
+ pReg->DacRegs[ 18 ] = lq | 0x38;
+
+#ifdef DEBUG
+ ErrorF( "bpp=%d z=%.1f ln=%d lm=%d lp=%d lq=%d\n",
+ bpp, z, ln, lm, lp, lq );
+#endif
+}
+
+/*
+ * MGA3026Init -- for mga2064 with ti3026
+ *
+ * The 'mode' parameter describes the video mode. The 'mode' structure
+ * as well as the 'vga256InfoRec' structure can be dereferenced for
+ * information that is needed to initialize the mode. The 'new' macro
+ * (see definition above) is used to simply fill in the structure.
+ */
+static Bool
+MGA3026Init(ScrnInfoPtr pScrn, DisplayModePtr mode)
+{
+ int hd, hs, he, ht, vd, vs, ve, vt, wd;
+ int i, BppShift, index_1d = 0;
+ const unsigned char* initDAC;
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARamdacPtr MGAdac = &pMga->Dac;
+ MGAFBLayout *pLayout = &pMga->CurrentLayout;
+ MGARegPtr pReg = &pMga->ModeReg;
+ vgaRegPtr pVga = &VGAHWPTR(pScrn)->ModeReg;
+
+ BppShift = pMga->BppShifts[(pLayout->bitsPerPixel >> 3) - 1];
+
+ switch(pLayout->bitsPerPixel)
+ {
+ case 8:
+ initDAC = MGADACbpp8;
+ break;
+ case 16:
+ initDAC = MGADACbpp16;
+ break;
+ case 24:
+ initDAC = MGADACbpp24;
+ break;
+ case 32:
+ if(pLayout->Overlay8Plus24)
+ initDAC = MGADACbpp8plus24;
+ else
+ initDAC = MGADACbpp32;
+ break;
+ default:
+ FatalError("MGA: unsupported bits per pixel\n");
+ }
+
+ /* Allocate the DacRegs space if not done already */
+ if (pReg->DacRegs == NULL) {
+ pReg->DacRegs = xnfcalloc(DACREGSIZE, 1);
+ }
+ for (i = 0; i < DACREGSIZE; i++) {
+ pReg->DacRegs[i] = initDAC[i];
+ if (MGADACregs[i] == 0x1D)
+ index_1d = i;
+ }
+
+ if((pLayout->bitsPerPixel == 32) && pLayout->Overlay8Plus24) {
+ pReg->DacRegs[9] = pMga->colorKey;
+ pReg->DacRegs[10] = pMga->colorKey;
+ }
+
+ if ( (pLayout->bitsPerPixel == 16) && (pLayout->weight.red == 5)
+ && (pLayout->weight.green == 5) && (pLayout->weight.blue == 5) ) {
+ pReg->DacRegs[1] &= ~0x01;
+ }
+ if (pMga->Interleave ) pReg->DacRegs[2] += 1;
+
+
+ if ( pLayout->bitsPerPixel == 24 ) {
+ int silicon_rev;
+ /* we need to set DacRegs[0] differently based on the silicon
+ * revision of the 3026 RAMDAC, as per page 2-14 of tvp3026.pdf.
+ * If we have rev A silicon, we want 0x07; rev B silicon wants
+ * 0x06.
+ */
+ silicon_rev = inTi3026(TVP3026_SILICON_REV);
+
+#ifdef DEBUG
+ ErrorF("TVP3026 revision 0x%x (rev %s)\n",
+ silicon_rev, (silicon_rev <= 0x20) ? "A" : "B");
+#endif
+
+ if(silicon_rev <= 0x20) {
+ /* rev A */
+ pReg->DacRegs[0] = 0x07;
+ } else {
+ /* rev B */
+ pReg->DacRegs[0] = 0x06;
+ }
+ }
+
+ /*
+ * This will initialize all of the generic VGA registers.
+ */
+ if (!vgaHWInit(pScrn, mode))
+ return(FALSE);
+
+ /*
+ * Here all of the MGA registers get filled in.
+ */
+ hd = (mode->CrtcHDisplay >> 3) - 1;
+ hs = (mode->CrtcHSyncStart >> 3) - 1;
+ he = (mode->CrtcHSyncEnd >> 3) - 1;
+ ht = (mode->CrtcHTotal >> 3) - 1;
+ vd = mode->CrtcVDisplay - 1;
+ vs = mode->CrtcVSyncStart - 1;
+ ve = mode->CrtcVSyncEnd - 1;
+ vt = mode->CrtcVTotal - 2;
+
+ /* HTOTAL & 0x7 equal to 0x6 in 8bpp or 0x4 in 24bpp causes strange
+ * vertical stripes
+ */
+ if((ht & 0x07) == 0x06 || (ht & 0x07) == 0x04)
+ ht++;
+
+ if (pLayout->bitsPerPixel == 24)
+ wd = (pLayout->displayWidth * 3) >> (4 - BppShift);
+ else
+ wd = pLayout->displayWidth >> (4 - BppShift);
+
+ pReg->ExtVga[0] = 0;
+ pReg->ExtVga[5] = 0;
+
+ if (mode->Flags & V_INTERLACE)
+ {
+ pReg->ExtVga[0] = 0x80;
+ pReg->ExtVga[5] = (hs + he - ht) >> 1;
+ wd <<= 1;
+ vt &= 0xFFFE;
+
+ /* enable interlaced cursor */
+ pReg->DacRegs[20] |= 0x20;
+ }
+
+ pReg->ExtVga[0] |= (wd & 0x300) >> 4;
+ pReg->ExtVga[1] = (((ht - 4) & 0x100) >> 8) |
+ ((hd & 0x100) >> 7) |
+ ((hs & 0x100) >> 6) |
+ (ht & 0x40);
+ pReg->ExtVga[2] = ((vt & 0xc00) >> 10) |
+ ((vd & 0x400) >> 8) |
+ ((vd & 0xc00) >> 7) |
+ ((vs & 0xc00) >> 5);
+ if (pLayout->bitsPerPixel == 24)
+ pReg->ExtVga[3] = (((1 << BppShift) * 3) - 1) | 0x80;
+ else
+ pReg->ExtVga[3] = ((1 << BppShift) - 1) | 0x80;
+
+ /* Set viddelay (CRTCEXT3 Bits 3-4). */
+ pReg->ExtVga[3] |= (pScrn->videoRam == 8192 ? 0x10
+ : pScrn->videoRam == 2048 ? 0x08 : 0x00);
+
+ pReg->ExtVga[4] = 0;
+
+ pVga->CRTC[0] = ht - 4;
+ pVga->CRTC[1] = hd;
+ pVga->CRTC[2] = hd;
+ pVga->CRTC[3] = (ht & 0x1F) | 0x80;
+ pVga->CRTC[4] = hs;
+ pVga->CRTC[5] = ((ht & 0x20) << 2) | (he & 0x1F);
+ pVga->CRTC[6] = vt & 0xFF;
+ pVga->CRTC[7] = ((vt & 0x100) >> 8 ) |
+ ((vd & 0x100) >> 7 ) |
+ ((vs & 0x100) >> 6 ) |
+ ((vd & 0x100) >> 5 ) |
+ 0x10 |
+ ((vt & 0x200) >> 4 ) |
+ ((vd & 0x200) >> 3 ) |
+ ((vs & 0x200) >> 2 );
+ pVga->CRTC[9] = ((vd & 0x200) >> 4) | 0x40;
+ pVga->CRTC[16] = vs & 0xFF;
+ pVga->CRTC[17] = (ve & 0x0F) | 0x20;
+ pVga->CRTC[18] = vd & 0xFF;
+ pVga->CRTC[19] = wd & 0xFF;
+ pVga->CRTC[21] = vd & 0xFF;
+ pVga->CRTC[22] = (vt + 1) & 0xFF;
+
+ if (mode->Flags & V_DBLSCAN)
+ pVga->CRTC[9] |= 0x80;
+
+ /* Per DDK vid.c line 75, sync polarity should be controlled
+ * via the TVP3026 RAMDAC register 1D and so MISC Output Register
+ * should always have bits 6 and 7 set. */
+
+ pVga->MiscOutReg |= 0xC0;
+ if ((mode->Flags & (V_PHSYNC | V_NHSYNC)) &&
+ (mode->Flags & (V_PVSYNC | V_NVSYNC)))
+ {
+ if (mode->Flags & V_PHSYNC)
+ pReg->DacRegs[index_1d] |= 0x01;
+ if (mode->Flags & V_PVSYNC)
+ pReg->DacRegs[index_1d] |= 0x02;
+ }
+ else
+ {
+ int VDisplay = mode->VDisplay;
+ if (mode->Flags & V_DBLSCAN)
+ VDisplay *= 2;
+ if (VDisplay < 400)
+ pReg->DacRegs[index_1d] |= 0x01; /* +hsync -vsync */
+ else if (VDisplay < 480)
+ pReg->DacRegs[index_1d] |= 0x02; /* -hsync +vsync */
+ else if (VDisplay < 768)
+ pReg->DacRegs[index_1d] |= 0x00; /* -hsync -vsync */
+ else
+ pReg->DacRegs[index_1d] |= 0x03; /* +hsync +vsync */
+ }
+
+ if (pMga->SyncOnGreen)
+ pReg->DacRegs[index_1d] |= 0x20;
+
+ pReg->Option = 0x402C0100; /* fine for 2064 and 2164 */
+
+ if (pMga->Interleave)
+ pReg->Option |= 0x1000;
+ else
+ pReg->Option &= ~0x1000;
+
+ /* must always have the pci retries on but rely on
+ polling to keep them from occuring */
+ pReg->Option &= ~0x20000000;
+
+ pVga->MiscOutReg |= 0x0C;
+ /* XXX Need to check the first argument */
+ MGATi3026SetPCLK( pScrn, mode->Clock, 1 << BppShift );
+
+ /* this one writes registers rather than writing to the
+ mgaReg->ModeReg and letting Restore write to the hardware
+ but that's no big deal since we will Restore right after
+ this function */
+
+ MGA_NOT_HAL(MGATi3026SetMCLK(pScrn, MGAdac->MemoryClock));
+
+#ifdef DEBUG
+ ErrorF("%6ld: %02X %02X %02X %02X %02X %02X %08lX\n", mode->Clock,
+ pReg->DacClk[0], pReg->DacClk[1], pReg->DacClk[2], pReg->DacClk[3], pReg->DacClk[4], pReg->DacClk[5], pReg->Option);
+ for (i=0; i<sizeof(MGADACregs); i++) ErrorF("%02X ", pReg->DacRegs[i]);
+ for (i=0; i<6; i++) ErrorF(" %02X", pReg->ExtVga[i]);
+ ErrorF("\n");
+#endif
+
+ /* This disables the VGA memory aperture */
+ pVga->MiscOutReg &= ~0x02;
+ return(TRUE);
+}
+
+/*
+ * MGA3026Restore -- for mga2064 with ti3026
+ *
+ * This function restores a video mode. It basically writes out all of
+ * the registers that have previously been saved in the vgaMGARec data
+ * structure.
+ */
+static void
+MGA3026Restore(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, MGARegPtr mgaReg,
+ Bool restoreFonts)
+{
+ int i;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ /*
+ * Code is needed to get things back to bank zero.
+ */
+ for (i = 0; i < 6; i++)
+ OUTREG16(0x1FDE, (mgaReg->ExtVga[i] << 8) | i);
+
+ pciSetBitsLong(pMga->PciTag, PCI_OPTION_REG, OPTION_MASK,
+ mgaReg->Option);
+
+ MGA_NOT_HAL(
+ /* select pixel clock PLL as clock source */
+ outTi3026(TVP3026_CLK_SEL, 0, mgaReg->DacRegs[3]);
+
+ /* set loop and pixel clock PLL PLLEN bits to 0 */
+ outTi3026(TVP3026_PLL_ADDR, 0, 0x2A);
+ outTi3026(TVP3026_LOAD_CLK_DATA, 0, 0);
+ outTi3026(TVP3026_PIX_CLK_DATA, 0, 0);
+ ); /* MGA_NOT_HAL */
+
+ /*
+ * This function handles restoring the generic VGA registers.
+ */
+ vgaHWRestore(pScrn, vgaReg,
+ VGA_SR_MODE | (restoreFonts ? VGA_SR_FONTS : 0));
+ MGA3026RestorePalette(pScrn, vgaReg->DAC);
+
+ /*
+ * Code to restore SVGA registers that have been saved/modified
+ * goes here.
+ */
+
+ MGA_NOT_HAL(
+ /* program pixel clock PLL */
+ outTi3026(TVP3026_PLL_ADDR, 0, 0x00);
+ for (i = 0; i < 3; i++)
+ outTi3026(TVP3026_PIX_CLK_DATA, 0, mgaReg->DacClk[i]);
+
+ if (vgaReg->MiscOutReg & 0x08) {
+ /* poll until pixel clock PLL LOCK bit is set */
+ outTi3026(TVP3026_PLL_ADDR, 0, 0x3F);
+ while ( ! (inTi3026(TVP3026_PIX_CLK_DATA) & 0x40) );
+ }
+
+ /* set Q divider for loop clock PLL */
+ outTi3026(TVP3026_MCLK_CTL, 0, mgaReg->DacRegs[18]);
+ ); /* MGA_NOT_HAL */
+
+ /* program loop PLL */
+ outTi3026(TVP3026_PLL_ADDR, 0, 0x00);
+ for (i = 3; i < 6; i++)
+ outTi3026(TVP3026_LOAD_CLK_DATA, 0, mgaReg->DacClk[i]);
+
+ MGA_NOT_HAL(
+ if ((vgaReg->MiscOutReg & 0x08) && ((mgaReg->DacClk[3] & 0xC0) == 0xC0) ) {
+ /* poll until loop PLL LOCK bit is set */
+ outTi3026(TVP3026_PLL_ADDR, 0, 0x3F);
+ while ( ! (inTi3026(TVP3026_LOAD_CLK_DATA) & 0x40) );
+ }
+ ); /* MGA_NOT_HAL */
+
+ /*
+ * restore other DAC registers
+ */
+ for (i = 0; i < DACREGSIZE; i++)
+ outTi3026(MGADACregs[i], 0, mgaReg->DacRegs[i]);
+
+#ifdef DEBUG
+ ErrorF("PCI retry (0-enabled / 1-disabled): %d\n",
+ !!(mgaReg->Option & 0x20000000));
+#endif
+}
+
+/*
+ * MGA3026Save -- for mga2064 with ti3026
+ *
+ * This function saves the video state.
+ */
+static void
+MGA3026Save(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, MGARegPtr mgaReg,
+ Bool saveFonts)
+{
+ int i;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ /* Allocate the DacRegs space if not done already */
+ if (mgaReg->DacRegs == NULL) {
+ mgaReg->DacRegs = xnfcalloc(DACREGSIZE, 1);
+ }
+
+ /*
+ * Code is needed to get back to bank zero.
+ */
+ OUTREG16(0x1FDE, 0x0004);
+
+ /*
+ * This function will handle creating the data structure and filling
+ * in the generic VGA portion.
+ */
+ vgaHWSave(pScrn, vgaReg, VGA_SR_MODE | (saveFonts ? VGA_SR_FONTS : 0));
+ MGA3026SavePalette(pScrn, vgaReg->DAC);
+
+ /*
+ * The port I/O code necessary to read in the extended registers
+ * into the fields of the vgaMGARec structure.
+ */
+ for (i = 0; i < 6; i++)
+ {
+ OUTREG8(0x1FDE, i);
+ mgaReg->ExtVga[i] = INREG8(0x1FDF);
+ }
+
+ MGA_NOT_HAL(
+ outTi3026(TVP3026_PLL_ADDR, 0, 0x00);
+ for (i = 0; i < 3; i++)
+ outTi3026(TVP3026_PIX_CLK_DATA, 0, mgaReg->DacClk[i] =
+ inTi3026(TVP3026_PIX_CLK_DATA));
+
+ outTi3026(TVP3026_PLL_ADDR, 0, 0x00);
+ for (i = 3; i < 6; i++)
+ outTi3026(TVP3026_LOAD_CLK_DATA, 0, mgaReg->DacClk[i] =
+ inTi3026(TVP3026_LOAD_CLK_DATA));
+ ); /* MGA_NOT_HAL */
+
+ for (i = 0; i < DACREGSIZE; i++)
+ mgaReg->DacRegs[i] = inTi3026(MGADACregs[i]);
+
+ mgaReg->Option = pciReadLong(pMga->PciTag, PCI_OPTION_REG);
+
+#ifdef DEBUG
+ ErrorF("read: %02X %02X %02X %02X %02X %02X %08lX\n",
+ mgaReg->DacClk[0], mgaReg->DacClk[1], mgaReg->DacClk[2], mgaReg->DacClk[3], mgaReg->DacClk[4], mgaReg->DacClk[5], mgaReg->Option);
+ for (i=0; i<sizeof(MGADACregs); i++) ErrorF("%02X ", mgaReg->DacRegs[i]);
+ for (i=0; i<6; i++) ErrorF(" %02X", mgaReg->ExtVga[i]);
+ ErrorF("\n");
+#endif
+}
+
+
+static void
+MGA3026LoadCursorImage(
+ ScrnInfoPtr pScrn,
+ unsigned char *src
+)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int i = 1024;
+
+ outTi3026(TVP3026_CURSOR_CTL, 0xf3, 0x00); /* reset A9,A8 */
+ /* reset cursor RAM load address A7..A0 */
+ outTi3026dreg(TVP3026_WADR_PAL, 0x00);
+
+ while(i--) {
+ while (INREG8(0x1FDA) & 0x01);
+ while (!(INREG8(0x1FDA) & 0x01));
+ outTi3026dreg(TVP3026_CUR_RAM, *(src++));
+ }
+}
+
+
+static void
+MGA3026ShowCursor(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ /* Enable cursor - X11 mode */
+ outTi3026(TVP3026_CURSOR_CTL, 0x6c, 0x13);
+}
+
+static void
+MGA3026HideCursor(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ /* Disable cursor */
+ outTi3026(TVP3026_CURSOR_CTL, 0xfc, 0x00);
+}
+
+static void
+MGA3026SetCursorPosition(
+ ScrnInfoPtr pScrn,
+ int x, int y
+)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ x += 64;
+ y += 64;
+
+ /* Output position - "only" 12 bits of location documented */
+
+ outTi3026dreg(TVP3026_CUR_XLOW, x & 0xFF);
+ outTi3026dreg(TVP3026_CUR_XHI, (x >> 8) & 0x0F);
+ outTi3026dreg(TVP3026_CUR_YLOW, y & 0xFF);
+ outTi3026dreg(TVP3026_CUR_YHI, (y >> 8) & 0x0F);
+}
+
+static void
+MGA3026SetCursorColors(
+ ScrnInfoPtr pScrn,
+ int bg, int fg
+)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ /* The TI 3026 cursor is always 8 bits so shift 8, not 10 */
+
+ /* Background color */
+ outTi3026dreg(TVP3026_CUR_COL_ADDR, 1);
+ outTi3026dreg(TVP3026_CUR_COL_DATA, (bg & 0x00FF0000) >> 16);
+ outTi3026dreg(TVP3026_CUR_COL_DATA, (bg & 0x0000FF00) >> 8);
+ outTi3026dreg(TVP3026_CUR_COL_DATA, (bg & 0x000000FF));
+
+ /* Foreground color */
+ outTi3026dreg(TVP3026_CUR_COL_ADDR, 2);
+ outTi3026dreg(TVP3026_CUR_COL_DATA, (fg & 0x00FF0000) >> 16);
+ outTi3026dreg(TVP3026_CUR_COL_DATA, (fg & 0x0000FF00) >> 8);
+ outTi3026dreg(TVP3026_CUR_COL_DATA, (fg & 0x000000FF));
+}
+
+static Bool
+MGA3026UseHWCursor(ScreenPtr pScrn, CursorPtr pCurs)
+{
+ if( XF86SCRNINFO(pScrn)->currentMode->Flags & V_DBLSCAN )
+ return FALSE;
+ return TRUE;
+}
+
+static const int DDC_SDA_MASK = 1 << 2;
+static const int DDC_SCL_MASK = 1 << 4;
+
+static unsigned int
+MGA3026_ddc1Read(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ /* Define the SDA as an input */
+ outTi3026(TVP3026_GEN_IO_CTL, 0xfb, 0);
+
+ /* wait for Vsync */
+ while( INREG( MGAREG_Status ) & 0x08 );
+ while( ! (INREG( MGAREG_Status ) & 0x08) );
+
+ /* Get the result */
+ return (inTi3026(TVP3026_GEN_IO_DATA) & DDC_SDA_MASK) >> 2 ;
+}
+
+static void
+MGA3026_I2CGetBits(I2CBusPtr b, int *clock, int *data)
+{
+ MGAPtr pMga = MGAPTR(xf86Screens[b->scrnIndex]);
+ unsigned char val;
+
+ /* Get the result. */
+ val = inTi3026(TVP3026_GEN_IO_DATA);
+ *clock = (val & DDC_SCL_MASK) != 0;
+ *data = (val & DDC_SDA_MASK) != 0;
+
+#ifdef DEBUG
+ ErrorF("MGA3026_I2CGetBits(%p,...) val=0x%x, returns clock %d, data %d\n", b, val, *clock, *data);
+#endif
+}
+
+/*
+ * ATTENTION! - the DATA and CLOCK lines need to be tri-stated when
+ * high. Therefore turn off output driver for the line to set line
+ * to high. High signal is maintained by a 15k Ohm pll-up resistor.
+ */
+static void
+MGA3026_I2CPutBits(I2CBusPtr b, int clock, int data)
+{
+ MGAPtr pMga = MGAPTR(xf86Screens[b->scrnIndex]);
+ unsigned char val,drv;
+
+ /* Write the values */
+ val = (clock ? DDC_SCL_MASK : 0) | (data ? DDC_SDA_MASK : 0);
+ drv = ((!clock) ? DDC_SCL_MASK : 0) | ((!data) ? DDC_SDA_MASK : 0);
+ /* Define the SDA (Data) and SCL (clock) as outputs */
+ outTi3026(TVP3026_GEN_IO_CTL, ~(DDC_SDA_MASK | DDC_SCL_MASK), drv);
+ outTi3026(TVP3026_GEN_IO_DATA, ~(DDC_SDA_MASK | DDC_SCL_MASK), val);
+
+#ifdef DEBUG
+ ErrorF("MGA3026_I2CPutBits(%p, %d, %d) val=0x%x\n", b, clock, data, val);
+#endif
+
+}
+
+
+Bool
+MGA3026_i2cInit(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ I2CBusPtr I2CPtr;
+
+ I2CPtr = xf86CreateI2CBusRec();
+ if(!I2CPtr) return FALSE;
+
+ pMga->I2C = I2CPtr;
+
+ I2CPtr->BusName = "DDC";
+ I2CPtr->scrnIndex = pScrn->scrnIndex;
+ I2CPtr->I2CPutBits = MGA3026_I2CPutBits;
+ I2CPtr->I2CGetBits = MGA3026_I2CGetBits;
+
+ /* I2CPutByte is timing out, experimenting with AcknTimeout
+ * default is 2CPtr->AcknTimeout = 5;
+ */
+ /* I2CPtr->AcknTimeout = 10; */
+
+ if (!xf86I2CBusInit(I2CPtr)) {
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static void
+MGA3026RamdacInit(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga;
+ MGARamdacPtr MGAdac;
+
+ pMga = MGAPTR(pScrn);
+ MGAdac = &pMga->Dac;
+
+ MGAdac->isHwCursor = TRUE;
+ MGAdac->CursorMaxWidth = 64;
+ MGAdac->CursorMaxHeight = 64;
+ MGAdac->SetCursorColors = MGA3026SetCursorColors;
+ MGAdac->SetCursorPosition = MGA3026SetCursorPosition;
+ MGAdac->LoadCursorImage = MGA3026LoadCursorImage;
+ MGAdac->HideCursor = MGA3026HideCursor;
+ MGAdac->ShowCursor = MGA3026ShowCursor;
+ MGAdac->UseHWCursor = MGA3026UseHWCursor;
+ MGAdac->CursorFlags =
+#if X_BYTE_ORDER == X_LITTLE_ENDIAN
+ HARDWARE_CURSOR_BIT_ORDER_MSBFIRST |
+#endif
+ HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
+ HARDWARE_CURSOR_SOURCE_MASK_NOT_INTERLEAVED;
+
+ MGAdac->LoadPalette = MGA3026LoadPalette;
+
+ MGAdac->ClockFrom = X_PROBED;
+ if ( pMga->Chipset == PCI_CHIP_MGA2064 && pMga->Bios2.PinID == 0 )
+ {
+ switch( pMga->Bios.RamdacType & 0xff )
+ {
+ case 1: MGAdac->maxPixelClock = 220000;
+ break;
+ case 2: MGAdac->maxPixelClock = 250000;
+ break;
+ default:
+ MGAdac->maxPixelClock = 175000;
+ MGAdac->ClockFrom = X_DEFAULT;
+ break;
+ }
+ /* Set MCLK based on amount of memory */
+ if(pMga->OverclockMem) {
+ if ( pScrn->videoRam < 4096 )
+ MGAdac->MemoryClock = pMga->Bios.ClkBase * 12;
+ else if ( pScrn->videoRam < 8192 )
+ MGAdac->MemoryClock = pMga->Bios.Clk4MB * 12;
+ else
+ MGAdac->MemoryClock = pMga->Bios.Clk8MB * 12;
+ MGAdac->MemClkFrom = X_CONFIG;
+ MGAdac->SetMemClk = TRUE;
+#if 0
+ ErrorF("BIOS Memory clock settings: 2Mb %d, 4Mb %d, 8MB %d\n",
+ pMga->Bios.ClkBase, pMga->Bios.Clk4MB, pMga->Bios.Clk8MB);
+#endif
+ } else {
+ if ( pScrn->videoRam < 4096 )
+ MGAdac->MemoryClock = pMga->Bios.ClkBase * 10;
+ else if ( pScrn->videoRam < 8192 )
+ MGAdac->MemoryClock = pMga->Bios.Clk4MB * 10;
+ else
+ MGAdac->MemoryClock = pMga->Bios.Clk8MB * 10;
+ MGAdac->MemClkFrom = X_PROBED;
+ MGAdac->SetMemClk = TRUE;
+ }
+ }
+ else
+ {
+ if ( pMga->Bios2.PinID ) /* make sure BIOS is available */
+ {
+ if ( pMga->Bios2.PclkMax != 0xff )
+ {
+ MGAdac->maxPixelClock = (pMga->Bios2.PclkMax + 100) * 1000;
+ }
+ else
+ MGAdac->maxPixelClock = 220000;
+
+ /* make sure we are not overdriving the GE for the amount of WRAM */
+ switch ( pScrn->videoRam )
+ {
+ case 4096:
+ if (pMga->Bios2.Clk4MB != 0xff)
+ pMga->Bios2.ClkGE = pMga->Bios2.Clk4MB;
+ break;
+ case 8192:
+ if (pMga->Bios2.Clk8MB != 0xff)
+ pMga->Bios2.ClkGE = pMga->Bios2.Clk8MB;
+ break;
+ case 12288:
+ if (pMga->Bios2.Clk12MB != 0xff)
+ pMga->Bios2.ClkGE = pMga->Bios2.Clk12MB;
+ break;
+ case 16384:
+ if (pMga->Bios2.Clk16MB != 0xff)
+ pMga->Bios2.ClkGE = pMga->Bios2.Clk16MB;
+ break;
+ default:
+ break;
+ }
+
+ if ( pMga->Bios2.ClkGE != 0xff && pMga->Bios2.ClkMem == 0xff )
+ pMga->Bios2.ClkMem = pMga->Bios2.ClkGE;
+ else if ( pMga->Bios2.ClkGE == 0xff && pMga->Bios2.ClkMem != 0xff )
+ ; /* don't need to do anything */
+ else if ( pMga->Bios2.ClkGE == pMga->Bios2.ClkMem && pMga->Bios2.ClkGE != 0xff )
+ pMga->Bios2.ClkMem = pMga->Bios2.ClkGE;
+ else
+ pMga->Bios2.ClkMem = 60;
+
+ MGAdac->MemoryClock = pMga->Bios2.ClkMem * 1000;
+ MGAdac->MemClkFrom = X_PROBED;
+ MGAdac->SetMemClk = TRUE;
+ } /* BIOS enabled initialization */
+ else
+ {
+ /* bios is not available, initialize to rational figures */
+ MGAdac->MemoryClock = 60000; /* 60 MHz WRAM */
+ MGAdac->maxPixelClock = 220000; /* 220 MHz */
+ MGAdac->ClockFrom = X_DEFAULT;
+ }
+ } /* 2164 specific initialization */
+
+ /* safety check */
+ if ( (MGAdac->MemoryClock < 40000) ||
+ (MGAdac->MemoryClock > 70000) )
+ MGAdac->MemoryClock = 50000;
+
+ /*
+ * Should initialise a sane default when the probed value is
+ * obviously garbage.
+ */
+
+ /* Check if interleaving can be used and set the rounding value */
+ if (pScrn->videoRam > 2048)
+ pMga->Interleave = TRUE;
+ else {
+ pMga->Interleave = FALSE;
+ pMga->BppShifts[0]++;
+ pMga->BppShifts[1]++;
+ pMga->BppShifts[2]++;
+ pMga->BppShifts[3]++;
+ }
+
+ pMga->Roundings[0] = 128 >> pMga->BppShifts[0];
+ pMga->Roundings[1] = 128 >> pMga->BppShifts[1];
+ pMga->Roundings[2] = 128 >> pMga->BppShifts[2];
+ pMga->Roundings[3] = 128 >> pMga->BppShifts[3];
+
+ /* Set Fast bitblt flag */
+ pMga->HasFBitBlt = !(pMga->Bios.FeatFlag & 0x00000001);
+}
+
+void MGA3026LoadPalette(
+ ScrnInfoPtr pScrn,
+ int numColors,
+ int *indices,
+ LOCO *colors,
+ VisualPtr pVisual
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ int i, index;
+
+ if(pMga->CurrentLayout.Overlay8Plus24 && (pVisual->nplanes != 8))
+ return;
+
+ if (pVisual->nplanes == 16) {
+ for(i = 0; i < numColors; i++) {
+ index = indices[i];
+ outTi3026dreg(MGA1064_WADR_PAL, index << 2);
+ outTi3026dreg(MGA1064_COL_PAL, colors[index >> 1].red);
+ outTi3026dreg(MGA1064_COL_PAL, colors[index].green);
+ outTi3026dreg(MGA1064_COL_PAL, colors[index >> 1].blue);
+
+ /* we have to write 2 indices since the pixel X on the
+ TVP3026 has green colors at different locations from
+ the red and blue colors */
+ if(index <= 31) {
+ outTi3026dreg(MGA1064_WADR_PAL, index << 3);
+ outTi3026dreg(MGA1064_COL_PAL, colors[index].red);
+ outTi3026dreg(MGA1064_COL_PAL, colors[(index << 1) + 1].green);
+ outTi3026dreg(MGA1064_COL_PAL, colors[index].blue);
+ }
+ }
+ } else {
+ int shift = (pVisual->nplanes == 15) ? 3 : 0;
+
+ for(i = 0; i < numColors; i++) {
+ index = indices[i];
+ outTi3026dreg(MGA1064_WADR_PAL, index << shift);
+ outTi3026dreg(MGA1064_COL_PAL, colors[index].red);
+ outTi3026dreg(MGA1064_COL_PAL, colors[index].green);
+ outTi3026dreg(MGA1064_COL_PAL, colors[index].blue);
+ }
+ }
+}
+
+
+static void
+MGA3026SavePalette(ScrnInfoPtr pScrn, unsigned char* pntr)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int i = 768;
+
+ outTi3026dreg(TVP3026_RADR_PAL, 0x00);
+ while(i--)
+ *(pntr++) = inTi3026dreg(TVP3026_COL_PAL);
+}
+
+static void
+MGA3026RestorePalette(ScrnInfoPtr pScrn, unsigned char* pntr)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int i = 768;
+
+ outTi3026dreg(TVP3026_WADR_PAL, 0x00);
+ while(i--)
+ outTi3026dreg(TVP3026_COL_PAL, *(pntr++));
+}
+
+
+void MGA2064SetupFuncs(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ pMga->PreInit = MGA3026RamdacInit;
+ pMga->Save = MGA3026Save;
+ pMga->Restore = MGA3026Restore;
+ pMga->ModeInit = MGA3026Init;
+ pMga->ddc1Read = MGA3026_ddc1Read;
+ /* vgaHWddc1SetSpeed will only work if the card is in VGA mode */
+ pMga->DDC1SetSpeed = vgaHWddc1SetSpeed;
+ pMga->i2cInit = MGA3026_i2cInit;
+}
diff --git a/src/mga_dacG.c b/src/mga_dacG.c
new file mode 100644
index 0000000..34a9432
--- /dev/null
+++ b/src/mga_dacG.c
@@ -0,0 +1,1187 @@
+/*
+ * MGA-1064, MGA-G100, MGA-G200, MGA-G400, MGA-G550 RAMDAC driver
+ */
+
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_dacG.c,v 1.51 2002/09/16 18:05:55 eich Exp $ */
+
+/*
+ * This is a first cut at a non-accelerated version to work with the
+ * new server design (DHD).
+ */
+
+#include "colormapst.h"
+
+/* All drivers should typically include these */
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+
+/* Drivers for PCI hardware need this */
+#include "xf86PciInfo.h"
+
+/* Drivers that need to access the PCI config space directly need this */
+#include "xf86Pci.h"
+
+#include "mga_bios.h"
+#include "mga_reg.h"
+#include "mga.h"
+#include "mga_macros.h"
+
+#include "xf86DDC.h"
+
+
+/*
+ * implementation
+ */
+
+#define DACREGSIZE 0x50
+
+/*
+ * Only change bits shown in this mask. Ideally reserved bits should be
+ * zeroed here. Also, don't change the vgaioen bit here since it is
+ * controlled elsewhere.
+ *
+ * XXX These settings need to be checked.
+ */
+#define OPTION1_MASK 0xFFFFFEFF
+#define OPTION2_MASK 0xFFFFFFFF
+#define OPTION3_MASK 0xFFFFFFFF
+
+#define OPTION1_MASK_PRIMARY 0xFFFC0FF
+
+static void MGAGRamdacInit(ScrnInfoPtr);
+static void MGAGSave(ScrnInfoPtr, vgaRegPtr, MGARegPtr, Bool);
+static void MGAGRestore(ScrnInfoPtr, vgaRegPtr, MGARegPtr, Bool);
+static Bool MGAGInit(ScrnInfoPtr, DisplayModePtr);
+static void MGAGLoadPalette(ScrnInfoPtr, int, int*, LOCO*, VisualPtr);
+static Bool MGAG_i2cInit(ScrnInfoPtr pScrn);
+
+/*
+ * MGAGCalcClock - Calculate the PLL settings (m, n, p, s).
+ *
+ * DESCRIPTION
+ * For more information, refer to the Matrox
+ * "MGA1064SG Developer Specification (document 10524-MS-0100).
+ * chapter 5.7.8. "PLLs Clocks Generators"
+ *
+ * PARAMETERS
+ * f_out IN Desired clock frequency.
+ * f_max IN Maximum allowed clock frequency.
+ * m OUT Value of PLL 'm' register.
+ * n OUT Value of PLL 'n' register.
+ * p OUT Value of PLL 'p' register.
+ * s OUT Value of PLL 's' filter register
+ * (pix pll clock only).
+ *
+ * HISTORY
+ * August 18, 1998 - Radoslaw Kapitan
+ * Adapted for G200 DAC
+ *
+ * February 28, 1997 - Guy DESBIEF
+ * Adapted for MGA1064SG DAC.
+ * based on MGACalcClock written by [aem] Andrew E. Mileski
+ */
+
+/* The following values are in kHz */
+#define MGA_MIN_VCO_FREQ 50000
+#define MGA_MAX_VCO_FREQ 310000
+
+static double
+MGAGCalcClock ( ScrnInfoPtr pScrn, long f_out,
+ int *best_m, int *best_n, int *p, int *s )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int m, n;
+ double f_pll, f_vco;
+ double m_err, calc_f;
+ double ref_freq;
+ int feed_div_min, feed_div_max;
+ int in_div_min, in_div_max;
+ int post_div_max;
+
+ switch( pMga->Chipset )
+ {
+ case PCI_CHIP_MGA1064:
+ ref_freq = 14318.18;
+ feed_div_min = 100;
+ feed_div_max = 127;
+ in_div_min = 1;
+ in_div_max = 31;
+ post_div_max = 7;
+ break;
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG550:
+ ref_freq = 27050.5;
+ feed_div_min = 7;
+ feed_div_max = 127;
+ in_div_min = 1;
+ in_div_max = 31;
+ post_div_max = 7;
+ break;
+ case PCI_CHIP_MGAG100:
+ case PCI_CHIP_MGAG100_PCI:
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ default:
+ if (pMga->Bios2.PinID && (pMga->Bios2.VidCtrl & 0x20))
+ ref_freq = 14318.18;
+ else
+ ref_freq = 27050.5;
+ feed_div_min = 7;
+ feed_div_max = 127;
+ in_div_min = 1;
+ in_div_max = 6;
+ post_div_max = 7;
+ break;
+ }
+
+ /* Make sure that f_min <= f_out */
+ if ( f_out < ( MGA_MIN_VCO_FREQ / 8))
+ f_out = MGA_MIN_VCO_FREQ / 8;
+
+ /*
+ * f_pll = f_vco / (p+1)
+ * Choose p so that MGA_MIN_VCO_FREQ <= f_vco <= MGA_MAX_VCO_FREQ
+ * we don't have to bother checking for this maximum limit.
+ */
+ f_vco = ( double ) f_out;
+ for ( *p = 0; *p <= post_div_max && f_vco < MGA_MIN_VCO_FREQ;
+ *p = *p * 2 + 1, f_vco *= 2.0);
+
+ /* Initial amount of error for frequency maximum */
+ m_err = f_out;
+
+ /* Search for the different values of ( m ) */
+ for ( m = in_div_min ; m <= in_div_max ; m++ )
+ {
+ /* see values of ( n ) which we can't use */
+ for ( n = feed_div_min; n <= feed_div_max; n++ )
+ {
+ calc_f = ref_freq * (n + 1) / (m + 1) ;
+
+ /*
+ * Pick the closest frequency.
+ */
+ if ( abs(calc_f - f_vco) < m_err ) {
+ m_err = abs(calc_f - f_vco);
+ *best_m = m;
+ *best_n = n;
+ }
+ }
+ }
+
+ /* Now all the calculations can be completed */
+ f_vco = ref_freq * (*best_n + 1) / (*best_m + 1);
+
+ /* Adjustments for filtering pll feed back */
+ if ( (50000.0 <= f_vco)
+ && (f_vco < 100000.0) )
+ *s = 0;
+ if ( (100000.0 <= f_vco)
+ && (f_vco < 140000.0) )
+ *s = 1;
+ if ( (140000.0 <= f_vco)
+ && (f_vco < 180000.0) )
+ *s = 2;
+ if ( (180000.0 <= f_vco) )
+ *s = 3;
+
+ f_pll = f_vco / ( *p + 1 );
+
+#ifdef DEBUG
+ ErrorF( "f_out_requ =%ld f_pll_real=%.1f f_vco=%.1f n=0x%x m=0x%x p=0x%x s=0x%x\n",
+ f_out, f_pll, f_vco, *best_n, *best_m, *p, *s );
+#endif
+
+ return f_pll;
+}
+
+/*
+ * MGAGSetPCLK - Set the pixel (PCLK) clock.
+ */
+static void
+MGAGSetPCLK( ScrnInfoPtr pScrn, long f_out )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr pReg = &pMga->ModeReg;
+
+ /* Pixel clock values */
+ int m, n, p, s;
+
+ /* The actual frequency output by the clock */
+ double f_pll;
+
+ if(MGAISGx50(pMga)) {
+ pReg->Clock = f_out;
+ return;
+ }
+
+ /* Do the calculations for m, n, p and s */
+ f_pll = MGAGCalcClock( pScrn, f_out, &m, &n, &p, &s );
+
+ /* Values for the pixel clock PLL registers */
+ pReg->DacRegs[ MGA1064_PIX_PLLC_M ] = m & 0x1F;
+ pReg->DacRegs[ MGA1064_PIX_PLLC_N ] = n & 0x7F;
+ pReg->DacRegs[ MGA1064_PIX_PLLC_P ] = (p & 0x07) | ((s & 0x03) << 3);
+}
+
+/*
+ * MGAGInit
+ */
+static Bool
+MGAGInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
+{
+ /*
+ * initial values of the DAC registers
+ */
+ const static unsigned char initDAC[] = {
+ /* 0x00: */ 0, 0, 0, 0, 0, 0, 0x00, 0,
+ /* 0x08: */ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0x10: */ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0x18: */ 0x00, 0, 0xC9, 0xFF, 0xBF, 0x20, 0x1F, 0x20,
+ /* 0x20: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ /* 0x28: */ 0x00, 0x00, 0x00, 0x00, 0, 0, 0, 0x40,
+ /* 0x30: */ 0x00, 0xB0, 0x00, 0xC2, 0x34, 0x14, 0x02, 0x83,
+ /* 0x38: */ 0x00, 0x93, 0x00, 0x77, 0x00, 0x00, 0x00, 0x3A,
+ /* 0x40: */ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0x48: */ 0, 0, 0, 0, 0, 0, 0, 0
+ };
+
+ int i, weight555 = FALSE;
+ int hd, hs, he, ht, vd, vs, ve, vt, wd;
+ int BppShift;
+ MGAPtr pMga;
+ MGARegPtr pReg;
+ vgaRegPtr pVga;
+ MGAFBLayout *pLayout;
+ xMODEINFO ModeInfo;
+
+ ModeInfo.ulDispWidth = mode->HDisplay;
+ ModeInfo.ulDispHeight = mode->VDisplay;
+ ModeInfo.ulFBPitch = mode->HDisplay;
+ ModeInfo.ulBpp = pScrn->bitsPerPixel;
+ ModeInfo.flSignalMode = 0;
+ ModeInfo.ulPixClock = mode->Clock;
+ ModeInfo.ulHFPorch = mode->HSyncStart - mode->HDisplay;
+ ModeInfo.ulHSync = mode->HSyncEnd - mode->HSyncStart;
+ ModeInfo.ulHBPorch = mode->HTotal - mode->HSyncEnd;
+ ModeInfo.ulVFPorch = mode->VSyncStart - mode->VDisplay;
+ ModeInfo.ulVSync = mode->VSyncEnd - mode->VSyncStart;
+ ModeInfo.ulVBPorch = mode->VTotal - mode->VSyncEnd;
+
+ pMga = MGAPTR(pScrn);
+ pReg = &pMga->ModeReg;
+ pVga = &VGAHWPTR(pScrn)->ModeReg;
+ pLayout = &pMga->CurrentLayout;
+
+ BppShift = pMga->BppShifts[(pLayout->bitsPerPixel >> 3) - 1];
+
+ MGA_NOT_HAL(
+ /* Allocate the DacRegs space if not done already */
+ if (pReg->DacRegs == NULL) {
+ pReg->DacRegs = xnfcalloc(DACREGSIZE, 1);
+ }
+ for (i = 0; i < DACREGSIZE; i++) {
+ pReg->DacRegs[i] = initDAC[i];
+ }
+ ); /* MGA_NOT_HAL */
+
+ switch(pMga->Chipset)
+ {
+ case PCI_CHIP_MGA1064:
+ pReg->DacRegs[ MGA1064_SYS_PLL_M ] = 0x04;
+ pReg->DacRegs[ MGA1064_SYS_PLL_N ] = 0x44;
+ pReg->DacRegs[ MGA1064_SYS_PLL_P ] = 0x18;
+ pReg->Option = 0x5F094F21;
+ pReg->Option2 = 0x00000000;
+ break;
+ case PCI_CHIP_MGAG100:
+ case PCI_CHIP_MGAG100_PCI:
+ pReg->DacRegs[ MGAGDAC_XVREFCTRL ] = 0x03;
+ if(pMga->HasSDRAM) {
+ if(pMga->OverclockMem) {
+ /* 220 Mhz */
+ pReg->DacRegs[ MGA1064_SYS_PLL_M ] = 0x06;
+ pReg->DacRegs[ MGA1064_SYS_PLL_N ] = 0x38;
+ pReg->DacRegs[ MGA1064_SYS_PLL_P ] = 0x18;
+ } else {
+ /* 203 Mhz */
+ pReg->DacRegs[ MGA1064_SYS_PLL_M ] = 0x01;
+ pReg->DacRegs[ MGA1064_SYS_PLL_N ] = 0x0E;
+ pReg->DacRegs[ MGA1064_SYS_PLL_P ] = 0x18;
+ }
+ pReg->Option = 0x404991a9;
+ } else {
+ if(pMga->OverclockMem) {
+ /* 143 Mhz */
+ pReg->DacRegs[ MGA1064_SYS_PLL_M ] = 0x06;
+ pReg->DacRegs[ MGA1064_SYS_PLL_N ] = 0x24;
+ pReg->DacRegs[ MGA1064_SYS_PLL_P ] = 0x10;
+ } else {
+ /* 124 Mhz */
+ pReg->DacRegs[ MGA1064_SYS_PLL_M ] = 0x04;
+ pReg->DacRegs[ MGA1064_SYS_PLL_N ] = 0x16;
+ pReg->DacRegs[ MGA1064_SYS_PLL_P ] = 0x08;
+ }
+ pReg->Option = 0x4049d121;
+ }
+ pReg->Option2 = 0x0000007;
+ break;
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG550:
+#ifdef USEMGAHAL
+ MGA_HAL(break;);
+#endif
+ if (MGAISGx50(pMga))
+ break;
+
+ if(pMga->Dac.maxPixelClock == 360000) { /* G400 MAX */
+ if(pMga->OverclockMem) {
+ /* 150/200 */
+ pReg->DacRegs[ MGA1064_SYS_PLL_M ] = 0x05;
+ pReg->DacRegs[ MGA1064_SYS_PLL_N ] = 0x42;
+ pReg->DacRegs[ MGA1064_SYS_PLL_P ] = 0x18;
+ pReg->Option3 = 0x019B8419;
+ pReg->Option = 0x50574120;
+ } else {
+ /* 125/166 */
+ pReg->DacRegs[ MGA1064_SYS_PLL_M ] = 0x02;
+ pReg->DacRegs[ MGA1064_SYS_PLL_N ] = 0x1B;
+ pReg->DacRegs[ MGA1064_SYS_PLL_P ] = 0x18;
+ pReg->Option3 = 0x019B8419;
+ pReg->Option = 0x5053C120;
+ }
+ } else {
+ if(pMga->OverclockMem) {
+ /* 125/166 */
+ pReg->DacRegs[ MGA1064_SYS_PLL_M ] = 0x02;
+ pReg->DacRegs[ MGA1064_SYS_PLL_N ] = 0x1B;
+ pReg->DacRegs[ MGA1064_SYS_PLL_P ] = 0x18;
+ pReg->Option3 = 0x019B8419;
+ pReg->Option = 0x5053C120;
+ } else {
+ /* 110/166 */
+ pReg->DacRegs[ MGA1064_SYS_PLL_M ] = 0x13;
+ pReg->DacRegs[ MGA1064_SYS_PLL_N ] = 0x7A;
+ pReg->DacRegs[ MGA1064_SYS_PLL_P ] = 0x08;
+ pReg->Option3 = 0x0190a421;
+ pReg->Option = 0x50044120;
+ }
+ }
+ if(pMga->HasSDRAM)
+ pReg->Option &= ~(1 << 14);
+ pReg->Option2 = 0x01003000;
+ break;
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ default:
+#ifdef USEMGAHAL
+ MGA_HAL(break;);
+#endif
+ if(pMga->OverclockMem) {
+ /* 143 Mhz */
+ pReg->DacRegs[ MGA1064_SYS_PLL_M ] = 0x06;
+ pReg->DacRegs[ MGA1064_SYS_PLL_N ] = 0x24;
+ pReg->DacRegs[ MGA1064_SYS_PLL_P ] = 0x10;
+ } else {
+ /* 124 Mhz */
+ pReg->DacRegs[ MGA1064_SYS_PLL_M ] = 0x04;
+ pReg->DacRegs[ MGA1064_SYS_PLL_N ] = 0x2D;
+ pReg->DacRegs[ MGA1064_SYS_PLL_P ] = 0x19;
+ }
+ pReg->Option2 = 0x00008000;
+ if(pMga->HasSDRAM)
+ pReg->Option = 0x40499121;
+ else
+ pReg->Option = 0x4049cd21;
+ break;
+ }
+
+ MGA_NOT_HAL(
+ /* must always have the pci retries on but rely on
+ polling to keep them from occuring */
+ pReg->Option &= ~0x20000000;
+
+ switch(pLayout->bitsPerPixel)
+ {
+ case 8:
+ pReg->DacRegs[ MGA1064_MUL_CTL ] = MGA1064_MUL_CTL_8bits;
+ break;
+ case 16:
+ pReg->DacRegs[ MGA1064_MUL_CTL ] = MGA1064_MUL_CTL_16bits;
+ if ( (pLayout->weight.red == 5) && (pLayout->weight.green == 5)
+ && (pLayout->weight.blue == 5) ) {
+ weight555 = TRUE;
+ pReg->DacRegs[ MGA1064_MUL_CTL ] = MGA1064_MUL_CTL_15bits;
+ }
+ break;
+ case 24:
+ pReg->DacRegs[ MGA1064_MUL_CTL ] = MGA1064_MUL_CTL_24bits;
+ break;
+ case 32:
+ if(pLayout->Overlay8Plus24) {
+ pReg->DacRegs[ MGA1064_MUL_CTL ] = MGA1064_MUL_CTL_32bits;
+ pReg->DacRegs[ MGA1064_COL_KEY_MSK_LSB ] = 0xFF;
+ pReg->DacRegs[ MGA1064_COL_KEY_LSB ] = pMga->colorKey;
+ } else
+ pReg->DacRegs[ MGA1064_MUL_CTL ] = MGA1064_MUL_CTL_32_24bits;
+ break;
+ default:
+ FatalError("MGA: unsupported depth\n");
+ }
+ ); /* MGA_NOT_HAL */
+
+ /*
+ * This will initialize all of the generic VGA registers.
+ */
+ if (!vgaHWInit(pScrn, mode))
+ return(FALSE);
+
+ /*
+ * Here all of the MGA registers get filled in.
+ */
+ hd = (mode->CrtcHDisplay >> 3) - 1;
+ hs = (mode->CrtcHSyncStart >> 3) - 1;
+ he = (mode->CrtcHSyncEnd >> 3) - 1;
+ ht = (mode->CrtcHTotal >> 3) - 1;
+ vd = mode->CrtcVDisplay - 1;
+ vs = mode->CrtcVSyncStart - 1;
+ ve = mode->CrtcVSyncEnd - 1;
+ vt = mode->CrtcVTotal - 2;
+
+ /* HTOTAL & 0x7 equal to 0x6 in 8bpp or 0x4 in 24bpp causes strange
+ * vertical stripes
+ */
+ if((ht & 0x07) == 0x06 || (ht & 0x07) == 0x04)
+ ht++;
+
+ if (pLayout->bitsPerPixel == 24)
+ wd = (pLayout->displayWidth * 3) >> (4 - BppShift);
+ else
+ wd = pLayout->displayWidth >> (4 - BppShift);
+
+ pReg->ExtVga[0] = 0;
+ pReg->ExtVga[5] = 0;
+
+ if (mode->Flags & V_INTERLACE)
+ {
+ pReg->ExtVga[0] = 0x80;
+ pReg->ExtVga[5] = (hs + he - ht) >> 1;
+ wd <<= 1;
+ vt &= 0xFFFE;
+ }
+
+ pReg->ExtVga[0] |= (wd & 0x300) >> 4;
+ pReg->ExtVga[1] = (((ht - 4) & 0x100) >> 8) |
+ ((hd & 0x100) >> 7) |
+ ((hs & 0x100) >> 6) |
+ (ht & 0x40);
+ pReg->ExtVga[2] = ((vt & 0xc00) >> 10) |
+ ((vd & 0x400) >> 8) |
+ ((vd & 0xc00) >> 7) |
+ ((vs & 0xc00) >> 5);
+ if (pLayout->bitsPerPixel == 24)
+ pReg->ExtVga[3] = (((1 << BppShift) * 3) - 1) | 0x80;
+ else
+ pReg->ExtVga[3] = ((1 << BppShift) - 1) | 0x80;
+
+ pReg->ExtVga[4] = 0;
+
+ pVga->CRTC[0] = ht - 4;
+ pVga->CRTC[1] = hd;
+ pVga->CRTC[2] = hd;
+ pVga->CRTC[3] = (ht & 0x1F) | 0x80;
+ pVga->CRTC[4] = hs;
+ pVga->CRTC[5] = ((ht & 0x20) << 2) | (he & 0x1F);
+ pVga->CRTC[6] = vt & 0xFF;
+ pVga->CRTC[7] = ((vt & 0x100) >> 8 ) |
+ ((vd & 0x100) >> 7 ) |
+ ((vs & 0x100) >> 6 ) |
+ ((vd & 0x100) >> 5 ) |
+ 0x10 |
+ ((vt & 0x200) >> 4 ) |
+ ((vd & 0x200) >> 3 ) |
+ ((vs & 0x200) >> 2 );
+ pVga->CRTC[9] = ((vd & 0x200) >> 4) | 0x40;
+ pVga->CRTC[16] = vs & 0xFF;
+ pVga->CRTC[17] = (ve & 0x0F) | 0x20;
+ pVga->CRTC[18] = vd & 0xFF;
+ pVga->CRTC[19] = wd & 0xFF;
+ pVga->CRTC[21] = vd & 0xFF;
+ pVga->CRTC[22] = (vt + 1) & 0xFF;
+
+ MGA_NOT_HAL(pReg->DacRegs[MGA1064_CURSOR_BASE_ADR_LOW] = pMga->FbCursorOffset >> 10);
+ MGA_NOT_HAL(pReg->DacRegs[MGA1064_CURSOR_BASE_ADR_HI] = pMga->FbCursorOffset >> 18);
+
+ if (pMga->SyncOnGreen) {
+ MGA_NOT_HAL(pReg->DacRegs[MGA1064_GEN_CTL] &= ~0x20);
+ pReg->ExtVga[3] |= 0x40;
+ }
+
+ /* select external clock */
+ pVga->MiscOutReg |= 0x0C;
+
+ MGA_NOT_HAL(
+ if (mode->Flags & V_DBLSCAN)
+ pVga->CRTC[9] |= 0x80;
+
+ if(MGAISGx50(pMga)) {
+ OUTREG(MGAREG_ZORG, 0);
+ }
+
+ MGAGSetPCLK(pScrn, mode->Clock);
+ ); /* MGA_NOT_HAL */
+
+ /* This disables the VGA memory aperture */
+ pVga->MiscOutReg &= ~0x02;
+
+ /* Urgh. Why do we define our own xMODEINFO structure instead
+ * of just passing the blinkin' DisplayModePtr? If we're going to
+ * just cut'n'paste routines from the HALlib, it would be better
+ * just to strip the MacroVision stuff out of the HALlib and release
+ * that, surely?
+ */
+ /********************* Second Crtc programming **************/
+ /* Writing values to crtc2[] array */
+ if (pMga->SecondCrtc)
+ {
+ MGACRTC2Get(pScrn, &ModeInfo);
+ MGACRTC2GetPitch(pScrn, &ModeInfo);
+ MGACRTC2GetDisplayStart(pScrn, &ModeInfo,0,0,0);
+ }
+ return(TRUE);
+}
+
+/*
+ * MGAGLoadPalette
+ */
+
+static void
+MGAPaletteLoadCallback(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAPaletteInfo *pal = pMga->palinfo;
+ int i;
+
+ while (!(INREG8(0x1FDA) & 0x08));
+
+ for(i = 0; i < 256; i++) {
+ if(pal->update) {
+ outMGAdreg(MGA1064_WADR_PAL, i);
+ outMGAdreg(MGA1064_COL_PAL, pal->red);
+ outMGAdreg(MGA1064_COL_PAL, pal->green);
+ outMGAdreg(MGA1064_COL_PAL, pal->blue);
+ pal->update = FALSE;
+ }
+ pal++;
+ }
+ pMga->PaletteLoadCallback = NULL;
+}
+
+void MGAGLoadPalette(
+ ScrnInfoPtr pScrn,
+ int numColors,
+ int *indices,
+ LOCO *colors,
+ VisualPtr pVisual
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if((pMga->CurrentLayout.Overlay8Plus24) && (pVisual->nplanes != 8))
+ return;
+
+ if(pMga->Chipset == PCI_CHIP_MGAG400 || pMga->Chipset == PCI_CHIP_MGAG550){
+ /* load them at the retrace in the block handler instead to
+ work around some problems with static on the screen */
+ while(numColors--) {
+ pMga->palinfo[*indices].update = TRUE;
+ pMga->palinfo[*indices].red = colors[*indices].red;
+ pMga->palinfo[*indices].green = colors[*indices].green;
+ pMga->palinfo[*indices].blue = colors[*indices].blue;
+ indices++;
+ }
+ pMga->PaletteLoadCallback = MGAPaletteLoadCallback;
+ return;
+ } else {
+ while(numColors--) {
+ outMGAdreg(MGA1064_WADR_PAL, *indices);
+ outMGAdreg(MGA1064_COL_PAL, colors[*indices].red);
+ outMGAdreg(MGA1064_COL_PAL, colors[*indices].green);
+ outMGAdreg(MGA1064_COL_PAL, colors[*indices].blue);
+ indices++;
+ }
+ }
+}
+
+/*
+ * MGAGRestorePalette
+ */
+
+static void
+MGAGRestorePalette(ScrnInfoPtr pScrn, unsigned char* pntr)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int i = 768;
+
+ outMGAdreg(MGA1064_WADR_PAL, 0x00);
+ while(i--)
+ outMGAdreg(MGA1064_COL_PAL, *(pntr++));
+}
+
+/*
+ * MGAGSavePalette
+ */
+static void
+MGAGSavePalette(ScrnInfoPtr pScrn, unsigned char* pntr)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int i = 768;
+
+ outMGAdreg(MGA1064_RADR_PAL, 0x00);
+ while(i--)
+ *(pntr++) = inMGAdreg(MGA1064_COL_PAL);
+}
+
+/*
+ * MGAGRestore
+ *
+ * This function restores a video mode. It basically writes out all of
+ * the registers that have previously been saved.
+ */
+static void
+MGAGRestore(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, MGARegPtr mgaReg,
+ Bool restoreFonts)
+{
+ int i;
+ MGAPtr pMga = MGAPTR(pScrn);
+ CARD32 optionMask;
+
+ /*
+ * Pixel Clock needs to be restored regardless if we use
+ * HALLib or not. HALlib doesn't do a good job restoring
+ * VESA modes. MATROX: hint, hint.
+ */
+ if (MGAISGx50(pMga) && mgaReg->Clock) {
+ /*
+ * With HALlib program only when restoring to console!
+ * To test this we check for Clock == 0.
+ */
+ MGAG450SetPLLFreq(pScrn, mgaReg->Clock);
+ mgaReg->PIXPLLCSaved = FALSE;
+ }
+
+ if(!pMga->SecondCrtc) {
+
+MGA_NOT_HAL(
+ /*
+ * Code is needed to get things back to bank zero.
+ */
+
+ /* restore DAC registers
+ * according to the docs we shouldn't write to reserved regs*/
+ for (i = 0; i < DACREGSIZE; i++) {
+ if( (i <= 0x03) ||
+ (i == 0x07) ||
+ (i == 0x0b) ||
+ (i == 0x0f) ||
+ ((i >= 0x13) && (i <= 0x17)) ||
+ (i == 0x1b) ||
+ (i == 0x1c) ||
+ ((i >= 0x1f) && (i <= 0x29)) ||
+ ((i >= 0x30) && (i <= 0x37)) ||
+ (MGAISGx50(pMga) && !mgaReg->PIXPLLCSaved &&
+ ((i == 0x2c) || (i == 0x2d) || (i == 0x2e) ||
+ (i == 0x4c) || (i == 0x4d) || (i == 0x4e))))
+ continue;
+ outMGAdac(i, mgaReg->DacRegs[i]);
+ }
+
+ /* Do not set the memory config for primary cards as it
+ should be correct already */
+ optionMask = (pMga->Primary) ? OPTION1_MASK_PRIMARY : OPTION1_MASK;
+
+ if (!MGAISGx50(pMga)) {
+ /* restore pci_option register */
+ pciSetBitsLong(pMga->PciTag, PCI_OPTION_REG, optionMask,
+ mgaReg->Option);
+ if (pMga->Chipset != PCI_CHIP_MGA1064)
+ pciSetBitsLong(pMga->PciTag, PCI_MGA_OPTION2, OPTION2_MASK,
+ mgaReg->Option2);
+ if (pMga->Chipset == PCI_CHIP_MGAG400 || pMga->Chipset == PCI_CHIP_MGAG550)
+ pciSetBitsLong(pMga->PciTag, PCI_MGA_OPTION3, OPTION3_MASK,
+ mgaReg->Option3);
+ }
+); /* MGA_NOT_HAL */
+#ifdef USEMGAHAL
+ /*
+ * Work around another bug in HALlib: it doesn't restore the
+ * DAC width register correctly. MATROX: hint, hint.
+ */
+ MGA_HAL(
+ outMGAdac(MGA1064_MUL_CTL,mgaReg->DacRegs[0]);
+ outMGAdac(MGA1064_MISC_CTL,mgaReg->DacRegs[1]);
+ if (!MGAISGx50(pMga)) {
+ outMGAdac(MGA1064_PIX_PLLC_M,mgaReg->DacRegs[2]);
+ outMGAdac(MGA1064_PIX_PLLC_N,mgaReg->DacRegs[3]);
+ outMGAdac(MGA1064_PIX_PLLC_P,mgaReg->DacRegs[4]);
+ }
+ );
+#endif
+ /* restore CRTCEXT regs */
+ for (i = 0; i < 6; i++)
+ OUTREG16(0x1FDE, (mgaReg->ExtVga[i] << 8) | i);
+
+ /*
+ * This function handles restoring the generic VGA registers.
+ */
+ vgaHWRestore(pScrn, vgaReg,
+ VGA_SR_MODE | (restoreFonts ? VGA_SR_FONTS : 0));
+ MGAGRestorePalette(pScrn, vgaReg->DAC);
+
+ /*
+ * this is needed to properly restore start address
+ */
+ OUTREG16(0x1FDE, (mgaReg->ExtVga[0] << 8) | 0);
+ } else {
+ /* Second Crtc */
+ xMODEINFO ModeInfo;
+
+MGA_NOT_HAL(
+ /* Enable Dual Head */
+ MGACRTC2Set(pScrn, &ModeInfo);
+ MGAEnableSecondOutPut(pScrn, &ModeInfo);
+ MGACRTC2SetPitch(pScrn, &ModeInfo);
+ MGACRTC2SetDisplayStart(pScrn, &ModeInfo,0,0,0);
+
+ for (i = 0x80; i <= 0xa0; i ++) {
+ if (i== 0x8d) {
+ i = 0x8f;
+ continue;
+ }
+ outMGAdac(i, mgaReg->dac2[ i - 0x80]);
+ }
+); /* MGA_NOT_HAL */
+
+ }
+
+#ifdef DEBUG
+ ErrorF("Setting DAC:");
+ for (i=0; i<DACREGSIZE; i++) {
+#if 1
+ if(!(i%16)) ErrorF("\n%02X: ",i);
+ ErrorF("%02X ", mgaReg->DacRegs[i]);
+#else
+ if(!(i%8)) ErrorF("\n%02X: ",i);
+ ErrorF("0x%02X, ", mgaReg->DacRegs[i]);
+#endif
+ }
+ ErrorF("\nOPTION = %08lX\n", mgaReg->Option);
+ ErrorF("OPTION2 = %08lX\n", mgaReg->Option2);
+ ErrorF("CRTCEXT:");
+ for (i=0; i<6; i++) ErrorF(" %02X", mgaReg->ExtVga[i]);
+ ErrorF("\n");
+#endif
+
+}
+
+/*
+ * MGAGSave
+ *
+ * This function saves the video state.
+ */
+static void
+MGAGSave(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, MGARegPtr mgaReg,
+ Bool saveFonts)
+{
+ int i;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ /*
+ * Pixel Clock needs to be restored regardless if we use
+ * HALLib or not. HALlib doesn't do a good job restoring
+ * VESA modes (s.o.). MATROX: hint, hint.
+ */
+ if (MGAISGx50(pMga)) {
+ mgaReg->Clock = MGAG450SavePLLFreq(pScrn);
+ }
+
+ if(pMga->SecondCrtc == TRUE) {
+ for(i = 0x80; i < 0xa0; i++)
+ mgaReg->dac2[i-0x80] = inMGAdac(i);
+
+ return;
+ }
+
+ MGA_NOT_HAL(
+ /* Allocate the DacRegs space if not done already */
+ if (mgaReg->DacRegs == NULL) {
+ mgaReg->DacRegs = xnfcalloc(DACREGSIZE, 1);
+ }
+ ); /* MGA_NOT_HAL */
+
+ /*
+ * Code is needed to get back to bank zero.
+ */
+ OUTREG16(0x1FDE, 0x0004);
+
+ /*
+ * This function will handle creating the data structure and filling
+ * in the generic VGA portion.
+ */
+ vgaHWSave(pScrn, vgaReg, VGA_SR_MODE | (saveFonts ? VGA_SR_FONTS : 0));
+ MGAGSavePalette(pScrn, vgaReg->DAC);
+ /*
+ * Work around another bug in HALlib: it doesn't restore the
+ * DAC width register correctly.
+ */
+
+#ifdef USEMGAHAL
+ /*
+ * Work around another bug in HALlib: it doesn't restore the
+ * DAC width register correctly (s.o.). MATROX: hint, hint.
+ */
+ MGA_HAL(
+ if (mgaReg->DacRegs == NULL) {
+ mgaReg->DacRegs = xnfcalloc(MGAISGx50(pMga) ? 2 : 5, 1);
+ }
+ mgaReg->DacRegs[0] = inMGAdac(MGA1064_MUL_CTL);
+ mgaReg->DacRegs[1] = inMGAdac(MGA1064_MISC_CTL);
+ if (!MGAISGx50(pMga)) {
+ mgaReg->DacRegs[2] = inMGAdac(MGA1064_PIX_PLLC_M);
+ mgaReg->DacRegs[3] = inMGAdac(MGA1064_PIX_PLLC_N);
+ mgaReg->DacRegs[4] = inMGAdac(MGA1064_PIX_PLLC_P);
+ }
+ );
+#endif
+ MGA_NOT_HAL(
+ /*
+ * The port I/O code necessary to read in the extended registers.
+ */
+ for (i = 0; i < DACREGSIZE; i++)
+ mgaReg->DacRegs[i] = inMGAdac(i);
+
+ mgaReg->PIXPLLCSaved = TRUE;
+
+ mgaReg->Option = pciReadLong(pMga->PciTag, PCI_OPTION_REG);
+
+ mgaReg->Option2 = pciReadLong(pMga->PciTag, PCI_MGA_OPTION2);
+ if (pMga->Chipset == PCI_CHIP_MGAG400 || pMga->Chipset == PCI_CHIP_MGAG550)
+ mgaReg->Option3 = pciReadLong(pMga->PciTag, PCI_MGA_OPTION3);
+ ); /* MGA_NOT_HAL */
+
+ for (i = 0; i < 6; i++)
+ {
+ OUTREG8(0x1FDE, i);
+ mgaReg->ExtVga[i] = INREG8(0x1FDF);
+ }
+#ifdef DEBUG
+ ErrorF("Saved values:\nDAC:");
+ for (i=0; i<DACREGSIZE; i++) {
+#if 1
+ if(!(i%16)) ErrorF("\n%02X: ",i);
+ ErrorF("%02X ", mgaReg->DacRegs[i]);
+#else
+ if(!(i%8)) ErrorF("\n%02X: ",i);
+ ErrorF("0x%02X, ", mgaReg->DacRegs[i]);
+#endif
+ }
+ ErrorF("\nOPTION = %08lX\n:", mgaReg->Option);
+ ErrorF("OPTION2 = %08lX\nCRTCEXT:", mgaReg->Option2);
+ for (i=0; i<6; i++) ErrorF(" %02X", mgaReg->ExtVga[i]);
+ ErrorF("\n");
+#endif
+}
+
+/****
+ *** HW Cursor
+ */
+static void
+MGAGLoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ CARD32 *dst = (CARD32*)(pMga->FbBase + pMga->FbCursorOffset);
+ int i = 128;
+
+ /* swap bytes in each line */
+ while( i-- ) {
+ *dst++ = (src[4] << 24) | (src[5] << 16) | (src[6] << 8) | src[7];
+ *dst++ = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3];
+ src += 8;
+ }
+}
+
+static void
+MGAGShowCursor(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ /* Enable cursor - X-Windows mode */
+ outMGAdac(MGA1064_CURSOR_CTL, 0x03);
+}
+
+static void
+MGAGShowCursorG100(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ /* Enable cursor - X-Windows mode */
+ outMGAdac(MGA1064_CURSOR_CTL, 0x01);
+}
+
+static void
+MGAGHideCursor(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ /* Disable cursor */
+ outMGAdac(MGA1064_CURSOR_CTL, 0x00);
+}
+
+static void
+MGAGSetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ x += 64;
+ y += 64;
+#ifdef USEMGAHAL
+ MGA_HAL(
+ x += pMga->HALGranularityOffX;
+ y += pMga->HALGranularityOffY;
+ );
+#endif
+ /* cursor update must never occurs during a retrace period (pp 4-160) */
+ while( INREG( MGAREG_Status ) & 0x08 );
+
+ /* Output position - "only" 12 bits of location documented */
+ OUTREG8( RAMDAC_OFFSET + MGA1064_CUR_XLOW, (x & 0xFF));
+ OUTREG8( RAMDAC_OFFSET + MGA1064_CUR_XHI, (x & 0xF00) >> 8);
+ OUTREG8( RAMDAC_OFFSET + MGA1064_CUR_YLOW, (y & 0xFF));
+ OUTREG8( RAMDAC_OFFSET + MGA1064_CUR_YHI, (y & 0xF00) >> 8);
+}
+
+
+static void
+MGAGSetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ /* Background color */
+ outMGAdac(MGA1064_CURSOR_COL0_RED, (bg & 0x00FF0000) >> 16);
+ outMGAdac(MGA1064_CURSOR_COL0_GREEN, (bg & 0x0000FF00) >> 8);
+ outMGAdac(MGA1064_CURSOR_COL0_BLUE, (bg & 0x000000FF));
+
+ /* Foreground color */
+ outMGAdac(MGA1064_CURSOR_COL1_RED, (fg & 0x00FF0000) >> 16);
+ outMGAdac(MGA1064_CURSOR_COL1_GREEN, (fg & 0x0000FF00) >> 8);
+ outMGAdac(MGA1064_CURSOR_COL1_BLUE, (fg & 0x000000FF));
+}
+
+static void
+MGAGSetCursorColorsG100(ScrnInfoPtr pScrn, int bg, int fg)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ /* Background color */
+ outMGAdac(MGA1064_CURSOR_COL1_RED, (bg & 0x00FF0000) >> 16);
+ outMGAdac(MGA1064_CURSOR_COL1_GREEN, (bg & 0x0000FF00) >> 8);
+ outMGAdac(MGA1064_CURSOR_COL1_BLUE, (bg & 0x000000FF));
+
+ /* Foreground color */
+ outMGAdac(MGA1064_CURSOR_COL2_RED, (fg & 0x00FF0000) >> 16);
+ outMGAdac(MGA1064_CURSOR_COL2_GREEN, (fg & 0x0000FF00) >> 8);
+ outMGAdac(MGA1064_CURSOR_COL2_BLUE, (fg & 0x000000FF));
+}
+
+static Bool
+MGAGUseHWCursor(ScreenPtr pScrn, CursorPtr pCurs)
+{
+ MGAPtr pMga = MGAPTR(xf86Screens[pScrn->myNum]);
+ /* This needs to detect if its on the second dac */
+ if( XF86SCRNINFO(pScrn)->currentMode->Flags & V_DBLSCAN )
+ return FALSE;
+ if( pMga->SecondCrtc == TRUE )
+ return FALSE;
+ return TRUE;
+}
+
+
+/*
+ * According to mga-1064g.pdf pp215-216 (4-179 & 4-180) the low bits of
+ * XGENIODATA and XGENIOCTL are connected to the 4 DDC pins, but don't say
+ * which VGA line is connected to each DDC pin, so I've had to guess.
+ *
+ * DDC1 support only requires DDC_SDA_MASK,
+ * DDC2 support reuqiers DDC_SDA_MASK and DDC_SCL_MASK
+ */
+static const int DDC_SDA_MASK = 1 << 1;
+static const int DDC_SCL_MASK = 1 << 3;
+
+static unsigned int
+MGAG_ddc1Read(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ unsigned char val;
+
+ /* Define the SDA as an input */
+ outMGAdacmsk(MGA1064_GEN_IO_CTL, ~(DDC_SCL_MASK | DDC_SDA_MASK), 0);
+
+ /* wait for Vsync */
+ while( INREG( MGAREG_Status ) & 0x08 );
+ while( ! (INREG( MGAREG_Status ) & 0x08) );
+
+ /* Get the result */
+ val = (inMGAdac(MGA1064_GEN_IO_DATA) & DDC_SDA_MASK);
+ return val;
+}
+
+static void
+MGAG_I2CGetBits(I2CBusPtr b, int *clock, int *data)
+{
+ MGAPtr pMga = MGAPTR(xf86Screens[b->scrnIndex]);
+ unsigned char val;
+
+ /* Get the result. */
+ val = inMGAdac(MGA1064_GEN_IO_DATA);
+
+ *clock = (val & DDC_SCL_MASK) != 0;
+ *data = (val & DDC_SDA_MASK) != 0;
+#ifdef DEBUG
+ ErrorF("MGAG_I2CGetBits(%p,...) val=0x%x, returns clock %d, data %d\n", b, val, *clock, *data);
+#endif
+}
+
+/*
+ * ATTENTION! - the DATA and CLOCK lines need to be tri-stated when
+ * high. Therefore turn off output driver for the line to set line
+ * to high. High signal is maintained by a 15k Ohm pll-up resistor.
+ */
+static void
+MGAG_I2CPutBits(I2CBusPtr b, int clock, int data)
+{
+ MGAPtr pMga = MGAPTR(xf86Screens[b->scrnIndex]);
+ unsigned char drv, val;
+
+ val = (clock ? DDC_SCL_MASK : 0) | (data ? DDC_SDA_MASK : 0);
+ drv = ((!clock) ? DDC_SCL_MASK : 0) | ((!data) ? DDC_SDA_MASK : 0);
+
+ /* Write the values */
+ outMGAdacmsk(MGA1064_GEN_IO_CTL, ~(DDC_SCL_MASK | DDC_SDA_MASK) , drv);
+ outMGAdacmsk(MGA1064_GEN_IO_DATA, ~(DDC_SCL_MASK | DDC_SDA_MASK) , val);
+#ifdef DEBUG
+ ErrorF("MGAG_I2CPutBits(%p, %d, %d) val=0x%x\n", b, clock, data, val);
+#endif
+}
+
+
+Bool
+MGAG_i2cInit(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ I2CBusPtr I2CPtr;
+
+ I2CPtr = xf86CreateI2CBusRec();
+ if(!I2CPtr) return FALSE;
+
+ pMga->I2C = I2CPtr;
+
+ I2CPtr->BusName = "DDC";
+ I2CPtr->scrnIndex = pScrn->scrnIndex;
+ I2CPtr->I2CPutBits = MGAG_I2CPutBits;
+ I2CPtr->I2CGetBits = MGAG_I2CGetBits;
+ I2CPtr->AcknTimeout = 5;
+
+ if (!xf86I2CBusInit(I2CPtr)) {
+ return FALSE;
+ }
+ return TRUE;
+}
+
+
+/*
+ * MGAGRamdacInit
+ * Handle broken G100 special.
+ */
+static void
+MGAGRamdacInit(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARamdacPtr MGAdac = &pMga->Dac;
+
+ MGAdac->isHwCursor = TRUE;
+ MGAdac->CursorOffscreenMemSize = 1024;
+ MGAdac->CursorMaxWidth = 64;
+ MGAdac->CursorMaxHeight = 64;
+ MGAdac->SetCursorPosition = MGAGSetCursorPosition;
+ MGAdac->LoadCursorImage = MGAGLoadCursorImage;
+ MGAdac->HideCursor = MGAGHideCursor;
+ if ((pMga->Chipset == PCI_CHIP_MGAG100)
+ || (pMga->Chipset == PCI_CHIP_MGAG100)) {
+ MGAdac->SetCursorColors = MGAGSetCursorColorsG100;
+ MGAdac->ShowCursor = MGAGShowCursorG100;
+ } else {
+ MGAdac->SetCursorColors = MGAGSetCursorColors;
+ MGAdac->ShowCursor = MGAGShowCursor;
+ }
+ MGAdac->UseHWCursor = MGAGUseHWCursor;
+ MGAdac->CursorFlags =
+#if X_BYTE_ORDER == X_LITTLE_ENDIAN
+ HARDWARE_CURSOR_BIT_ORDER_MSBFIRST |
+#endif
+ HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64 |
+ HARDWARE_CURSOR_TRUECOLOR_AT_8BPP;
+
+ MGAdac->LoadPalette = MGAGLoadPalette;
+
+ if ( pMga->Bios2.PinID && pMga->Bios2.PclkMax != 0xFF )
+ {
+ MGAdac->maxPixelClock = (pMga->Bios2.PclkMax + 100) * 1000;
+ MGAdac->ClockFrom = X_PROBED;
+ }
+ else
+ {
+ switch( pMga->Chipset )
+ {
+ case PCI_CHIP_MGA1064:
+ if ( pMga->ChipRev < 3 )
+ MGAdac->maxPixelClock = 170000;
+ else
+ MGAdac->maxPixelClock = 220000;
+ break;
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG550:
+ /* We don't know the new pins format but we know that
+ the maxclock / 4 is where the RamdacType was in the
+ old pins format */
+ MGAdac->maxPixelClock = pMga->Bios2.RamdacType * 4000;
+ if(MGAdac->maxPixelClock < 300000)
+ MGAdac->maxPixelClock = 300000;
+ break;
+ default:
+ MGAdac->maxPixelClock = 250000;
+ }
+ MGAdac->ClockFrom = X_DEFAULT;
+ }
+
+ /* Disable interleaving and set the rounding value */
+ pMga->Interleave = FALSE;
+
+ pMga->Roundings[0] = 64;
+ pMga->Roundings[1] = 32;
+ pMga->Roundings[2] = 64;
+ pMga->Roundings[3] = 32;
+
+ /* Clear Fast bitblt flag */
+ pMga->HasFBitBlt = FALSE;
+}
+
+void MGAGSetupFuncs(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ pMga->PreInit = MGAGRamdacInit;
+ pMga->Save = MGAGSave;
+ pMga->Restore = MGAGRestore;
+ pMga->ModeInit = MGAGInit;
+ pMga->ddc1Read = MGAG_ddc1Read;
+ /* vgaHWddc1SetSpeed will only work if the card is in VGA mode */
+ pMga->DDC1SetSpeed = vgaHWddc1SetSpeed;
+ pMga->i2cInit = MGAG_i2cInit;
+}
+
diff --git a/src/mga_dga.c b/src/mga_dga.c
new file mode 100644
index 0000000..d6735b1
--- /dev/null
+++ b/src/mga_dga.c
@@ -0,0 +1,459 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_dga.c,v 1.16 2002/09/16 18:05:55 eich Exp $ */
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+#include "xf86Pci.h"
+#include "xf86PciInfo.h"
+#include "xaa.h"
+#include "xaalocal.h"
+#include "mga_bios.h"
+#include "mga.h"
+#include "mga_reg.h"
+#include "dgaproc.h"
+
+
+static Bool MGA_OpenFramebuffer(ScrnInfoPtr, char **, unsigned char **,
+ int *, int *, int *);
+static Bool MGA_SetMode(ScrnInfoPtr, DGAModePtr);
+static int MGA_GetViewport(ScrnInfoPtr);
+static void MGA_SetViewport(ScrnInfoPtr, int, int, int);
+static void MGA_FillRect(ScrnInfoPtr, int, int, int, int, unsigned long);
+static void MGA_BlitRect(ScrnInfoPtr, int, int, int, int, int, int);
+static void MGA_BlitTransRect(ScrnInfoPtr, int, int, int, int, int, int,
+ unsigned long);
+
+static
+DGAFunctionRec MGA_DGAFuncs = {
+ MGA_OpenFramebuffer,
+ NULL,
+ MGA_SetMode,
+ MGA_SetViewport,
+ MGA_GetViewport,
+ MGAStormSync,
+ MGA_FillRect,
+ MGA_BlitRect,
+ MGA_BlitTransRect
+};
+
+
+static int
+FindSmallestPitch(
+ MGAPtr pMga,
+ int Bpp,
+ int width
+){
+ int Pitches1[] =
+ {640, 768, 800, 960, 1024, 1152, 1280, 1600, 1920, 2048, 0};
+ int Pitches2[] =
+ {512, 640, 768, 800, 832, 960, 1024, 1152, 1280, 1600, 1664,
+ 1920, 2048, 0};
+ int *linePitches = NULL;
+ int pitch;
+
+
+ if(!pMga->NoAccel) {
+ switch(pMga->Chipset) {
+ case PCI_CHIP_MGA2064:
+ linePitches = Pitches1;
+ break;
+ case PCI_CHIP_MGA2164:
+ case PCI_CHIP_MGA2164_AGP:
+ case PCI_CHIP_MGA1064:
+ linePitches = Pitches2;
+ break;
+ }
+ }
+
+ pitch = pMga->Roundings[Bpp - 1] - 1;
+
+ if(linePitches) {
+ while((*linePitches < width) || (*linePitches & pitch))
+ linePitches++;
+ return *linePitches;
+ }
+
+ return ((width + pitch) & ~pitch);
+}
+
+static DGAModePtr
+MGASetupDGAMode(
+ ScrnInfoPtr pScrn,
+ DGAModePtr modes,
+ int *num,
+ int bitsPerPixel,
+ int depth,
+ Bool pixmap,
+ int secondPitch,
+ unsigned long red,
+ unsigned long green,
+ unsigned long blue,
+ short visualClass
+){
+ DisplayModePtr firstMode, pMode;
+ MGAPtr pMga = MGAPTR(pScrn);
+ DGAModePtr mode, newmodes;
+ int size, pitch, Bpp = bitsPerPixel >> 3;
+
+SECOND_PASS:
+
+ pMode = firstMode = pScrn->modes;
+
+ while(1) {
+
+
+ pitch = FindSmallestPitch(pMga, Bpp, pMode->HDisplay);
+ size = pitch * Bpp * pMode->VDisplay;
+
+ if((!secondPitch || (pitch != secondPitch)) &&
+ (size <= pMga->FbUsableSize)) {
+
+ if(secondPitch)
+ pitch = secondPitch;
+
+ if(!(newmodes = xrealloc(modes, (*num + 1) * sizeof(DGAModeRec))))
+ break;
+
+ modes = newmodes;
+ mode = modes + *num;
+
+ mode->mode = pMode;
+ mode->flags = DGA_CONCURRENT_ACCESS;
+ if(pixmap)
+ mode->flags |= DGA_PIXMAP_AVAILABLE;
+ if(!pMga->NoAccel) {
+ mode->flags |= DGA_FILL_RECT | DGA_BLIT_RECT;
+ if((Bpp != 3) && (pMga->Chipset != PCI_CHIP_MGA2064))
+ mode->flags |= DGA_BLIT_RECT_TRANS;
+ }
+ if(pMode->Flags & V_DBLSCAN)
+ mode->flags |= DGA_DOUBLESCAN;
+ if(pMode->Flags & V_INTERLACE)
+ mode->flags |= DGA_INTERLACED;
+ mode->byteOrder = pScrn->imageByteOrder;
+ mode->depth = depth;
+ mode->bitsPerPixel = bitsPerPixel;
+ mode->red_mask = red;
+ mode->green_mask = green;
+ mode->blue_mask = blue;
+ mode->visualClass = visualClass;
+ mode->viewportWidth = pMode->HDisplay;
+ mode->viewportHeight = pMode->VDisplay;
+ mode->xViewportStep = (3 - pMga->BppShifts[Bpp - 1]);
+ if((Bpp == 3) &&
+ (pMga->Chipset == PCI_CHIP_MGAG400 || pMga->Chipset == PCI_CHIP_MGAG550))
+ mode->xViewportStep <<= 1;
+ mode->yViewportStep = 1;
+ mode->viewportFlags = DGA_FLIP_RETRACE;
+ mode->offset = pMga->YDstOrg * Bpp; /* gonna need to fix that */
+ mode->address = pMga->FbStart;
+ mode->bytesPerScanline = pitch * Bpp;
+ mode->imageWidth = pitch;
+ mode->imageHeight = pMga->FbUsableSize / mode->bytesPerScanline;
+ mode->pixmapWidth = pitch;
+ mode->pixmapHeight = (min(pMga->FbUsableSize, 16*1024*1024)) /
+ mode->bytesPerScanline;
+ mode->maxViewportX = mode->imageWidth - mode->viewportWidth;
+ mode->maxViewportY = (pMga->FbUsableSize / mode->bytesPerScanline) -
+ mode->viewportHeight;
+
+ if( (pMga->Chipset == PCI_CHIP_MGA2064) ||
+ (pMga->Chipset == PCI_CHIP_MGA2164) ||
+ (pMga->Chipset == PCI_CHIP_MGA2164_AGP))
+ {
+ int tmp;
+
+ tmp = (8*1024*1024 / mode->bytesPerScanline) -
+ mode->viewportHeight;
+ if(tmp < 0) tmp = 0;
+ if(tmp < mode->maxViewportY)
+ mode->maxViewportY = tmp;
+ }
+
+ (*num)++;
+ }
+
+ pMode = pMode->next;
+ if(pMode == firstMode)
+ break;
+ }
+
+ if(secondPitch) {
+ secondPitch = 0;
+ goto SECOND_PASS;
+ }
+
+ return modes;
+}
+
+
+Bool
+MGADGAInit(ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ DGAModePtr modes = NULL;
+ int num = 0;
+
+ /* 8 */
+ modes = MGASetupDGAMode (pScrn, modes, &num, 8, 8,
+ (pScrn->bitsPerPixel == 8),
+ (pScrn->bitsPerPixel != 8) ? 0 : pScrn->displayWidth,
+ 0, 0, 0, PseudoColor);
+
+ /* 15 */
+ modes = MGASetupDGAMode (pScrn, modes, &num, 16, 15,
+ (pScrn->bitsPerPixel == 16),
+ (pScrn->depth != 15) ? 0 : pScrn->displayWidth,
+ 0x7c00, 0x03e0, 0x001f, TrueColor);
+
+ modes = MGASetupDGAMode (pScrn, modes, &num, 16, 15,
+ (pScrn->bitsPerPixel == 16),
+ (pScrn->depth != 15) ? 0 : pScrn->displayWidth,
+ 0x7c00, 0x03e0, 0x001f, DirectColor);
+
+ /* 16 */
+ modes = MGASetupDGAMode (pScrn, modes, &num, 16, 16,
+ (pScrn->bitsPerPixel == 16),
+ (pScrn->depth != 16) ? 0 : pScrn->displayWidth,
+ 0xf800, 0x07e0, 0x001f, TrueColor);
+
+ modes = MGASetupDGAMode (pScrn, modes, &num, 16, 16,
+ (pScrn->bitsPerPixel == 16),
+ (pScrn->depth != 16) ? 0 : pScrn->displayWidth,
+ 0xf800, 0x07e0, 0x001f, DirectColor);
+
+ /* 24 */
+ modes = MGASetupDGAMode (pScrn, modes, &num, 24, 24,
+ (pScrn->bitsPerPixel == 24),
+ (pScrn->bitsPerPixel != 24) ? 0 : pScrn->displayWidth,
+ 0xff0000, 0x00ff00, 0x0000ff, TrueColor);
+
+ modes = MGASetupDGAMode (pScrn, modes, &num, 24, 24,
+ (pScrn->bitsPerPixel == 24),
+ (pScrn->bitsPerPixel != 24) ? 0 : pScrn->displayWidth,
+ 0xff0000, 0x00ff00, 0x0000ff, DirectColor);
+
+ /* 32 */
+ modes = MGASetupDGAMode (pScrn, modes, &num, 32, 24,
+ (pScrn->bitsPerPixel == 32),
+ (pScrn->bitsPerPixel != 32) ? 0 : pScrn->displayWidth,
+ 0xff0000, 0x00ff00, 0x0000ff, TrueColor);
+
+ modes = MGASetupDGAMode (pScrn, modes, &num, 32, 24,
+ (pScrn->bitsPerPixel == 32),
+ (pScrn->bitsPerPixel != 32) ? 0 : pScrn->displayWidth,
+ 0xff0000, 0x00ff00, 0x0000ff, DirectColor);
+
+ pMga->numDGAModes = num;
+ pMga->DGAModes = modes;
+
+ return DGAInit(pScreen, &MGA_DGAFuncs, modes, num);
+}
+
+
+static int
+BitsSet(unsigned long data)
+{
+ unsigned long mask;
+ int set = 0;
+
+ for(mask = 1; mask; mask <<= 1)
+ if(mask & data) set++;
+
+ return set;
+}
+
+static Bool
+MGA_SetMode(
+ ScrnInfoPtr pScrn,
+ DGAModePtr pMode
+){
+ static MGAFBLayout SavedLayouts[MAXSCREENS];
+ int index = pScrn->pScreen->myNum;
+
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if(!pMode) { /* restore the original mode */
+ if(pMga->DGAactive)
+ memcpy(&pMga->CurrentLayout, &SavedLayouts[index], sizeof(MGAFBLayout));
+
+ pScrn->currentMode = pMga->CurrentLayout.mode;
+ pScrn->SwitchMode(index, pScrn->currentMode, 0);
+ MGAAdjustFrame(index, pScrn->frameX0, pScrn->frameY0, 0);
+ pMga->DGAactive = FALSE;
+ } else {
+ if(!pMga->DGAactive) { /* save the old parameters */
+ memcpy(&SavedLayouts[index], &pMga->CurrentLayout, sizeof(MGAFBLayout));
+ pMga->DGAactive = TRUE;
+ }
+ /* update CurrentLayout */
+ pMga->CurrentLayout.bitsPerPixel = pMode->bitsPerPixel;
+ pMga->CurrentLayout.depth = pMode->depth;
+ pMga->CurrentLayout.displayWidth = pMode->bytesPerScanline /
+ (pMode->bitsPerPixel >> 3);
+ pMga->CurrentLayout.weight.red = BitsSet(pMode->red_mask);
+ pMga->CurrentLayout.weight.green = BitsSet(pMode->green_mask);
+ pMga->CurrentLayout.weight.blue = BitsSet(pMode->blue_mask);
+ pMga->CurrentLayout.Overlay8Plus24 = FALSE;
+ /* MGAModeInit() will set the mode field */
+
+ pScrn->SwitchMode(index, pMode->mode, 0);
+ }
+
+ return TRUE;
+}
+
+
+
+static int
+MGA_GetViewport(
+ ScrnInfoPtr pScrn
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ return pMga->DGAViewportStatus;
+}
+
+static void
+MGA_SetViewport(
+ ScrnInfoPtr pScrn,
+ int x, int y,
+ int flags
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ MGAAdjustFrame(pScrn->pScreen->myNum, x, y, flags);
+ pMga->DGAViewportStatus = 0; /* MGAAdjustFrame loops until finished */
+}
+
+static void
+MGA_FillRect (
+ ScrnInfoPtr pScrn,
+ int x, int y, int w, int h,
+ unsigned long color
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if(!pMga->AccelInfoRec) return;
+
+ switch(pMga->CurrentLayout.bitsPerPixel) {
+ case 8:
+ Mga8SetupForSolidFill(pScrn, color, GXcopy, ~0);
+ break;
+ case 16:
+ Mga16SetupForSolidFill(pScrn, color, GXcopy, ~0);
+ break;
+ case 24:
+ Mga24SetupForSolidFill(pScrn, color, GXcopy, ~0);
+ break;
+ case 32:
+ Mga32SetupForSolidFill(pScrn, color, GXcopy, ~0);
+ break;
+ }
+
+ (*pMga->AccelInfoRec->SubsequentSolidFillRect)(pScrn, x, y, w, h);
+
+ SET_SYNC_FLAG(pMga->AccelInfoRec);
+}
+
+static void
+MGA_BlitRect(
+ ScrnInfoPtr pScrn,
+ int srcx, int srcy,
+ int w, int h,
+ int dstx, int dsty
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ int xdir = ((srcx < dstx) && (srcy == dsty)) ? -1 : 1;
+ int ydir = (srcy < dsty) ? -1 : 1;
+
+ if(!pMga->AccelInfoRec) return;
+
+ switch(pMga->CurrentLayout.bitsPerPixel) {
+ case 8:
+ Mga8SetupForScreenToScreenCopy(
+ pScrn, xdir, ydir, GXcopy, ~0, -1);
+ break;
+ case 16:
+ Mga16SetupForScreenToScreenCopy(
+ pScrn, xdir, ydir, GXcopy, ~0, -1);
+ break;
+ case 24:
+ Mga24SetupForScreenToScreenCopy(
+ pScrn, xdir, ydir, GXcopy, ~0, -1);
+ break;
+ case 32:
+ Mga32SetupForScreenToScreenCopy(
+ pScrn, xdir, ydir, GXcopy, ~0, -1);
+ break;
+ }
+
+ (*pMga->AccelInfoRec->SubsequentScreenToScreenCopy)(
+ pScrn, srcx, srcy, dstx, dsty, w, h);
+
+ SET_SYNC_FLAG(pMga->AccelInfoRec);
+}
+
+
+static void
+MGA_BlitTransRect(
+ ScrnInfoPtr pScrn,
+ int srcx, int srcy,
+ int w, int h,
+ int dstx, int dsty,
+ unsigned long color
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ int xdir = ((srcx < dstx) && (srcy == dsty)) ? -1 : 1;
+ int ydir = (srcy < dsty) ? -1 : 1;
+
+ if(!pMga->AccelInfoRec) return;
+ if(pMga->CurrentLayout.bitsPerPixel == 24) return;
+ if(pMga->Chipset == PCI_CHIP_MGA2064) return;
+
+ pMga->DrawTransparent = TRUE;
+
+ switch(pMga->CurrentLayout.bitsPerPixel) {
+ case 8:
+ Mga8SetupForScreenToScreenCopy(
+ pScrn, xdir, ydir, GXcopy, ~0, color);
+ break;
+ case 16:
+ Mga16SetupForScreenToScreenCopy(
+ pScrn, xdir, ydir, GXcopy, ~0, color);
+ break;
+ case 32:
+ Mga32SetupForScreenToScreenCopy(
+ pScrn, xdir, ydir, GXcopy, ~0, color);
+ break;
+ }
+
+ pMga->DrawTransparent = FALSE;
+
+ (*pMga->AccelInfoRec->SubsequentScreenToScreenCopy)(
+ pScrn, srcx, srcy, dstx, dsty, w, h);
+
+ SET_SYNC_FLAG(pMga->AccelInfoRec);
+}
+
+
+static Bool
+MGA_OpenFramebuffer(
+ ScrnInfoPtr pScrn,
+ char **name,
+ unsigned char **mem,
+ int *size,
+ int *offset,
+ int *flags
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ *name = NULL; /* no special device */
+ *mem = (unsigned char*)pMga->FbAddress;
+ *size = pMga->FbMapSize;
+ *offset = 0;
+ *flags = DGA_NEED_ROOT;
+
+ return TRUE;
+}
diff --git a/src/mga_dh.c b/src/mga_dh.c
new file mode 100644
index 0000000..79c8510
--- /dev/null
+++ b/src/mga_dh.c
@@ -0,0 +1,518 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_dh.c,v 1.4 2002/01/11 15:42:57 dawes Exp $ */
+/*********************************************************************
+* G450: This is for Dual Head.
+* Matrox Graphics
+* Author : Luugi Marsan
+**********************************************************************/
+
+
+/* All drivers should typically include these */
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+
+/* Drivers for PCI hardware need this */
+#include "xf86PciInfo.h"
+
+/* Drivers that need to access the PCI config space directly need this */
+#include "xf86Pci.h"
+
+#include "mga_bios.h"
+#include "mga_reg.h"
+#include "mga.h"
+
+#define MNP_TABLE_SIZE 64
+#define CLKSEL_MGA 0x0c
+#define PLLLOCK 0x40
+
+/* CRTC2 control field*/
+#define C2_EN_A 0
+#define C2_EN_M (1 << C2_EN_A)
+#define C2_HIPRILVL_A 4
+#define C2_HIPRILVL_M (7 << C2_HIPRILVL_A)
+#define C2_MAXHIPRI_A 8
+#define C2_MAXHIPRI_M (7 << C2_MAXHIPRI_A)
+
+#define C2CTL_PIXCLKSEL_SHIFT 1L
+#define C2CTL_PIXCLKSEL_MASK (3L << C2CTL_PIXCLKSEL_SHIFT)
+#define C2CTL_PIXCLKSELH_SHIFT 14L
+#define C2CTL_PIXCLKSELH_MASK (1L << C2CTL_PIXCLKSELH_SHIFT)
+#define C2CTL_PIXCLKSEL_PCICLK 0L
+#define C2CTL_PIXCLKSEL_VDOCLK (1L << C2CTL_PIXCLKSEL_SHIFT)
+#define C2CTL_PIXCLKSEL_PIXELPLL (2L << C2CTL_PIXCLKSEL_SHIFT)
+#define C2CTL_PIXCLKSEL_VIDEOPLL (3L << C2CTL_PIXCLKSEL_SHIFT)
+#define C2CTL_PIXCLKSEL_VDCLK (1L << C2CTL_PIXCLKSELH_SHIFT)
+
+#define C2CTL_PIXCLKSEL_CRISTAL (1L << C2CTL_PIXCLKSEL_SHIFT) | (1L << C2CTL_PIXCLKSELH_SHIFT)
+#define C2CTL_PIXCLKSEL_SYSTEMPLL (2L << C2CTL_PIXCLKSEL_SHIFT) | (1L << C2CTL_PIXCLKSELH_SHIFT)
+
+#define C2CTL_PIXCLKDIS_SHIFT 3L
+#define C2CTL_PIXCLKDIS_MASK (1L << C2CTL_PIXCLKDIS_SHIFT)
+#define C2CTL_PIXCLKDIS_DISABLE (1L << C2CTL_PIXCLKDIS_SHIFT)
+
+#define C2CTL_CRTCDACSEL_SHIFT 20L
+#define C2CTL_CRTCDACSEL_MASK (1L << C2CTL_CRTCDACSEL_SHIFT)
+#define C2CTL_CRTCDACSEL_CRTC1 0
+#define C2CTL_CRTCDACSEL_CRTC2 (1L << C2CTL_CRTCDACSEL_SHIFT)
+
+/* Misc field*/
+#define IOADDSEL 0x01
+#define RAMMAPEN 0x02
+#define CLKSEL_25175 0x00
+#define CLKSEL_28322 0x04
+#define CLKSEL_MGA 0x0c
+#define VIDEODIS 0x10
+#define HPGODDEV 0x20
+#define HSYNCPOL 0x40
+#define VSYNCPOL 0x80
+
+/* XSYNCCTRL field */
+#define XSYNCCTRL_DAC1HSPOL_SHIFT 2
+#define XSYNCCTRL_DAC1HSPOL_MASK (1 << XSYNCCTRL_DAC1HSPOL_SHIFT)
+#define XSYNCCTRL_DAC1HSPOL_NEG (1 << XSYNCCTRL_DAC1HSPOL_SHIFT)
+#define XSYNCCTRL_DAC1HSPOL_POS 0
+#define XSYNCCTRL_DAC1VSPOL_SHIFT 3
+#define XSYNCCTRL_DAC1VSPOL_MASK (1 << XSYNCCTRL_DAC1VSPOL_SHIFT)
+#define XSYNCCTRL_DAC1VSPOL_NEG (1 << XSYNCCTRL_DAC1VSPOL_SHIFT)
+#define XSYNCCTRL_DAC1VSPOL_POS 0
+#define XSYNCCTRL_DAC2HSPOL_SHIFT 6
+#define XSYNCCTRL_DAC2HSPOL_MASK (1 << XSYNCCTRL_DAC2HSPOL_SHIFT)
+#define XSYNCCTRL_DAC2HSPOL_NEG (1 << XSYNCCTRL_DAC2HSPOL_SHIFT)
+#define XSYNCCTRL_DAC2HSPOL_POS 0
+#define XSYNCCTRL_DAC2VSPOL_SHIFT 7
+#define XSYNCCTRL_DAC2VSPOL_MASK (1 << XSYNCCTRL_DAC2VSPOL_SHIFT)
+#define XSYNCCTRL_DAC2VSPOL_NEG (1 << XSYNCCTRL_DAC2VSPOL_SHIFT)
+#define XSYNCCTRL_DAC2VSPOL_POS 0
+#define XSYNCCTRL_DAC1HSOFF_SHIFT 0
+#define XSYNCCTRL_DAC1HSOFF_MASK (1 << XSYNCCTRL_DAC1HSOFF_SHIFT)
+#define XSYNCCTRL_DAC1HSOFF_OFF (1 << XSYNCCTRL_DAC1HSOFF_SHIFT)
+#define XSYNCCTRL_DAC1HSOFF_ON 1
+#define XSYNCCTRL_DAC1VSOFF_SHIFT 1
+#define XSYNCCTRL_DAC1VSOFF_MASK (1 << XSYNCCTRL_DAC1VSOFF_SHIFT)
+#define XSYNCCTRL_DAC1VSOFF_OFF (1 << XSYNCCTRL_DAC1VSOFF_SHIFT)
+#define XSYNCCTRL_DAC1VSOFF_ON 0
+#define XSYNCCTRL_DAC2HSOFF_SHIFT 4
+#define XSYNCCTRL_DAC2HSOFF_MASK (1 << XSYNCCTRL_DAC2HSOFF_SHIFT)
+#define XSYNCCTRL_DAC2HSOFF_OFF (1 << XSYNCCTRL_DAC2HSOFF_SHIFT)
+#define XSYNCCTRL_DAC2HSOFF_ON 0
+#define XSYNCCTRL_DAC2VSOFF_SHIFT 5
+#define XSYNCCTRL_DAC2VSOFF_MASK (1 << XSYNCCTRL_DAC2VSOFF_SHIFT)
+#define XSYNCCTRL_DAC2VSOFF_OFF (1 << XSYNCCTRL_DAC2VSOFF_SHIFT)
+#define XSYNCCTRL_DAC2VSOFF_ON 0
+
+
+/* XDISPCTRL field */
+#define XDISPCTRL_DAC1OUTSEL_SHIFT 0L
+#define XDISPCTRL_DAC1OUTSEL_MASK 1L
+#define XDISPCTRL_DAC1OUTSEL_DIS 0L
+#define XDISPCTRL_DAC1OUTSEL_EN 1L
+#define XDISPCTRL_DAC2OUTSEL_SHIFT 2L
+#define XDISPCTRL_DAC2OUTSEL_MASK (3L << XDISPCTRL_DAC2OUTSEL_SHIFT)
+#define XDISPCTRL_DAC2OUTSEL_DIS 0L
+#define XDISPCTRL_DAC2OUTSEL_CRTC1 (1L << XDISPCTRL_DAC2OUTSEL_SHIFT)
+#define XDISPCTRL_DAC2OUTSEL_CRTC2 (2L << XDISPCTRL_DAC2OUTSEL_SHIFT)
+#define XDISPCTRL_DAC2OUTSEL_TVE (3L << XDISPCTRL_DAC2OUTSEL_SHIFT)
+#define XDISPCTRL_PANOUTSEL_SHIFT 5L
+#define XDISPCTRL_PANOUTSEL_MASK (3L << XDISPCTRL_PANOUTSEL_SHIFT)
+#define XDISPCTRL_PANOUTSEL_DIS 0L
+#define XDISPCTRL_PANOUTSEL_CRTC1 (1L << XDISPCTRL_PANOUTSEL_SHIFT)
+#define XDISPCTRL_PANOUTSEL_CRTC2RGB (2L << XDISPCTRL_PANOUTSEL_SHIFT)
+#define XDISPCTRL_PANOUTSEL_CRTC2656 (3L << XDISPCTRL_PANOUTSEL_SHIFT)
+
+/* XPWRCTRL field*/
+#define XPWRCTRL_DAC2PDN_SHIFT 0
+#define XPWRCTRL_DAC2PDN_MASK (1 << XPWRCTRL_DAC2PDN_SHIFT)
+#define XPWRCTRL_VIDPLLPDN_SHIFT 1
+#define XPWRCTRL_VIDPLLPDN_MASK (1 << XPWRCTRL_VIDPLLPDN_SHIFT)
+#define XPWRCTRL_PANPDN_SHIFT 2
+#define XPWRCTRL_PANPDN_MASK (1 << XPWRCTRL_PANPDN_SHIFT)
+#define XPWRCTRL_RFIFOPDN_SHIFT 3
+#define XPWRCTRL_RFIFOPDN_MASK (1 << XPWRCTRL_RFIFOPDN_SHIFT)
+#define XPWRCTRL_CFIFOPDN_SHIFT 4
+#define XPWRCTRL_CFIFOPDN_MASK (1 << XPWRCTRL_CFIFOPDN_SHIFT)
+
+
+
+#define POS_HSYNC 0x00000004
+#define POS_VSYNC 0x00000008
+
+
+/* Set CRTC 2*/
+/* Uses the mode given by xfree86 to setup the registry */
+/* Does not write to the hard yet */
+void MGACRTC2Get(ScrnInfoPtr pScrn, xMODEINFO *pModeInfo)
+{
+
+
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr pReg = &pMga->ModeReg;
+
+ xMODEINFO tmpModeInfo;
+ CARD32 ulHTotal;
+ CARD32 ulHDispEnd;
+ CARD32 ulHBlkStr;
+ CARD32 ulHBlkEnd;
+ CARD32 ulHSyncStr;
+ CARD32 ulHSyncEnd;
+ CARD32 ulVTotal;
+ CARD32 ulVDispEnd;
+ CARD32 ulVBlkStr;
+ CARD32 ulVBlkEnd;
+ CARD32 ulVSyncStr;
+ CARD32 ulVSyncEnd;
+ CARD32 ulOffset;
+ CARD32 ulCtl2;
+ CARD32 ulDataCtl2;
+ CARD32 ulDispHeight = pModeInfo->ulDispHeight;
+
+#ifdef DEBUG
+ ErrorF("ENTER MGACRTC2Get\n");
+#endif
+
+ tmpModeInfo = *pModeInfo;
+
+
+ /* First compute the Values */
+
+ ulHTotal = tmpModeInfo.ulDispWidth +
+ tmpModeInfo.ulHFPorch +
+ tmpModeInfo.ulHBPorch +
+ tmpModeInfo.ulHSync;
+
+ ulHDispEnd = tmpModeInfo.ulDispWidth;
+ ulHBlkStr = ulHDispEnd;
+ ulHBlkEnd = ulHBlkStr + tmpModeInfo.ulHBPorch + tmpModeInfo.ulHFPorch + tmpModeInfo.ulHSync;
+ ulHSyncStr = ulHBlkStr + tmpModeInfo.ulHFPorch;
+ ulHSyncEnd = ulHSyncStr + tmpModeInfo.ulHSync;
+
+ ulVTotal = ulDispHeight +
+ tmpModeInfo.ulVFPorch +
+ tmpModeInfo.ulVBPorch +
+ tmpModeInfo.ulVSync;
+
+
+ ulVDispEnd = ulDispHeight;
+ ulVBlkStr = ulVDispEnd;
+ ulVBlkEnd = ulVBlkStr + tmpModeInfo.ulVBPorch + tmpModeInfo.ulVFPorch + tmpModeInfo.ulVSync;
+ ulVSyncStr = ulVBlkStr + tmpModeInfo.ulVFPorch;
+ ulVSyncEnd = ulVSyncStr + tmpModeInfo.ulVSync;
+
+ ulOffset = tmpModeInfo.ulFBPitch;
+
+
+
+ ulCtl2 = INREG(MGAREG_C2CTL);
+ ulDataCtl2 = INREG(MGAREG_C2DATACTL);
+
+ ulCtl2 &= 0xFF1FFFFF;
+ ulDataCtl2 &= 0xFFFFFF00;
+
+ switch (tmpModeInfo.ulBpp)
+ {
+ case 15: ulCtl2 |= 0x00200000;
+ ulOffset <<= 1;
+ break;
+ case 16: ulCtl2 |= 0x00400000;
+ ulOffset <<= 1;
+ break;
+ case 32: ulCtl2 |= 0x00800000;
+ ulOffset <<= 2;
+ break;
+ }
+
+
+ pReg->crtc2[ MGAREG2_C2CTL ] = ulCtl2;
+ pReg->crtc2[ MGAREG2_C2DATACTL ] = ulDataCtl2;
+
+ /* Horizontal Value*/
+ pReg->crtc2[MGAREG2_C2HPARAM] = (((ulHDispEnd-8) << 16) | (ulHTotal-8)) ;
+ pReg->crtc2[MGAREG2_C2HSYNC] = (((ulHSyncEnd-8) << 16) | (ulHSyncStr-8)) ;
+
+
+ /*Vertical Value*/
+ pReg->crtc2[MGAREG2_C2VPARAM] = (((ulVDispEnd-1) << 16) | (ulVTotal-1)) ;
+ pReg->crtc2[MGAREG2_C2VSYNC] = (((ulVSyncEnd-1) << 16) | (ulVSyncStr-1)) ;
+
+ /** Offset value*/
+
+ pReg->crtc2[MGAREG2_C2OFFSET] = ulOffset;
+
+#ifdef DEBUG
+ ErrorF("EXIT MGACRTC2Get\n");
+#endif
+
+}
+
+/* Set CRTC 2*/
+/* Writes to the hardware */
+void MGACRTC2Set(ScrnInfoPtr pScrn, xMODEINFO *pModeInfo)
+{
+
+
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr pReg = &pMga->ModeReg;
+
+#ifdef DEBUG
+ ErrorF("ENTER MGACRTC2Set\n");
+#endif
+
+
+ /* This writes to the registers manually */
+ OUTREG(MGAREG_C2CTL, pReg->crtc2[MGAREG2_C2CTL]);
+ OUTREG(MGAREG_C2DATACTL,pReg->crtc2[MGAREG2_C2DATACTL]);
+
+
+ /* Horizontal Value*/
+ OUTREG(MGAREG_C2HPARAM, pReg->crtc2[MGAREG2_C2HPARAM]);
+ OUTREG(MGAREG_C2HSYNC, pReg->crtc2[MGAREG2_C2HSYNC]);
+
+
+ /*Vertical Value*/
+ OUTREG(MGAREG_C2VPARAM, pReg->crtc2[MGAREG2_C2VPARAM]);
+ OUTREG(MGAREG_C2VSYNC, pReg->crtc2[MGAREG2_C2VSYNC]);
+
+ /** Offset value*/
+
+ OUTREG(MGAREG_C2OFFSET, pReg->crtc2[MGAREG2_C2VSYNC]);
+#ifdef DEBUG
+ ErrorF("EXIT MGACRTC2Set\n");
+#endif
+
+}
+
+
+/* Set CRTC2 on the right output */
+void MGAEnableSecondOutPut(ScrnInfoPtr pScrn, xMODEINFO *pModeInfo)
+{
+ CARD8 ucByte, ucXDispCtrl;
+ CARD32 ulC2CTL, ulStatusReg;
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr pReg;
+ pReg = &pMga->ModeReg;
+#ifdef DEBUG
+ ErrorF("ENTER MGAEnableSecondOutPut\n");
+#endif
+
+
+ /* Route Video PLL on second CRTC */
+ ulC2CTL = INREG( MGAREG_C2CTL);
+
+ /*--- Disable Pixel clock oscillations On Crtc1 */
+ OUTREG( MGAREG_C2CTL, ulC2CTL | C2CTL_PIXCLKDIS_MASK);
+ /*--- Have to wait minimum time (2 acces will be ok) */
+ ulStatusReg = INREG( MGAREG_Status);
+ ulStatusReg = INREG( MGAREG_Status);
+
+
+ ulC2CTL &= ~(C2CTL_PIXCLKSEL_MASK | C2CTL_PIXCLKSELH_MASK);
+
+ ulC2CTL |= C2CTL_PIXCLKSEL_VIDEOPLL;
+
+
+ OUTREG( MGAREG_C2CTL, ulC2CTL);
+ /*--- Enable Pixel clock oscillations on CRTC2*/
+ OUTREG( MGAREG_C2CTL, ulC2CTL & ~C2CTL_PIXCLKDIS_MASK);
+
+
+ /* We don't use MISC synch pol, must be 0*/
+ ucByte = inMGAdreg( MGAREG_MISC_READ);
+
+ OUTREG8(MGAREG_MISC_WRITE, (CARD8)(ucByte & ~(HSYNCPOL| VSYNCPOL) ));
+
+
+
+
+ /* Set Rset to 0.7 V*/
+ ucByte = inMGAdac(MGA1064_GEN_IO_CTL);
+ ucByte &= ~0x40;
+ pReg->DacRegs[MGA1064_GEN_IO_CTL] = ucByte;
+ outMGAdac (MGA1064_GEN_IO_CTL, ucByte);
+
+ ucByte = inMGAdac( MGA1064_GEN_IO_DATA);
+ ucByte &= ~0x40;
+ pReg->DacRegs[MGA1064_GEN_IO_DATA]= ucByte;
+ outMGAdac (MGA1064_GEN_IO_DATA, ucByte);
+
+ /* Since G550 can swap outputs at BIOS initialisation, we must check which
+ * DAC is 'logically' used as the secondary (don't assume its DAC2 anymore) */
+
+ ulC2CTL = INREG(MGAREG_C2CTL);
+ ucXDispCtrl = inMGAdac(MGA1064_DISP_CTL);
+
+ ucXDispCtrl &= ~XDISPCTRL_DAC2OUTSEL_MASK;
+ ucXDispCtrl |= XDISPCTRL_DAC2OUTSEL_CRTC2;
+
+ if (!pMga->SecondOutput) {
+ /* Route Crtc2 on Output1 */
+ ucXDispCtrl &= ~XDISPCTRL_DAC2OUTSEL_MASK;
+ ucXDispCtrl |= XDISPCTRL_DAC2OUTSEL_CRTC1;
+ ulC2CTL |= C2CTL_CRTCDACSEL_CRTC2;
+ }
+ else {
+ /* Route Crtc2 on Output2*/
+ ucXDispCtrl &= ~XDISPCTRL_DAC2OUTSEL_MASK;
+ ucXDispCtrl |= XDISPCTRL_DAC2OUTSEL_CRTC2;
+ ulC2CTL &= ~C2CTL_CRTCDACSEL_MASK;
+ }
+
+ /* Enable CRTC2*/
+ ulC2CTL |= C2_EN_M;
+
+ pReg->dac2[ MGA1064_DISP_CTL - 0x80] = ucXDispCtrl;
+
+
+
+ OUTREG( MGAREG_C2CTL, ulC2CTL);
+
+ /* Set DAC2 Synch polarity*/
+ ucByte = inMGAdac( MGA1064_SYNC_CTL);
+ ucByte &= ~(XSYNCCTRL_DAC2HSPOL_MASK | XSYNCCTRL_DAC2VSPOL_MASK);
+ if ( !(pModeInfo->flSignalMode & POS_HSYNC) )
+ {
+ ucByte |= XSYNCCTRL_DAC2HSPOL_NEG;
+ }
+ if ( !(pModeInfo->flSignalMode & POS_VSYNC) )
+ {
+ ucByte |= XSYNCCTRL_DAC2VSPOL_NEG;
+ }
+
+ /* Enable synch output*/
+ ucByte &= ~(XSYNCCTRL_DAC2HSOFF_MASK | XSYNCCTRL_DAC2VSOFF_MASK);
+ pReg->dac2[ MGA1064_SYNC_CTL - 0x80] = ucByte;
+
+ /* Powerup DAC2*/
+ ucByte = inMGAdac( MGA1064_PWR_CTL);
+ pReg->dac2[ MGA1064_PWR_CTL - 0x80] = /* 0x0b; */ (ucByte | XPWRCTRL_DAC2PDN_MASK);
+
+
+
+ /* Power up Fifo*/
+ ucByte = inMGAdac( MGA1064_PWR_CTL);
+ pReg->dac2[ MGA1064_PWR_CTL - 0x80] = 0x1b; /* (ucByte | XPWRCTRL_CFIFOPDN_MASK) */;
+
+
+#ifdef DEBUG
+ ErrorF("EXIT MGAEnableSecondOutPut\n");
+#endif
+}
+
+
+
+
+
+void MGACRTC2GetPitch (ScrnInfoPtr pScrn, xMODEINFO *pModeInfo)
+{
+ CARD32 ulOffset;
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr pReg;
+
+ pReg = &pMga->ModeReg;
+#ifdef DEBUG
+ ErrorF("ENTER MGACRTC2GetPitch\n");
+#endif
+
+
+ switch(pModeInfo->ulBpp)
+ {
+ case 15:
+ case 16:
+ ulOffset = pModeInfo->ulFBPitch * 2;
+ break;
+ case 32:
+ ulOffset = pModeInfo->ulFBPitch * 4;
+ break;
+ default: /* Muffle compiler */
+ ulOffset = pModeInfo->ulFBPitch;
+ break;
+ }
+
+ pReg->crtc2[MGAREG2_C2OFFSET] = ulOffset;
+
+#ifdef DEBUG
+ ErrorF("EXIT MGACRTC2GetPitch\n");
+#endif
+
+}
+
+void MGACRTC2SetPitch (ScrnInfoPtr pScrn, xMODEINFO *pModeInfo)
+{
+
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr pReg;
+ pReg = &pMga->ModeReg;
+
+#ifdef DEBUG
+ ErrorF("ENTER CRCT2SetPitch\n");
+#endif
+
+
+ OUTREG(MGAREG_C2OFFSET, pReg->crtc2[MGAREG2_C2OFFSET]);
+#ifdef DEBUG
+ ErrorF("EXIT CRCT2SetPitch\n");
+#endif
+
+}
+
+
+ /* Set Display Start*/
+ /* base in bytes*/
+void MGACRTC2GetDisplayStart (ScrnInfoPtr pScrn, xMODEINFO *pModeInfo, CARD32 base, CARD32 ulX, CARD32 ulY)
+{
+
+ CARD32 ulAddress;
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr pReg;
+ pReg = &pMga->ModeReg;
+
+#ifdef DEBUG
+ ErrorF("ENTER MGACRTC2GetDisplayStart\n");
+#endif
+
+
+ pReg = &pMga->ModeReg;
+
+ ulAddress = (pModeInfo->ulFBPitch * ulY + ulX);
+ switch(pModeInfo->ulBpp)
+ {
+ case 15:
+ case 16:
+ ulAddress <<= 1;
+ break;
+ case 32:
+ ulAddress <<= 2;
+ break;
+ }
+
+ pReg->crtc2[MGAREG2_C2STARTADD0] = ulAddress + base;
+#ifdef DEBUG
+ ErrorF("EXIT MGACRTC2GetDisplayStart\n");
+#endif
+
+}
+
+void MGACRTC2SetDisplayStart (ScrnInfoPtr pScrn, xMODEINFO *pModeInfo, CARD32 base, CARD32 ulX, CARD32 ulY)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr pReg;
+ pReg = &pMga->ModeReg;
+#ifdef DEBUG
+ ErrorF("ENTER MGACRTC2SetDisplayStart\n");
+#endif
+
+ OUTREG(MGAREG2_C2STARTADD0, pReg->crtc2[MGAREG2_C2STARTADD0]);
+#ifdef DEBUG
+ ErrorF("EXIT MGACRTC2GetDisplayStart\n");
+#endif
+
+}
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/mga_dri.c b/src/mga_dri.c
new file mode 100644
index 0000000..37d3a9a
--- /dev/null
+++ b/src/mga_dri.c
@@ -0,0 +1,1418 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_dri.c,v 1.28 2003/02/08 21:26:58 dawes Exp $ */
+
+/*
+ * Copyright 2000 VA Linux Systems Inc., Fremont, California.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ * Keith Whitwell <keith@tungstengraphics.com>
+ * Gareth Hughes <gareth@valinux.com>
+ */
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+#include "xf86Priv.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+#define PSZ 8
+#include "cfb.h"
+#undef PSZ
+#include "cfb16.h"
+#include "cfb32.h"
+
+#include "miline.h"
+
+
+
+
+#include "mga_bios.h"
+#include "mga_reg.h"
+#include "mga.h"
+#include "mga_macros.h"
+#include "mga_dri.h"
+#include "mga_sarea.h"
+
+#define _XF86DRI_SERVER_
+#include "GL/glxtokens.h"
+#include "sarea.h"
+
+
+
+
+
+#include "GL/glxtokens.h"
+
+#include "mga_bios.h"
+#include "mga_reg.h"
+#include "mga.h"
+#include "mga_macros.h"
+#include "mga_dri.h"
+
+#include "mga_sarea.h"
+
+static char MGAKernelDriverName[] = "mga";
+static char MGAClientDriverName[] = "mga";
+
+/* DRI buffer management
+ */
+extern void Mga8DRIInitBuffers( WindowPtr pWin, RegionPtr prgn,
+ CARD32 index );
+extern void Mga8DRIMoveBuffers( WindowPtr pParent, DDXPointRec ptOldOrg,
+ RegionPtr prgnSrc, CARD32 index );
+
+extern void Mga16DRIInitBuffers( WindowPtr pWin, RegionPtr prgn,
+ CARD32 index );
+extern void Mga16DRIMoveBuffers( WindowPtr pParent, DDXPointRec ptOldOrg,
+ RegionPtr prgnSrc, CARD32 index );
+
+extern void Mga24DRIInitBuffers( WindowPtr pWin, RegionPtr prgn,
+ CARD32 index );
+extern void Mga24DRIMoveBuffers( WindowPtr pParent, DDXPointRec ptOldOrg,
+ RegionPtr prgnSrc, CARD32 index );
+
+extern void Mga32DRIInitBuffers( WindowPtr pWin, RegionPtr prgn,
+ CARD32 index );
+extern void Mga32DRIMoveBuffers( WindowPtr pParent, DDXPointRec ptOldOrg,
+ RegionPtr prgnSrc, CARD32 index );
+
+
+/* Initialize the visual configs that are supported by the hardware.
+ * These are combined with the visual configs that the indirect
+ * rendering core supports, and the intersection is exported to the
+ * client.
+ */
+static Bool MGAInitVisualConfigs( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ int numConfigs = 0;
+ __GLXvisualConfig *pConfigs = 0;
+ MGAConfigPrivPtr pMGAConfigs = 0;
+ MGAConfigPrivPtr *pMGAConfigPtrs = 0;
+ int i, db, depth, stencil, accum;
+
+ switch ( pScrn->bitsPerPixel ) {
+ case 8:
+ case 24:
+ break;
+
+ case 16:
+ numConfigs = 8;
+
+ pConfigs = (__GLXvisualConfig*)xcalloc( sizeof(__GLXvisualConfig),
+ numConfigs );
+ if ( !pConfigs ) {
+ return FALSE;
+ }
+
+ pMGAConfigs = (MGAConfigPrivPtr)xcalloc( sizeof(MGAConfigPrivRec),
+ numConfigs );
+ if ( !pMGAConfigs ) {
+ xfree( pConfigs );
+ return FALSE;
+ }
+
+ pMGAConfigPtrs = (MGAConfigPrivPtr*)xcalloc( sizeof(MGAConfigPrivPtr),
+ numConfigs );
+ if ( !pMGAConfigPtrs ) {
+ xfree( pConfigs );
+ xfree( pMGAConfigs );
+ return FALSE;
+ }
+
+ for ( i = 0 ; i < numConfigs ; i++ ) {
+ pMGAConfigPtrs[i] = &pMGAConfigs[i];
+ }
+
+ i = 0;
+ depth = 1;
+ for ( accum = 0 ; accum <= 1 ; accum++ ) {
+ for ( stencil = 0 ; stencil <= 1 ; stencil++ ) {
+ for ( db = 1 ; db >= 0 ; db-- ) {
+ pConfigs[i].vid = -1;
+ pConfigs[i].class = -1;
+ pConfigs[i].rgba = TRUE;
+ pConfigs[i].redSize = 5;
+ pConfigs[i].greenSize = 6;
+ pConfigs[i].blueSize = 5;
+ pConfigs[i].alphaSize = 0;
+ pConfigs[i].redMask = 0x0000F800;
+ pConfigs[i].greenMask = 0x000007E0;
+ pConfigs[i].blueMask = 0x0000001F;
+ pConfigs[i].alphaMask = 0;
+ if ( accum ) {
+ pConfigs[i].accumRedSize = 16;
+ pConfigs[i].accumGreenSize = 16;
+ pConfigs[i].accumBlueSize = 16;
+ pConfigs[i].accumAlphaSize = 0;
+ } else {
+ pConfigs[i].accumRedSize = 0;
+ pConfigs[i].accumGreenSize = 0;
+ pConfigs[i].accumBlueSize = 0;
+ pConfigs[i].accumAlphaSize = 0;
+ }
+ if ( db ) {
+ pConfigs[i].doubleBuffer = TRUE;
+ } else {
+ pConfigs[i].doubleBuffer = FALSE;
+ }
+ pConfigs[i].stereo = FALSE;
+ pConfigs[i].bufferSize = 16;
+ if ( depth ) {
+ pConfigs[i].depthSize = 16;
+ } else {
+ pConfigs[i].depthSize = 0;
+ }
+ if ( stencil ) {
+ pConfigs[i].stencilSize = 8;
+ } else {
+ pConfigs[i].stencilSize = 0;
+ }
+ pConfigs[i].auxBuffers = 0;
+ pConfigs[i].level = 0;
+ if ( accum || stencil ) {
+ pConfigs[i].visualRating = GLX_SLOW_VISUAL_EXT;
+ } else {
+ pConfigs[i].visualRating = GLX_NONE_EXT;
+ }
+ pConfigs[i].transparentPixel = 0;
+ pConfigs[i].transparentRed = 0;
+ pConfigs[i].transparentGreen = 0;
+ pConfigs[i].transparentBlue = 0;
+ pConfigs[i].transparentAlpha = 0;
+ pConfigs[i].transparentIndex = 0;
+ i++;
+ }
+ }
+ }
+ if ( i != numConfigs ) {
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "[drm] Incorrect initialization of visuals\n" );
+ return FALSE;
+ }
+ break;
+
+ case 32:
+ numConfigs = 8;
+
+ pConfigs = (__GLXvisualConfig*)xcalloc( sizeof(__GLXvisualConfig),
+ numConfigs );
+ if ( !pConfigs ) {
+ return FALSE;
+ }
+
+ pMGAConfigs = (MGAConfigPrivPtr)xcalloc( sizeof(MGAConfigPrivRec),
+ numConfigs );
+ if ( !pMGAConfigs ) {
+ xfree( pConfigs );
+ return FALSE;
+ }
+
+ pMGAConfigPtrs = (MGAConfigPrivPtr*)xcalloc( sizeof(MGAConfigPrivPtr),
+ numConfigs );
+ if ( !pMGAConfigPtrs ) {
+ xfree( pConfigs );
+ xfree( pMGAConfigs );
+ return FALSE;
+ }
+
+ for ( i = 0 ; i < numConfigs ; i++ ) {
+ pMGAConfigPtrs[i] = &pMGAConfigs[i];
+ }
+
+ i = 0;
+ for ( accum = 0 ; accum <= 1 ; accum++ ) {
+ for ( depth = 0 ; depth <= 1 ; depth++ ) { /* and stencil */
+ for ( db = 1 ; db >= 0 ; db-- ) {
+ pConfigs[i].vid = -1;
+ pConfigs[i].class = -1;
+ pConfigs[i].rgba = TRUE;
+ pConfigs[i].redSize = 8;
+ pConfigs[i].greenSize = 8;
+ pConfigs[i].blueSize = 8;
+ pConfigs[i].alphaSize = 0;
+ pConfigs[i].redMask = 0x00FF0000;
+ pConfigs[i].greenMask = 0x0000FF00;
+ pConfigs[i].blueMask = 0x000000FF;
+ pConfigs[i].alphaMask = 0x0;
+ if ( accum ) {
+ pConfigs[i].accumRedSize = 16;
+ pConfigs[i].accumGreenSize = 16;
+ pConfigs[i].accumBlueSize = 16;
+ pConfigs[i].accumAlphaSize = 0;
+ } else {
+ pConfigs[i].accumRedSize = 0;
+ pConfigs[i].accumGreenSize = 0;
+ pConfigs[i].accumBlueSize = 0;
+ pConfigs[i].accumAlphaSize = 0;
+ }
+ if ( db ) {
+ pConfigs[i].doubleBuffer = TRUE;
+ } else {
+ pConfigs[i].doubleBuffer = FALSE;
+ }
+ pConfigs[i].stereo = FALSE;
+ pConfigs[i].bufferSize = 24;
+ if ( depth ) {
+ pConfigs[i].depthSize = 24;
+ pConfigs[i].stencilSize = 8;
+ }
+ else {
+ pConfigs[i].depthSize = 0;
+ pConfigs[i].stencilSize = 0;
+ }
+ pConfigs[i].auxBuffers = 0;
+ pConfigs[i].level = 0;
+ if ( accum ) {
+ pConfigs[i].visualRating = GLX_SLOW_VISUAL_EXT;
+ } else {
+ pConfigs[i].visualRating = GLX_NONE_EXT;
+ }
+ pConfigs[i].transparentPixel = 0;
+ pConfigs[i].transparentRed = 0;
+ pConfigs[i].transparentGreen = 0;
+ pConfigs[i].transparentBlue = 0;
+ pConfigs[i].transparentAlpha = 0;
+ pConfigs[i].transparentIndex = 0;
+ i++;
+ }
+ }
+ }
+ if ( i != numConfigs ) {
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "[drm] Incorrect initialization of visuals\n" );
+ return FALSE;
+ }
+ break;
+
+ default:
+ /* Unexpected bits/pixels */
+ break;
+ }
+
+ pMga->numVisualConfigs = numConfigs;
+ pMga->pVisualConfigs = pConfigs;
+ pMga->pVisualConfigsPriv = pMGAConfigs;
+
+ GlxSetVisualConfigs( numConfigs, pConfigs, (void **)pMGAConfigPtrs );
+
+ return TRUE;
+}
+
+static Bool MGACreateContext( ScreenPtr pScreen, VisualPtr visual,
+ drmContext hwContext, void *pVisualConfigPriv,
+ DRIContextType contextStore )
+{
+ /* Nothing yet */
+ return TRUE;
+}
+
+static void MGADestroyContext( ScreenPtr pScreen, drmContext hwContext,
+ DRIContextType contextStore )
+{
+ /* Nothing yet */
+}
+
+
+/* Quiescence, locking
+ */
+#define MGA_TIMEOUT 2048
+
+static void MGAWaitForIdleDMA( ScrnInfoPtr pScrn )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ drmMGALock lock;
+ int ret;
+ int i = 0;
+
+ memset( &lock, 0, sizeof(drmMGALock) );
+
+ for (;;) {
+ do {
+ /* first ask for quiescent and flush */
+ lock.flags = DRM_MGA_LOCK_QUIESCENT | DRM_MGA_LOCK_FLUSH;
+ do {
+ ret = drmCommandWrite( pMga->drmFD, DRM_MGA_FLUSH,
+ &lock, sizeof( drmMGALock ) );
+ } while ( ret == -EBUSY && i++ < DRM_MGA_IDLE_RETRY );
+
+ /* if it's still busy just try quiescent */
+ if ( ret == -EBUSY ) {
+ lock.flags = DRM_MGA_LOCK_QUIESCENT;
+ do {
+ ret = drmCommandWrite( pMga->drmFD, DRM_MGA_FLUSH,
+ &lock, sizeof( drmMGALock ) );
+ } while ( ret == -EBUSY && i++ < DRM_MGA_IDLE_RETRY );
+ }
+ } while ( ( ret == -EBUSY ) && ( i++ < MGA_TIMEOUT ) );
+
+ if ( ret == 0 )
+ return;
+
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "[dri] Idle timed out, resetting engine...\n" );
+
+ drmCommandNone( pMga->drmFD, DRM_MGA_RESET );
+ }
+}
+
+
+void MGAGetQuiescence( ScrnInfoPtr pScrn )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ DRILock( screenInfo.screens[pScrn->scrnIndex], 0 );
+ pMga->haveQuiescense = 1;
+
+ if ( pMga->directRenderingEnabled ) {
+ MGAFBLayout *pLayout = &pMga->CurrentLayout;
+
+ MGAWaitForIdleDMA( pScrn );
+
+ WAITFIFO( 11 );
+ OUTREG( MGAREG_MACCESS, pMga->MAccess );
+ OUTREG( MGAREG_PITCH, pLayout->displayWidth );
+
+ pMga->PlaneMask = ~0;
+ OUTREG( MGAREG_PLNWT, pMga->PlaneMask );
+
+ pMga->BgColor = 0;
+ pMga->FgColor = 0;
+ OUTREG( MGAREG_BCOL, pMga->BgColor );
+ OUTREG( MGAREG_FCOL, pMga->FgColor );
+ OUTREG( MGAREG_SRCORG, pMga->realSrcOrg );
+
+ pMga->SrcOrg = 0;
+ OUTREG( MGAREG_DSTORG, pMga->DstOrg );
+ OUTREG( MGAREG_OPMODE, MGAOPM_DMA_BLIT );
+ OUTREG( MGAREG_CXBNDRY, 0xFFFF0000 ); /* (maxX << 16) | minX */
+ OUTREG( MGAREG_YTOP, 0x00000000 ); /* minPixelPointer */
+ OUTREG( MGAREG_YBOT, 0x007FFFFF ); /* maxPixelPointer */
+
+ pMga->AccelFlags &= ~CLIPPER_ON;
+ }
+}
+
+void MGAGetQuiescenceShared( ScrnInfoPtr pScrn )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAEntPtr pMGAEnt = pMga->entityPrivate;
+ MGAPtr pMGA2 = MGAPTR(pMGAEnt->pScrn_2);
+
+ DRILock( screenInfo.screens[pMGAEnt->pScrn_1->scrnIndex], 0 );
+
+ pMga = MGAPTR(pMGAEnt->pScrn_1);
+ pMga->haveQuiescense = 1;
+ pMGA2->haveQuiescense = 1;
+
+ if ( pMGAEnt->directRenderingEnabled ) {
+ MGAWaitForIdleDMA( pMGAEnt->pScrn_1 );
+ pMga->RestoreAccelState( pScrn );
+ xf86SetLastScrnFlag( pScrn->entityList[0], pScrn->scrnIndex );
+ }
+}
+
+static void MGASwapContext( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ /* Arrange for dma_quiescence and xaa sync to be called as
+ * appropriate.
+ */
+ pMga->haveQuiescense = 0;
+ pMga->AccelInfoRec->NeedToSync = TRUE;
+}
+
+static void MGASwapContextShared( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAEntPtr pMGAEnt = pMga->entityPrivate;
+ MGAPtr pMGA2 = MGAPTR(pMGAEnt->pScrn_2);
+
+ pMga = MGAPTR(pMGAEnt->pScrn_1);
+
+ pMga->haveQuiescense = 0;
+ pMga->AccelInfoRec->NeedToSync = TRUE;
+
+ pMGA2->haveQuiescense = 0;
+ pMGA2->AccelInfoRec->NeedToSync = TRUE;
+}
+
+/* This is really only called from validate/postvalidate as we
+ * override the dri lock/unlock. Want to remove validate/postvalidate
+ * processing, but need to remove all client-side use of drawable lock
+ * first (otherwise there is noone recover when a client dies holding
+ * the drawable lock).
+ *
+ * What does this mean?
+ *
+ * - The above code gets executed every time a
+ * window changes shape or the focus changes, which isn't really
+ * optimal.
+ * - The X server therefore believes it needs to do an XAA sync
+ * *and* a dma quiescense ioctl each time that happens.
+ *
+ * We don't wrap wakeuphandler any longer, so at least we can say that
+ * this doesn't happen *every time the mouse moves*...
+ */
+static void
+MGADRISwapContext( ScreenPtr pScreen, DRISyncType syncType,
+ DRIContextType oldContextType, void *oldContext,
+ DRIContextType newContextType, void *newContext )
+{
+#if 0
+ if ( syncType == DRI_3D_SYNC &&
+ oldContextType == DRI_2D_CONTEXT &&
+ newContextType == DRI_2D_CONTEXT )
+ {
+ MGASwapContext( pScreen );
+ }
+#endif
+}
+
+static void
+MGADRISwapContextShared( ScreenPtr pScreen, DRISyncType syncType,
+ DRIContextType oldContextType, void *oldContext,
+ DRIContextType newContextType, void *newContext )
+{
+#if 0
+ if ( syncType == DRI_3D_SYNC &&
+ oldContextType == DRI_2D_CONTEXT &&
+ newContextType == DRI_2D_CONTEXT )
+ {
+ MGASwapContextShared( pScreen );
+ }
+#endif
+}
+
+
+static void MGAWakeupHandler( int screenNum, pointer wakeupData,
+ unsigned long result, pointer pReadmask )
+{
+ ScreenPtr pScreen = screenInfo.screens[screenNum];
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+
+ if ( xf86IsEntityShared( pScrn->entityList[0] ) ) {
+ MGASwapContextShared( pScreen );
+ } else {
+ MGASwapContext( pScreen );
+ }
+}
+
+static void MGABlockHandler( int screenNum, pointer blockData,
+ pointer pTimeout, pointer pReadmask )
+
+{
+ ScreenPtr pScreen = screenInfo.screens[screenNum];
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAEntPtr pMGAEnt;
+
+ if ( pMga->haveQuiescense ) {
+ if ( xf86IsEntityShared( pScrn->entityList[0] ) ) {
+ /* Restore to first screen */
+ pMga->RestoreAccelState( pScrn );
+ xf86SetLastScrnFlag( pScrn->entityList[0], pScrn->scrnIndex );
+ pMGAEnt = pMga->entityPrivate;
+
+ if ( pMGAEnt->directRenderingEnabled ) {
+ DRIUnlock( screenInfo.screens[pMGAEnt->pScrn_1->scrnIndex] );
+ }
+ } else {
+ if ( pMga->directRenderingEnabled ) {
+ DRIUnlock( pScreen );
+ }
+ }
+ pMga->haveQuiescense = 0;
+ }
+}
+
+void MGASelectBuffer( ScrnInfoPtr pScrn, int which )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIPtr pMGADRI = (MGADRIPtr)pMga->pDRIInfo->devPrivate;
+
+ switch ( which ) {
+ case MGA_BACK:
+ OUTREG( MGAREG_DSTORG, pMGADRI->backOffset );
+ OUTREG( MGAREG_SRCORG, pMGADRI->backOffset );
+ break;
+ case MGA_DEPTH:
+ OUTREG( MGAREG_DSTORG, pMGADRI->depthOffset );
+ OUTREG( MGAREG_SRCORG, pMGADRI->depthOffset );
+ break;
+ default:
+ case MGA_FRONT:
+ OUTREG( MGAREG_DSTORG, pMGADRI->frontOffset );
+ OUTREG( MGAREG_SRCORG, pMGADRI->frontOffset );
+ break;
+ }
+}
+
+
+static unsigned int mylog2( unsigned int n )
+{
+ unsigned int log2 = 1;
+ while ( n > 1 ) n >>= 1, log2++;
+ return log2;
+}
+
+static Bool MGADRIAgpInit(ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+ unsigned long mode;
+ unsigned int vendor, device;
+ int ret, count, i;
+
+ if(pMga->agpSize < 12)pMga->agpSize = 12;
+ if(pMga->agpSize > 64)pMga->agpSize = 64; /* cap */
+
+ /* FIXME: Make these configurable...
+ */
+ pMGADRIServer->agp.size = pMga->agpSize * 1024 * 1024;
+
+ pMGADRIServer->warp.offset = 0;
+ pMGADRIServer->warp.size = MGA_WARP_UCODE_SIZE;
+
+ pMGADRIServer->primary.offset = (pMGADRIServer->warp.offset +
+ pMGADRIServer->warp.size);
+ pMGADRIServer->primary.size = 1024 * 1024;
+
+ pMGADRIServer->buffers.offset = (pMGADRIServer->primary.offset +
+ pMGADRIServer->primary.size);
+ pMGADRIServer->buffers.size = MGA_NUM_BUFFERS * MGA_BUFFER_SIZE;
+
+
+ pMGADRIServer->agpTextures.offset = (pMGADRIServer->buffers.offset +
+ pMGADRIServer->buffers.size);
+
+ pMGADRIServer->agpTextures.size = pMGADRIServer->agp.size -
+ pMGADRIServer->agpTextures.offset;
+
+ if ( drmAgpAcquire( pMga->drmFD ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] AGP not available\n" );
+ return FALSE;
+ }
+
+ mode = drmAgpGetMode( pMga->drmFD ); /* Default mode */
+ vendor = drmAgpVendorId( pMga->drmFD );
+ device = drmAgpDeviceId( pMga->drmFD );
+
+ mode &= ~MGA_AGP_MODE_MASK;
+ switch ( pMga->agpMode ) {
+ case 4:
+ mode |= MGA_AGP_4X_MODE;
+ case 2:
+ mode |= MGA_AGP_2X_MODE;
+ case 1:
+ default:
+ mode |= MGA_AGP_1X_MODE;
+ }
+
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] Mode 0x%08lx [AGP 0x%04x/0x%04x; Card 0x%04x/0x%04x]\n",
+ mode, vendor, device,
+ pMga->PciInfo->vendor,
+ pMga->PciInfo->chipType );
+
+ if ( drmAgpEnable( pMga->drmFD, mode ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] AGP not enabled\n" );
+ drmAgpRelease( pMga->drmFD );
+ return FALSE;
+ }
+
+ if ( pMga->Chipset == PCI_CHIP_MGAG200 ) {
+ switch ( pMga->agpMode ) {
+ case 2:
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[drm] Enabling AGP 2x PLL encoding\n" );
+ OUTREG( MGAREG_AGP_PLL, MGA_AGP2XPLL_ENABLE );
+ break;
+
+ case 1:
+ default:
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[drm] Disabling AGP 2x PLL encoding\n" );
+ OUTREG( MGAREG_AGP_PLL, MGA_AGP2XPLL_DISABLE );
+ pMga->agpMode = 1;
+ break;
+ }
+ }
+
+ ret = drmAgpAlloc( pMga->drmFD, pMGADRIServer->agp.size,
+ 0, NULL, &pMGADRIServer->agp.handle );
+ if ( ret < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] Out of memory (%d)\n", ret );
+ drmAgpRelease( pMga->drmFD );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] %d kB allocated with handle 0x%08x\n",
+ pMGADRIServer->agp.size/1024, pMGADRIServer->agp.handle );
+
+ if ( drmAgpBind( pMga->drmFD, pMGADRIServer->agp.handle, 0 ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] Could not bind memory\n" );
+ drmAgpFree( pMga->drmFD, pMGADRIServer->agp.handle );
+ drmAgpRelease( pMga->drmFD );
+ return FALSE;
+ }
+
+ /* WARP microcode space
+ */
+ if ( drmAddMap( pMga->drmFD,
+ pMGADRIServer->warp.offset,
+ pMGADRIServer->warp.size,
+ DRM_AGP, DRM_READ_ONLY,
+ &pMGADRIServer->warp.handle ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not add WARP microcode mapping\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] WARP microcode handle = 0x%08lx\n",
+ pMGADRIServer->warp.handle );
+
+ if ( drmMap( pMga->drmFD,
+ pMGADRIServer->warp.handle,
+ pMGADRIServer->warp.size,
+ &pMGADRIServer->warp.map ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not map WARP microcode\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] WARP microcode mapped at 0x%08lx\n",
+ (unsigned long)pMGADRIServer->warp.map );
+
+ /* Primary DMA space
+ */
+ if ( drmAddMap( pMga->drmFD,
+ pMGADRIServer->primary.offset,
+ pMGADRIServer->primary.size,
+ DRM_AGP, DRM_READ_ONLY,
+ &pMGADRIServer->primary.handle ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not add primary DMA mapping\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] Primary DMA handle = 0x%08lx\n",
+ pMGADRIServer->primary.handle );
+
+ if ( drmMap( pMga->drmFD,
+ pMGADRIServer->primary.handle,
+ pMGADRIServer->primary.size,
+ &pMGADRIServer->primary.map ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not map primary DMA\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] Primary DMA mapped at 0x%08lx\n",
+ (unsigned long)pMGADRIServer->primary.map );
+
+ /* DMA buffers
+ */
+ if ( drmAddMap( pMga->drmFD,
+ pMGADRIServer->buffers.offset,
+ pMGADRIServer->buffers.size,
+ DRM_AGP, 0,
+ &pMGADRIServer->buffers.handle ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not add DMA buffers mapping\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] DMA buffers handle = 0x%08lx\n",
+ pMGADRIServer->buffers.handle );
+
+ if ( drmMap( pMga->drmFD,
+ pMGADRIServer->buffers.handle,
+ pMGADRIServer->buffers.size,
+ &pMGADRIServer->buffers.map ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not map DMA buffers\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] DMA buffers mapped at 0x%08lx\n",
+ (unsigned long)pMGADRIServer->buffers.map );
+
+ count = drmAddBufs( pMga->drmFD,
+ MGA_NUM_BUFFERS, MGA_BUFFER_SIZE,
+ DRM_AGP_BUFFER, pMGADRIServer->buffers.offset );
+ if ( count <= 0 ) {
+ xf86DrvMsg( pScrn->scrnIndex, X_INFO,
+ "[drm] failure adding %d %d byte DMA buffers\n",
+ MGA_NUM_BUFFERS, MGA_BUFFER_SIZE );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[drm] Added %d %d byte DMA buffers\n",
+ count, MGA_BUFFER_SIZE );
+
+ i = mylog2(pMGADRIServer->agpTextures.size / MGA_NR_TEX_REGIONS);
+ if(i < MGA_LOG_MIN_TEX_REGION_SIZE)
+ i = MGA_LOG_MIN_TEX_REGION_SIZE;
+ pMGADRIServer->agpTextures.size = (pMGADRIServer->agpTextures.size >> i) << i;
+
+ if ( drmAddMap( pMga->drmFD,
+ pMGADRIServer->agpTextures.offset,
+ pMGADRIServer->agpTextures.size,
+ DRM_AGP, 0,
+ &pMGADRIServer->agpTextures.handle ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not add agpTexture mapping\n" );
+ return FALSE;
+ }
+/* should i map it ? */
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] agpTexture handle = 0x%08lx\n",
+ pMGADRIServer->agpTextures.handle );
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] agpTexture size: %d kb\n", pMGADRIServer->agpTextures.size/1024 );
+
+ return TRUE;
+}
+
+static Bool MGADRIMapInit( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+
+ pMGADRIServer->registers.size = MGAIOMAPSIZE;
+
+ if ( drmAddMap( pMga->drmFD,
+ (drmHandle)pMga->IOAddress,
+ pMGADRIServer->registers.size,
+ DRM_REGISTERS, DRM_READ_ONLY,
+ &pMGADRIServer->registers.handle ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[drm] Could not add MMIO registers mapping\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[drm] Registers handle = 0x%08lx\n",
+ pMGADRIServer->registers.handle );
+
+ pMGADRIServer->status.size = SAREA_MAX;
+
+ if ( drmAddMap( pMga->drmFD, 0, pMGADRIServer->status.size,
+ DRM_SHM, DRM_READ_ONLY | DRM_LOCKED | DRM_KERNEL,
+ &pMGADRIServer->status.handle ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[drm] Could not add status page mapping\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[drm] Status handle = 0x%08lx\n",
+ pMGADRIServer->status.handle );
+
+ if ( drmMap( pMga->drmFD,
+ pMGADRIServer->status.handle,
+ pMGADRIServer->status.size,
+ &pMGADRIServer->status.map ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not map status page\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] Status page mapped at 0x%08lx\n",
+ (unsigned long)pMGADRIServer->status.map );
+
+ return TRUE;
+}
+
+static Bool MGADRIKernelInit( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+ drmMGAInit init;
+ int ret;
+
+ memset( &init, 0, sizeof(drmMGAInit) );
+
+ init.func = MGA_INIT_DMA;
+ init.sarea_priv_offset = sizeof(XF86DRISAREARec);
+
+ switch ( pMga->Chipset ) {
+ case PCI_CHIP_MGAG550:
+ case PCI_CHIP_MGAG400:
+ init.chipset = MGA_CARD_TYPE_G400;
+ break;
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ init.chipset = MGA_CARD_TYPE_G200;
+ break;
+ default:
+ return FALSE;
+ }
+ init.sgram = !pMga->HasSDRAM;
+
+ init.maccess = pMga->MAccess;
+
+ init.fb_cpp = pScrn->bitsPerPixel / 8;
+ init.front_offset = pMGADRIServer->frontOffset;
+ init.front_pitch = pMGADRIServer->frontPitch / init.fb_cpp;
+ init.back_offset = pMGADRIServer->backOffset;
+ init.back_pitch = pMGADRIServer->backPitch / init.fb_cpp;
+
+ init.depth_cpp = pScrn->bitsPerPixel / 8;
+ init.depth_offset = pMGADRIServer->depthOffset;
+ init.depth_pitch = pMGADRIServer->depthPitch / init.depth_cpp;
+
+ init.texture_offset[0] = pMGADRIServer->textureOffset;
+ init.texture_size[0] = pMGADRIServer->textureSize;
+
+ init.fb_offset = pMGADRIServer->fb.handle;
+ init.mmio_offset = pMGADRIServer->registers.handle;
+ init.status_offset = pMGADRIServer->status.handle;
+
+ init.warp_offset = pMGADRIServer->warp.handle;
+ init.primary_offset = pMGADRIServer->primary.handle;
+ init.buffers_offset = pMGADRIServer->buffers.handle;
+
+ init.texture_offset[1] = pMGADRIServer->agpTextures.handle;
+ init.texture_size[1] = pMGADRIServer->agpTextures.size;
+
+ ret = drmCommandWrite( pMga->drmFD, DRM_MGA_INIT, &init, sizeof(drmMGAInit));
+ if ( ret < 0 ) {
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "[drm] Failed to initialize DMA! (%d)\n", ret );
+ return FALSE;
+ }
+
+#if 0
+ /* FIXME: This is just here to clean up after the engine reset test
+ * in the kernel module. Please remove it later...
+ */
+ pMga->GetQuiescence( pScrn );
+#endif
+
+ return TRUE;
+}
+
+static void MGADRIIrqInit(MGAPtr pMga, ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+
+ /* version = drmGetVersion(pMga->drmFD);
+ if ( version ) {
+ if ( version->version_major != 3 ||
+ version->version_minor < 0 ) {*/
+ if (!pMga->irq) {
+ pMga->irq = drmGetInterruptFromBusID(
+ pMga->drmFD,
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->busnum,
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->devnum,
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->funcnum);
+
+ if((drmCtlInstHandler(pMga->drmFD, pMga->irq)) != 0) {
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "[drm] failure adding irq handler, "
+ "there is a device already using that irq\n"
+ "[drm] falling back to irq-free operation\n");
+ pMga->irq = 0;
+ } else {
+ pMga->reg_ien = INREG( MGAREG_IEN );
+ }
+ }
+
+ if (pMga->irq)
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "[drm] dma control initialized, using IRQ %d\n",
+ pMga->irq);
+}
+
+static Bool MGADRIBuffersInit( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+
+
+ pMGADRIServer->drmBuffers = drmMapBufs( pMga->drmFD );
+ if ( !pMGADRIServer->drmBuffers ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[drm] Failed to map DMA buffers list\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[drm] Mapped %d DMA buffers\n",
+ pMGADRIServer->drmBuffers->count );
+
+ return TRUE;
+}
+
+
+Bool MGADRIScreenInit( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ DRIInfoPtr pDRIInfo;
+ MGADRIPtr pMGADRI;
+ MGADRIServerPrivatePtr pMGADRIServer;
+
+ switch(pMga->Chipset) {
+ case PCI_CHIP_MGAG550:
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG200:
+#if 0
+ case PCI_CHIP_MGAG200_PCI:
+#endif
+ break;
+ default:
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "[drm] Direct rendering only supported with G200/G400/G550 AGP\n");
+ return FALSE;
+ }
+
+ /* Check that the GLX, DRI, and DRM modules have been loaded by testing
+ * for canonical symbols in each module.
+ */
+ if ( !xf86LoaderCheckSymbol( "GlxSetVisualConfigs" ) ) return FALSE;
+ if ( !xf86LoaderCheckSymbol( "DRIScreenInit" ) ) return FALSE;
+ if ( !xf86LoaderCheckSymbol( "drmAvailable" ) ) return FALSE;
+ if ( !xf86LoaderCheckSymbol( "DRIQueryVersion" ) ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[dri] MGADRIScreenInit failed (libdri.a too old)\n" );
+ return FALSE;
+ }
+
+ /* Check the DRI version */
+ {
+ int major, minor, patch;
+ DRIQueryVersion( &major, &minor, &patch );
+ if ( major != 4 || minor < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[dri] MGADRIScreenInit failed because of a version mismatch.\n"
+ "[dri] libDRI version = %d.%d.%d but version 4.0.x is needed.\n"
+ "[dri] Disabling the DRI.\n",
+ major, minor, patch );
+ return FALSE;
+ }
+ }
+
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[drm] bpp: %d depth: %d\n",
+ pScrn->bitsPerPixel, pScrn->depth );
+
+ if ( (pScrn->bitsPerPixel / 8) != 2 &&
+ (pScrn->bitsPerPixel / 8) != 4 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[dri] Direct rendering only supported in 16 and 32 bpp modes\n" );
+ return FALSE;
+ }
+
+ pDRIInfo = DRICreateInfoRec();
+ if ( !pDRIInfo ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[dri] DRICreateInfoRec() failed\n" );
+ return FALSE;
+ }
+ pMga->pDRIInfo = pDRIInfo;
+
+ pDRIInfo->drmDriverName = MGAKernelDriverName;
+ pDRIInfo->clientDriverName = MGAClientDriverName;
+ pDRIInfo->busIdString = xalloc(64);
+ sprintf( pDRIInfo->busIdString, "PCI:%d:%d:%d",
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->busnum,
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->devnum,
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->funcnum );
+ pDRIInfo->ddxDriverMajorVersion = MGA_MAJOR_VERSION;
+ pDRIInfo->ddxDriverMinorVersion = MGA_MINOR_VERSION;
+ pDRIInfo->ddxDriverPatchVersion = MGA_PATCHLEVEL;
+ pDRIInfo->frameBufferPhysicalAddress = pMga->FbAddress;
+ pDRIInfo->frameBufferSize = pMga->FbMapSize;
+ pDRIInfo->frameBufferStride = pScrn->displayWidth*(pScrn->bitsPerPixel/8);
+ pDRIInfo->ddxDrawableTableEntry = MGA_MAX_DRAWABLES;
+
+ pDRIInfo->wrap.BlockHandler = MGABlockHandler;
+ pDRIInfo->wrap.WakeupHandler = MGAWakeupHandler;
+ pDRIInfo->wrap.ValidateTree = NULL;
+ pDRIInfo->wrap.PostValidateTree = NULL;
+
+ pDRIInfo->createDummyCtx = TRUE;
+ pDRIInfo->createDummyCtxPriv = FALSE;
+
+ if ( SAREA_MAX_DRAWABLES < MGA_MAX_DRAWABLES ) {
+ pDRIInfo->maxDrawableTableEntry = SAREA_MAX_DRAWABLES;
+ } else {
+ pDRIInfo->maxDrawableTableEntry = MGA_MAX_DRAWABLES;
+ }
+
+ /* For now the mapping works by using a fixed size defined
+ * in the SAREA header.
+ */
+ if ( sizeof(XF86DRISAREARec) + sizeof(MGASAREAPrivRec) > SAREA_MAX ) {
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "[drm] Data does not fit in SAREA\n" );
+ return FALSE;
+ }
+
+ xf86DrvMsg( pScrn->scrnIndex, X_INFO,
+ "[drm] Sarea %d+%d: %d\n",
+ sizeof(XF86DRISAREARec), sizeof(MGASAREAPrivRec),
+ sizeof(XF86DRISAREARec) + sizeof(MGASAREAPrivRec) );
+
+ pDRIInfo->SAREASize = SAREA_MAX;
+
+ pMGADRI = (MGADRIPtr)xcalloc( sizeof(MGADRIRec), 1 );
+ if ( !pMGADRI ) {
+ DRIDestroyInfoRec( pMga->pDRIInfo );
+ pMga->pDRIInfo = 0;
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "[drm] Failed to allocate memory for private record\n" );
+ return FALSE;
+ }
+
+ pMGADRIServer = (MGADRIServerPrivatePtr)
+ xcalloc( sizeof(MGADRIServerPrivateRec), 1 );
+ if ( !pMGADRIServer ) {
+ xfree( pMGADRI );
+ DRIDestroyInfoRec( pMga->pDRIInfo );
+ pMga->pDRIInfo = 0;
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "[drm] Failed to allocate memory for private record\n" );
+ return FALSE;
+ }
+ pMga->DRIServerInfo = pMGADRIServer;
+
+ pDRIInfo->devPrivate = pMGADRI;
+ pDRIInfo->devPrivateSize = sizeof(MGADRIRec);
+ pDRIInfo->contextSize = sizeof(MGADRIContextRec);
+
+ pDRIInfo->CreateContext = MGACreateContext;
+ pDRIInfo->DestroyContext = MGADestroyContext;
+ if ( xf86IsEntityShared( pScrn->entityList[0] ) ) {
+ pDRIInfo->SwapContext = MGADRISwapContextShared;
+ } else {
+ pDRIInfo->SwapContext = MGADRISwapContext;
+ }
+
+ switch( pScrn->bitsPerPixel ) {
+ case 8:
+ pDRIInfo->InitBuffers = Mga8DRIInitBuffers;
+ pDRIInfo->MoveBuffers = Mga8DRIMoveBuffers;
+ case 16:
+ pDRIInfo->InitBuffers = Mga16DRIInitBuffers;
+ pDRIInfo->MoveBuffers = Mga16DRIMoveBuffers;
+ case 24:
+ pDRIInfo->InitBuffers = Mga24DRIInitBuffers;
+ pDRIInfo->MoveBuffers = Mga24DRIMoveBuffers;
+ case 32:
+ pDRIInfo->InitBuffers = Mga32DRIInitBuffers;
+ pDRIInfo->MoveBuffers = Mga32DRIMoveBuffers;
+ }
+
+ pDRIInfo->bufferRequests = DRI_ALL_WINDOWS;
+
+ if ( !DRIScreenInit( pScreen, pDRIInfo, &pMga->drmFD ) ) {
+ xfree( pMGADRIServer );
+ pMga->DRIServerInfo = 0;
+ xfree( pDRIInfo->devPrivate );
+ pDRIInfo->devPrivate = 0;
+ DRIDestroyInfoRec( pMga->pDRIInfo );
+ pMga->pDRIInfo = 0;
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[drm] DRIScreenInit failed. Disabling DRI.\n" );
+ return FALSE;
+ }
+
+ /* Check the DRM versioning */
+ {
+ drmVersionPtr version;
+
+ /* Check the DRM lib version.
+ drmGetLibVersion was not supported in version 1.0, so check for
+ symbol first to avoid possible crash or hang.
+ */
+ if (xf86LoaderCheckSymbol("drmGetLibVersion")) {
+ version = drmGetLibVersion(pMga->drmFD);
+ }
+ else {
+ /* drmlib version 1.0.0 didn't have the drmGetLibVersion
+ entry point. Fake it by allocating a version record
+ via drmGetVersion and changing it to version 1.0.0
+ */
+ version = drmGetVersion(pMga->drmFD);
+ version->version_major = 1;
+ version->version_minor = 0;
+ version->version_patchlevel = 0;
+ }
+
+ if (version) {
+ if (version->version_major != 1 ||
+ version->version_minor < 1) {
+ /* incompatible drm library version */
+ xf86DrvMsg(pScreen->myNum, X_ERROR,
+ "[dri] MGADRIScreenInit failed because of a version mismatch.\n"
+ "[dri] libdrm.a module version is %d.%d.%d but version 1.1.x is needed.\n"
+ "[dri] Disabling DRI.\n",
+ version->version_major,
+ version->version_minor,
+ version->version_patchlevel);
+ drmFreeVersion(version);
+ MGADRICloseScreen( pScreen ); /* FIXME: ??? */
+ return FALSE;
+ }
+ drmFreeVersion(version);
+ }
+
+ /* Check the MGA DRM version */
+ version = drmGetVersion(pMga->drmFD);
+ if ( version ) {
+ if ( version->version_major != 3 ||
+ version->version_minor < 0 ) {
+ /* incompatible drm version */
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[dri] MGADRIScreenInit failed because of a version mismatch.\n"
+ "[dri] mga.o kernel module version is %d.%d.%d but version 3.0.x is needed.\n"
+ "[dri] Disabling DRI.\n",
+ version->version_major,
+ version->version_minor,
+ version->version_patchlevel );
+ drmFreeVersion( version );
+ MGADRICloseScreen( pScreen ); /* FIXME: ??? */
+ return FALSE;
+ }
+ drmFreeVersion( version );
+ }
+ }
+
+#if 0
+ /* Calculate texture constants for AGP texture space.
+ * FIXME: move!
+ */
+ {
+ CARD32 agpTextureOffset = MGA_DMA_BUF_SZ * MGA_DMA_BUF_NR;
+ CARD32 agpTextureSize = pMGADRI->agp.size - agpTextureOffset;
+
+ i = mylog2(agpTextureSize / MGA_NR_TEX_REGIONS);
+ if (i < MGA_LOG_MIN_TEX_REGION_SIZE)
+ i = MGA_LOG_MIN_TEX_REGION_SIZE;
+
+ pMGADRI->logAgpTextureGranularity = i;
+ pMGADRI->agpTextureSize = (agpTextureSize >> i) << i;
+ pMGADRI->agpTextureOffset = agpTextureOffset;
+ }
+#endif
+
+ if ( !MGADRIAgpInit( pScreen ) ) {
+ DRICloseScreen( pScreen );
+ return FALSE;
+ }
+
+ if ( !MGADRIMapInit( pScreen ) ) {
+ DRICloseScreen( pScreen );
+ return FALSE;
+ }
+ {
+ void *scratch_ptr;
+ int scratch_int;
+
+ DRIGetDeviceInfo(pScreen, &pMGADRIServer->fb.handle,
+ &scratch_int, &scratch_int,
+ &scratch_int, &scratch_int,
+ &scratch_ptr);
+ }
+
+ if ( !MGAInitVisualConfigs( pScreen ) ) {
+ DRICloseScreen( pScreen );
+ return FALSE;
+ }
+ xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[dri] visual configs initialized\n" );
+
+ return TRUE;
+}
+
+
+Bool MGADRIFinishScreenInit( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+ MGADRIPtr pMGADRI = (MGADRIPtr)pMga->pDRIInfo->devPrivate;
+ int i;
+
+ if ( !pMga->pDRIInfo )
+ return FALSE;
+
+ pMga->pDRIInfo->driverSwapMethod = DRI_HIDE_X_CONTEXT;
+
+ /* NOTE: DRIFinishScreenInit must be called before *DRIKernelInit
+ * because *DRIKernelInit requires that the hardware lock is held by
+ * the X server, and the first time the hardware lock is grabbed is
+ * in DRIFinishScreenInit.
+ */
+ if ( !DRIFinishScreenInit( pScreen ) ) {
+ MGADRICloseScreen( pScreen );
+ return FALSE;
+ }
+
+ if ( !MGADRIKernelInit( pScreen ) ) {
+ MGADRICloseScreen( pScreen );
+ return FALSE;
+ }
+
+ if ( !MGADRIBuffersInit( pScreen ) ) {
+ MGADRICloseScreen( pScreen );
+ return FALSE;
+ }
+
+ MGADRIIrqInit(pMga, pScreen);
+
+ switch(pMga->Chipset) {
+ case PCI_CHIP_MGAG550:
+ case PCI_CHIP_MGAG400:
+ pMGADRI->chipset = MGA_CARD_TYPE_G400;
+ break;
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ pMGADRI->chipset = MGA_CARD_TYPE_G200;
+ break;
+ default:
+ return FALSE;
+ }
+ pMGADRI->width = pScrn->virtualX;
+ pMGADRI->height = pScrn->virtualY;
+ pMGADRI->mem = pScrn->videoRam * 1024;
+ pMGADRI->cpp = pScrn->bitsPerPixel / 8;
+
+ pMGADRI->agpMode = pMga->agpMode;
+
+ pMGADRI->frontOffset = pMGADRIServer->frontOffset;
+ pMGADRI->frontPitch = pMGADRIServer->frontPitch;
+ pMGADRI->backOffset = pMGADRIServer->backOffset;
+ pMGADRI->backPitch = pMGADRIServer->backPitch;
+ pMGADRI->depthOffset = pMGADRIServer->depthOffset;
+ pMGADRI->depthPitch = pMGADRIServer->depthPitch;
+ pMGADRI->textureOffset = pMGADRIServer->textureOffset;
+ pMGADRI->textureSize = pMGADRIServer->textureSize;
+
+ i = mylog2( pMGADRI->textureSize / MGA_NR_TEX_REGIONS );
+ if ( i < MGA_LOG_MIN_TEX_REGION_SIZE )
+ i = MGA_LOG_MIN_TEX_REGION_SIZE;
+
+ pMGADRI->logTextureGranularity = i;
+ pMGADRI->textureSize = (pMGADRI->textureSize >> i) << i; /* truncate */
+
+ i = mylog2( pMGADRIServer->agpTextures.size / MGA_NR_TEX_REGIONS );
+ if ( i < MGA_LOG_MIN_TEX_REGION_SIZE )
+ i = MGA_LOG_MIN_TEX_REGION_SIZE;
+
+ pMGADRI->logAgpTextureGranularity = i;
+ pMGADRI->agpTextureOffset = (unsigned int)pMGADRIServer->agpTextures.handle;
+ pMGADRI->agpTextureSize = (unsigned int)pMGADRIServer->agpTextures.size;
+
+ pMGADRI->registers.handle = pMGADRIServer->registers.handle;
+ pMGADRI->registers.size = pMGADRIServer->registers.size;
+ pMGADRI->status.handle = pMGADRIServer->status.handle;
+ pMGADRI->status.size = pMGADRIServer->status.size;
+ pMGADRI->primary.handle = pMGADRIServer->primary.handle;
+ pMGADRI->primary.size = pMGADRIServer->primary.size;
+ pMGADRI->buffers.handle = pMGADRIServer->buffers.handle;
+ pMGADRI->buffers.size = pMGADRIServer->buffers.size;
+ pMGADRI->sarea_priv_offset = sizeof(XF86DRISAREARec);
+ return TRUE;
+}
+
+
+void MGADRICloseScreen( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+ drmMGAInit init;
+
+ if ( pMGADRIServer->drmBuffers ) {
+ drmUnmapBufs( pMGADRIServer->drmBuffers );
+ pMGADRIServer->drmBuffers = NULL;
+ }
+
+ if (pMga->irq) {
+ drmCtlUninstHandler(pMga->drmFD);
+ pMga->irq = 0;
+ }
+
+ /* Cleanup DMA */
+ memset( &init, 0, sizeof(drmMGAInit) );
+ init.func = MGA_CLEANUP_DMA;
+ drmCommandWrite( pMga->drmFD, DRM_MGA_INIT, &init, sizeof(drmMGAInit) );
+
+ if ( pMGADRIServer->status.map ) {
+ drmUnmap( pMGADRIServer->status.map, pMGADRIServer->status.size );
+ pMGADRIServer->status.map = NULL;
+ }
+ if ( pMGADRIServer->buffers.map ) {
+ drmUnmap( pMGADRIServer->buffers.map, pMGADRIServer->buffers.size );
+ pMGADRIServer->buffers.map = NULL;
+ }
+ if ( pMGADRIServer->primary.map ) {
+ drmUnmap( pMGADRIServer->primary.map, pMGADRIServer->primary.size );
+ pMGADRIServer->primary.map = NULL;
+ }
+ if ( pMGADRIServer->warp.map ) {
+ drmUnmap( pMGADRIServer->warp.map, pMGADRIServer->warp.size );
+ pMGADRIServer->warp.map = NULL;
+ }
+
+ if ( pMGADRIServer->agpTextures.map ) {
+ drmUnmap( pMGADRIServer->agpTextures.map, pMGADRIServer->agpTextures.size );
+ pMGADRIServer->agpTextures.map = NULL;
+ }
+
+ if ( pMGADRIServer->agp.handle ) {
+ drmAgpUnbind( pMga->drmFD, pMGADRIServer->agp.handle );
+ drmAgpFree( pMga->drmFD, pMGADRIServer->agp.handle );
+ pMGADRIServer->agp.handle = 0;
+ drmAgpRelease( pMga->drmFD );
+ }
+
+ DRICloseScreen( pScreen );
+
+ if ( pMga->pDRIInfo ) {
+ if ( pMga->pDRIInfo->devPrivate ) {
+ xfree( pMga->pDRIInfo->devPrivate );
+ pMga->pDRIInfo->devPrivate = 0;
+ }
+ DRIDestroyInfoRec( pMga->pDRIInfo );
+ pMga->pDRIInfo = 0;
+ }
+ if ( pMga->DRIServerInfo ) {
+ xfree( pMga->DRIServerInfo );
+ pMga->DRIServerInfo = 0;
+ }
+ if ( pMga->pVisualConfigs ) {
+ xfree( pMga->pVisualConfigs );
+ }
+ if ( pMga->pVisualConfigsPriv ) {
+ xfree( pMga->pVisualConfigsPriv );
+ }
+}
diff --git a/src/mga_dri.h b/src/mga_dri.h
new file mode 100644
index 0000000..b9ed1c2
--- /dev/null
+++ b/src/mga_dri.h
@@ -0,0 +1,122 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_dri.h,v 1.8 2002/11/29 11:06:42 eich Exp $ */
+
+/*
+ * Copyright 2000 VA Linux Systems Inc., Fremont, California.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ * Keith Whitwell <keith@tungstengraphics.com>
+ * Gareth Hughes <gareth@valinux.com>
+ */
+
+#ifndef __MGA_DRI_H__
+#define __MGA_DRI_H__
+
+#include "xf86drm.h"
+#include "mga_common.h"
+
+#define MGA_DEFAULT_AGP_MODE 1
+#define MGA_MAX_AGP_MODE 4
+
+/* Buffer are aligned on 4096 byte boundaries.
+ */
+#define MGA_BUFFER_ALIGN 0x00000fff
+
+typedef struct {
+ int reserved_map_agpstart;
+ int reserved_map_idx;
+ int buffer_map_idx;
+ int sarea_priv_offset;
+ int primary_size;
+ int warp_ucode_size;
+ int chipset;
+ int sgram;
+
+ unsigned int frontOffset;
+ unsigned int frontPitch;
+
+ unsigned int backOffset;
+ unsigned int backPitch;
+
+ unsigned int depthOffset;
+ unsigned int depthPitch;
+
+ unsigned int textureOffset;
+ int textureSize;
+
+ drmRegion agp;
+
+ /* PCI mappings */
+ drmRegion fb;
+ drmRegion registers;
+ drmRegion status;
+
+ /* AGP mappings */
+ drmRegion warp;
+ drmRegion primary;
+ drmRegion buffers;
+ drmRegion agpTextures;
+
+ drmBufMapPtr drmBuffers;
+
+} MGADRIServerPrivateRec, *MGADRIServerPrivatePtr;
+
+typedef struct {
+ int chipset;
+ int width;
+ int height;
+ int mem;
+ int cpp;
+
+ int agpMode;
+
+ unsigned int frontOffset;
+ unsigned int frontPitch;
+
+ unsigned int backOffset;
+ unsigned int backPitch;
+
+ unsigned int depthOffset;
+ unsigned int depthPitch;
+
+ unsigned int textureOffset;
+ unsigned int textureSize;
+ int logTextureGranularity;
+
+ /* Allow calculation of setup dma addresses.
+ */
+ unsigned int agpBufferOffset;
+
+ unsigned int agpTextureOffset;
+ unsigned int agpTextureSize;
+ int logAgpTextureGranularity;
+
+ unsigned int mAccess;
+
+ drmRegion registers;
+ drmRegion status;
+ drmRegion primary;
+ drmRegion buffers;
+ unsigned int sarea_priv_offset;
+} MGADRIRec, *MGADRIPtr;
+
+#endif
diff --git a/src/mga_dripriv.h b/src/mga_dripriv.h
new file mode 100644
index 0000000..3ddd133
--- /dev/null
+++ b/src/mga_dripriv.h
@@ -0,0 +1,51 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_dripriv.h,v 1.4 2001/04/10 16:08:01 dawes Exp $ */
+
+/*
+ * Copyright 2000 VA Linux Systems Inc., Fremont, California.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ * Gareth Hughes <gareth@valinux.com>
+ */
+
+#ifndef __MGA_DRIPRIV_H__
+#define __MGA_DRIPRIV_H__
+
+#include "GL/glxint.h"
+
+#define MGA_MAX_DRAWABLES 256
+
+extern void GlxSetVisualConfigs( int nconfigs,
+ __GLXvisualConfig *configs,
+ void **configprivs );
+
+typedef struct {
+ /* Nothing here yet */
+ int dummy;
+} MGAConfigPrivRec, *MGAConfigPrivPtr;
+
+typedef struct {
+ /* Nothing here yet */
+ int dummy;
+} MGADRIContextRec, *MGADRIContextPtr;
+
+#endif
diff --git a/src/mga_driver.c b/src/mga_driver.c
new file mode 100644
index 0000000..c2696d1
--- /dev/null
+++ b/src/mga_driver.c
@@ -0,0 +1,4166 @@
+/* $XConsortium: mga_driver.c /main/12 1996/10/28 05:13:26 kaleb $ */
+/*
+ * MGA Millennium (MGA2064W) with Ti3026 RAMDAC driver v.1.1
+ *
+ * The driver is written without any chip documentation. All extended ports
+ * and registers come from tracing the VESA-ROM functions.
+ * The BitBlt Engine comes from tracing the windows BitBlt function.
+ *
+ * Author: Radoslaw Kapitan, Tarnow, Poland
+ * kapitan@student.uci.agh.edu.pl
+ * original source
+ *
+ * Now that MATROX has released documentation to the public, enhancing
+ * this driver has become much easier. Nevertheless, this work continues
+ * to be based on Radoslaw's original source
+ *
+ * Contributors:
+ * Andrew van der Stock
+ * ajv@greebo.net
+ * additions, corrections, cleanups
+ *
+ * Dirk Hohndel
+ * hohndel@XFree86.Org
+ * integrated into XFree86-3.1.2Gg
+ * fixed some problems with PCI probing and mapping
+ *
+ * David Dawes
+ * dawes@XFree86.Org
+ * some cleanups, and fixed some problems
+ *
+ * Andrew E. Mileski
+ * aem@ott.hookup.net
+ * RAMDAC timing, and BIOS stuff
+ *
+ * Leonard N. Zubkoff
+ * lnz@dandelion.com
+ * Support for 8MB boards, RGB Sync-on-Green, and DPMS.
+ * Guy DESBIEF
+ * g.desbief@aix.pacwan.net
+ * RAMDAC MGA1064 timing,
+ * Doug Merritt
+ * doug@netcom.com
+ * Fixed 32bpp hires 8MB horizontal line glitch at middle right
+ * Niels Gram Jeppesen
+ * Added digital screen option for first head
+ */
+
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_driver.c,v 1.231 2003/01/29 19:29:49 eich Exp $ */
+
+/*
+ * This is a first cut at a non-accelerated version to work with the
+ * new server design (DHD).
+ */
+
+
+/* All drivers should typically include these */
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+
+/* All drivers need this */
+#include "xf86_ansic.h"
+
+#include "compiler.h"
+
+/* Drivers for PCI hardware need this */
+#include "xf86PciInfo.h"
+
+/* Drivers that need to access the PCI config space directly need this */
+#include "xf86Pci.h"
+
+/* All drivers initialising the SW cursor need this */
+#include "mipointer.h"
+
+/* All drivers implementing backing store need this */
+#include "mibstore.h"
+
+#include "micmap.h"
+
+#include "xf86DDC.h"
+#include "xf86RAC.h"
+#include "vbe.h"
+
+#include "fb.h"
+#include "cfb8_32.h"
+#include "dixstruct.h"
+
+#include "mga_reg.h"
+#include "mga.h"
+#include "mga_macros.h"
+
+#include "xaa.h"
+#include "xf86cmap.h"
+#include "shadowfb.h"
+#include "fbdevhw.h"
+
+#ifdef XF86DRI
+#include "dri.h"
+#endif
+
+/*
+ * Forward definitions for the functions that make up the driver.
+ */
+
+/* Mandatory functions */
+static const OptionInfoRec * MGAAvailableOptions(int chipid, int busid);
+static void MGAIdentify(int flags);
+static Bool MGAProbe(DriverPtr drv, int flags);
+static Bool MGAPreInit(ScrnInfoPtr pScrn, int flags);
+static Bool MGAScreenInit(int Index, ScreenPtr pScreen, int argc,
+ char **argv);
+static Bool MGAEnterVT(int scrnIndex, int flags);
+static Bool MGAEnterVTFBDev(int scrnIndex, int flags);
+static void MGALeaveVT(int scrnIndex, int flags);
+static Bool MGACloseScreen(int scrnIndex, ScreenPtr pScreen);
+static Bool MGASaveScreen(ScreenPtr pScreen, int mode);
+static Bool MGASaveScreenCrtc2(ScreenPtr pScreen, int mode);
+
+/* This shouldn't be needed since RAC will disable all I/O for MGA cards. */
+#ifdef DISABLE_VGA_IO
+static void VgaIOSave(int i, void *arg);
+static void VgaIORestore(int i, void *arg);
+#endif
+
+/* Optional functions */
+static void MGAFreeScreen(int scrnIndex, int flags);
+static int MGAValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose,
+ int flags);
+
+/* Internally used functions */
+static Bool MGAMapMem(ScrnInfoPtr pScrn);
+static Bool MGAUnmapMem(ScrnInfoPtr pScrn);
+static void MGASave(ScrnInfoPtr pScrn);
+static void MGARestore(ScrnInfoPtr pScrn);
+static Bool MGAModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode);
+static void MGABlockHandler(int, pointer, pointer, pointer);
+static void MGAG100BlackMagic(MGAPtr pMga);
+
+static int MGAEntityIndex = -1;
+
+#include "mga_merge.h"
+
+
+/*
+ * This contains the functions needed by the server after loading the
+ * driver module. It must be supplied, and gets added the driver list by
+ * the Module Setup funtion in the dynamic case. In the static case a
+ * reference to this is compiled in, and this requires that the name of
+ * this DriverRec be an upper-case version of the driver name.
+ */
+
+DriverRec MGA_C_NAME = {
+ MGA_VERSION,
+ MGA_DRIVER_NAME,
+ MGAIdentify,
+ MGAProbe,
+ MGAAvailableOptions,
+ NULL,
+ 0
+};
+
+/* Supported chipsets */
+static SymTabRec MGAChipsets[] = {
+ { PCI_CHIP_MGA2064, "mga2064w" },
+ { PCI_CHIP_MGA1064, "mga1064sg" },
+ { PCI_CHIP_MGA2164, "mga2164w" },
+ { PCI_CHIP_MGA2164_AGP, "mga2164w AGP" },
+ { PCI_CHIP_MGAG100, "mgag100" },
+ { PCI_CHIP_MGAG100_PCI, "mgag100 PCI" },
+ { PCI_CHIP_MGAG200, "mgag200" },
+ { PCI_CHIP_MGAG200_PCI, "mgag200 PCI" },
+ { PCI_CHIP_MGAG400, "mgag400" },
+ { PCI_CHIP_MGAG550, "mgag550" },
+ {-1, NULL }
+};
+
+static PciChipsets MGAPciChipsets[] = {
+ { PCI_CHIP_MGA2064, PCI_CHIP_MGA2064, (resRange*)RES_SHARED_VGA },
+ { PCI_CHIP_MGA1064, PCI_CHIP_MGA1064, (resRange*)RES_SHARED_VGA },
+ { PCI_CHIP_MGA2164, PCI_CHIP_MGA2164, (resRange*)RES_SHARED_VGA },
+ { PCI_CHIP_MGA2164_AGP, PCI_CHIP_MGA2164_AGP,(resRange*)RES_SHARED_VGA },
+ { PCI_CHIP_MGAG100, PCI_CHIP_MGAG100, (resRange*)RES_SHARED_VGA },
+ { PCI_CHIP_MGAG100_PCI, PCI_CHIP_MGAG100_PCI,(resRange*)RES_SHARED_VGA },
+ { PCI_CHIP_MGAG200, PCI_CHIP_MGAG200, (resRange*)RES_SHARED_VGA },
+ { PCI_CHIP_MGAG200_PCI, PCI_CHIP_MGAG200_PCI,(resRange*)RES_SHARED_VGA },
+ { PCI_CHIP_MGAG400, PCI_CHIP_MGAG400, (resRange*)RES_SHARED_VGA },
+ { PCI_CHIP_MGAG550, PCI_CHIP_MGAG550, (resRange*)RES_SHARED_VGA },
+ { -1, -1, (resRange*)RES_UNDEFINED }
+};
+
+static const OptionInfoRec MGAOptions[] = {
+ { OPTION_SW_CURSOR, "SWcursor", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_HW_CURSOR, "HWcursor", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_PCI_RETRY, "PciRetry", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_SYNC_ON_GREEN, "SyncOnGreen", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_NOACCEL, "NoAccel", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_SHOWCACHE, "ShowCache", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_OVERLAY, "Overlay", OPTV_ANYSTR, {0}, FALSE },
+ { OPTION_MGA_SDRAM, "MGASDRAM", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_SHADOW_FB, "ShadowFB", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_FBDEV, "UseFBDev", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_COLOR_KEY, "ColorKey", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_SET_MCLK, "SetMclk", OPTV_FREQ, {0}, FALSE },
+ { OPTION_OVERCLOCK_MEM, "OverclockMem", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_VIDEO_KEY, "VideoKey", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_ROTATE, "Rotate", OPTV_ANYSTR, {0}, FALSE },
+ { OPTION_TEXTURED_VIDEO, "TexturedVideo",OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_CRTC2HALF, "Crtc2Half", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_CRTC2RAM, "Crtc2Ram", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_INT10, "Int10", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_AGP_MODE, "AGPMode", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_AGP_SIZE, "AGPSize", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_DIGITAL1, "DigitalScreen1",OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_DIGITAL2, "DigitalScreen2",OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_TV, "TV", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_TVSTANDARD, "TVStandard", OPTV_ANYSTR, {0}, FALSE },
+ { OPTION_CABLETYPE, "CableType", OPTV_ANYSTR, {0}, FALSE },
+ { OPTION_NOHAL, "NoHal", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_SWAPPED_HEAD, "SwappedHead", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_DRI, "DRI", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_MERGEDFB, "MergedFB", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_HSYNC2, "Monitor2HSync", OPTV_ANYSTR, {0}, FALSE },
+ { OPTION_VREFRESH2, "Monitor2VRefresh", OPTV_ANYSTR, {0}, FALSE },
+ { OPTION_MONITOR2POS, "Monitor2Position", OPTV_ANYSTR, {0}, FALSE },
+ { OPTION_METAMODES, "MetaModes", OPTV_ANYSTR, {0}, FALSE },
+ { -1, NULL, OPTV_NONE, {0}, FALSE }
+};
+
+
+/*
+ * List of symbols from other modules that this module references. This
+ * list is used to tell the loader that it is OK for symbols here to be
+ * unresolved providing that it hasn't been told that they haven't been
+ * told that they are essential via a call to xf86LoaderReqSymbols() or
+ * xf86LoaderReqSymLists(). The purpose is this is to avoid warnings about
+ * unresolved symbols that are not required.
+ */
+
+static const char *vgahwSymbols[] = {
+ "vgaHWFreeHWRec",
+ "vgaHWGetHWRec",
+ "vgaHWGetIOBase",
+ "vgaHWGetIndex",
+ "vgaHWInit",
+ "vgaHWLock",
+ "vgaHWMapMem",
+ "vgaHWProtect",
+ "vgaHWRestore",
+ "vgaHWSave",
+ "vgaHWSaveScreen",
+ "vgaHWSetMmioFuncs",
+ "vgaHWUnlock",
+ "vgaHWUnmapMem",
+ "vgaHWddc1SetSpeed",
+ NULL
+};
+
+static const char *fbSymbols[] = {
+ "fbPictureInit",
+ "fbScreenInit",
+ NULL
+};
+
+static const char *xf8_32bppSymbols[] = {
+ "cfb8_32ScreenInit",
+ "xf86Overlay8Plus32Init",
+ NULL
+};
+
+static const char *xaaSymbols[] = {
+ "XAACachePlanarMonoStipple",
+ "XAACreateInfoRec",
+ "XAADestroyInfoRec",
+ "XAAFallbackOps",
+ "XAAFillSolidRects",
+ "XAAInit",
+ "XAAMoveDWORDS",
+ "XAAScreenIndex",
+ "XAA_888_plus_PICT_a8_to_8888",
+ NULL
+};
+
+static const char *ramdacSymbols[] = {
+ "xf86CreateCursorInfoRec",
+ "xf86DestroyCursorInfoRec",
+ "xf86InitCursor",
+ NULL
+};
+
+#ifdef XFree86LOADER
+#ifdef XF86DRI
+static const char *drmSymbols[] = {
+ "drmAddBufs",
+ "drmAddMap",
+ "drmAgpAcquire",
+ "drmAgpAlloc",
+ "drmAgpBind",
+ "drmAgpDeviceId",
+ "drmAgpEnable",
+ "drmAgpFree",
+ "drmAgpGetMode",
+ "drmAgpRelease",
+ "drmAgpUnbind",
+ "drmAgpVendorId",
+ "drmCommandNone",
+ "drmCommandWrite",
+ "drmFreeVersion",
+ "drmGetLibVersion",
+ "drmGetVersion",
+ "drmMap",
+ "drmMapBufs",
+ "drmUnmap",
+ "drmUnmapBufs",
+ NULL
+};
+
+static const char *driSymbols[] = {
+ "DRICloseScreen",
+ "DRICreateInfoRec",
+ "DRIDestroyInfoRec",
+ "DRIFinishScreenInit",
+ "DRIGetDeviceInfo",
+ "DRILock",
+ "DRIQueryVersion",
+ "DRIScreenInit",
+ "DRIUnlock",
+ "GlxSetVisualConfigs",
+ NULL
+};
+#endif
+#endif
+
+#define MGAuseI2C 1
+
+static const char *ddcSymbols[] = {
+ "xf86DoEDID_DDC1",
+#if MGAuseI2C
+ "xf86DoEDID_DDC2",
+#endif
+ "xf86PrintEDID",
+ "xf86SetDDCproperties",
+ NULL
+};
+
+static const char *i2cSymbols[] = {
+ "xf86CreateI2CBusRec",
+ "xf86I2CBusInit",
+ NULL
+};
+
+static const char *shadowSymbols[] = {
+ "ShadowFBInit",
+ NULL
+};
+
+#ifdef XFree86LOADER
+static const char *vbeSymbols[] = {
+ "VBEInit",
+ "vbeDoEDID",
+ "vbeFree",
+ NULL
+};
+#endif
+
+static const char *int10Symbols[] = {
+ "xf86FreeInt10",
+ "xf86InitInt10",
+ NULL
+};
+
+static const char *fbdevHWSymbols[] = {
+ "fbdevHWAdjustFrame",
+ "fbdevHWEnterVT",
+ "fbdevHWGetVidmem",
+ "fbdevHWInit",
+ "fbdevHWLeaveVT",
+ "fbdevHWLoadPalette",
+ "fbdevHWMapMMIO",
+ "fbdevHWMapVidmem",
+ "fbdevHWModeInit",
+ "fbdevHWRestore",
+ "fbdevHWSave",
+ "fbdevHWSwitchMode",
+ "fbdevHWUnmapMMIO",
+ "fbdevHWUnmapVidmem",
+ "fbdevHWUseBuildinMode",
+ "fbdevHWValidMode",
+ NULL
+};
+
+#ifdef USEMGAHAL
+static const char *halSymbols[] = {
+ "MGACloseLibrary",
+ "MGAGetBOARDHANDLESize",
+ "MGAGetHardwareInfo",
+ "MGAOpenLibrary",
+ "MGARestoreVgaState",
+ "MGASaveVgaState",
+ "MGASetMode",
+ "MGASetVgaMode",
+ "MGAValidateMode",
+ "MGAValidateVideoParameters",
+ "HALSetDisplayStart",
+ NULL
+};
+#endif
+#ifdef XFree86LOADER
+
+static MODULESETUPPROTO(mgaSetup);
+
+static XF86ModuleVersionInfo mgaVersRec =
+{
+ MGA_DRIVER_NAME,
+ MODULEVENDORSTRING,
+ MODINFOSTRING1,
+ MODINFOSTRING2,
+ XF86_VERSION_CURRENT,
+ MGA_MAJOR_VERSION, MGA_MINOR_VERSION, MGA_PATCHLEVEL,
+ ABI_CLASS_VIDEODRV, /* This is a video driver */
+ ABI_VIDEODRV_VERSION,
+ MOD_CLASS_VIDEODRV,
+ {0,0,0,0}
+};
+
+XF86ModuleData MGA_MODULE_DATA = { &mgaVersRec, mgaSetup, NULL };
+
+static pointer
+mgaSetup(pointer module, pointer opts, int *errmaj, int *errmin)
+{
+ static Bool setupDone = FALSE;
+
+ /* This module should be loaded only once, but check to be sure. */
+
+ if (!setupDone) {
+ setupDone = TRUE;
+ xf86AddDriver(&MGA_C_NAME, module, 0);
+
+ /*
+ * Modules that this driver always requires may be loaded here
+ * by calling LoadSubModule().
+ */
+
+ /*
+ * Tell the loader about symbols from other modules that this module
+ * might refer to.
+ */
+ LoaderRefSymLists(vgahwSymbols, xaaSymbols,
+ xf8_32bppSymbols, ramdacSymbols,
+ ddcSymbols, i2cSymbols, shadowSymbols,
+ fbdevHWSymbols, vbeSymbols,
+ fbSymbols, int10Symbols,
+#ifdef XF86DRI
+ drmSymbols, driSymbols,
+#endif
+#ifdef USEMGAHAL
+ halSymbols,
+#endif
+ NULL);
+
+ /*
+ * The return value must be non-NULL on success even though there
+ * is no TearDownProc.
+ */
+ return (pointer)1;
+ } else {
+ if (errmaj) *errmaj = LDR_ONCEONLY;
+ return NULL;
+ }
+}
+
+
+#endif /* XFree86LOADER */
+
+/*
+ * ramdac info structure initialization
+ */
+static MGARamdacRec DacInit = {
+ FALSE, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL,
+ 90000, /* maxPixelClock */
+ 0, X_DEFAULT, X_DEFAULT, FALSE
+};
+
+Bool
+MGAGetRec(ScrnInfoPtr pScrn)
+{
+ /*
+ * Allocate an MGARec, and hook it into pScrn->driverPrivate.
+ * pScrn->driverPrivate is initialised to NULL, so we can check if
+ * the allocation has already been done.
+ */
+ if (pScrn->driverPrivate != NULL)
+ return TRUE;
+
+ pScrn->driverPrivate = xnfcalloc(sizeof(MGARec), 1);
+ /* Initialise it */
+
+ MGAPTR(pScrn)->Dac = DacInit;
+ return TRUE;
+}
+
+void
+MGAFreeRec(ScrnInfoPtr pScrn)
+{
+ if (pScrn->driverPrivate == NULL)
+ return;
+ xfree(pScrn->driverPrivate);
+ pScrn->driverPrivate = NULL;
+}
+
+static const OptionInfoRec *
+MGAAvailableOptions(int chipid, int busid)
+{
+ return MGAOptions;
+}
+
+/* Mandatory */
+static void
+MGAIdentify(int flags)
+{
+ xf86PrintChipsets(MGA_NAME, "driver for Matrox chipsets", MGAChipsets);
+}
+
+
+/* Mandatory */
+static Bool
+MGAProbe(DriverPtr drv, int flags)
+{
+ int i;
+ GDevPtr *devSections;
+ int *usedChips = NULL;
+ int numDevSections;
+ int numUsed;
+ Bool foundScreen = FALSE;
+
+ /*
+ * The aim here is to find all cards that this driver can handle,
+ * and for the ones not already claimed by another driver, claim the
+ * slot, and allocate a ScrnInfoRec.
+ *
+ * This should be a minimal probe, and it should under no circumstances
+ * change the state of the hardware. Because a device is found, don't
+ * assume that it will be used. Don't do any initialisations other than
+ * the required ScrnInfoRec initialisations. Don't allocate any new
+ * data structures.
+ */
+
+ /*
+ * Check if there has been a chipset override in the config file.
+ * For this we must find out if there is an active device section which
+ * is relevant, i.e., which has no driver specified or has THIS driver
+ * specified.
+ */
+
+ if ((numDevSections = xf86MatchDevice(MGA_DRIVER_NAME,
+ &devSections)) <= 0) {
+ /*
+ * There's no matching device section in the config file, so quit
+ * now.
+ */
+ return FALSE;
+ }
+
+ /*
+ * We need to probe the hardware first. We then need to see how this
+ * fits in with what is given in the config file, and allow the config
+ * file info to override any contradictions.
+ */
+
+ /*
+ * All of the cards this driver supports are PCI, so the "probing" just
+ * amounts to checking the PCI data that the server has already collected.
+ */
+ if (xf86GetPciVideoInfo() == NULL) {
+ /*
+ * We won't let anything in the config file override finding no
+ * PCI video cards at all. This seems reasonable now, but we'll see.
+ */
+ return FALSE;
+ }
+
+ numUsed = xf86MatchPciInstances(MGA_NAME, PCI_VENDOR_MATROX,
+ MGAChipsets, MGAPciChipsets, devSections,
+ numDevSections, drv, &usedChips);
+ /* Free it since we don't need that list after this */
+ xfree(devSections);
+ if (numUsed <= 0)
+ return FALSE;
+
+
+ if (flags & PROBE_DETECT)
+ foundScreen = TRUE;
+ else for (i = 0; i < numUsed; i++) {
+ ScrnInfoPtr pScrn;
+ EntityInfoPtr pEnt;
+#ifdef DISABLE_VGA_IO
+ MgaSavePtr smga;
+#endif
+
+ /* Allocate a ScrnInfoRec and claim the slot */
+ pScrn = NULL;
+
+#ifndef DISABLE_VGA_IO
+ if ((pScrn = xf86ConfigPciEntity(pScrn, 0,usedChips[i],
+ MGAPciChipsets, NULL, NULL,
+ NULL, NULL, NULL)))
+#else
+ smga = xnfalloc(sizeof(MgaSave));
+ smga->pvp = xf86GetPciInfoForEntity(usedChips[i]);
+ if ((pScrn = xf86ConfigPciEntity(pScrn, 0,usedChips[i],
+ MGAPciChipsets, NULL,VgaIOSave,
+ VgaIOSave, VgaIORestore,smga)))
+#endif
+ {
+
+ /* Fill in what we can of the ScrnInfoRec */
+ pScrn->driverVersion = MGA_VERSION;
+ pScrn->driverName = MGA_DRIVER_NAME;
+ pScrn->name = MGA_NAME;
+ pScrn->Probe = MGAProbe;
+ pScrn->PreInit = MGAPreInit;
+ pScrn->ScreenInit = MGAScreenInit;
+ pScrn->SwitchMode = MGASwitchMode;
+ pScrn->AdjustFrame = MGAAdjustFrame;
+ pScrn->EnterVT = MGAEnterVT;
+ pScrn->LeaveVT = MGALeaveVT;
+ pScrn->FreeScreen = MGAFreeScreen;
+ pScrn->ValidMode = MGAValidMode;
+
+ foundScreen = TRUE;
+ }
+
+ /*
+ * For cards that can do dual head per entity, mark the entity
+ * as sharable.
+ */
+ pEnt = xf86GetEntityInfo(usedChips[i]);
+ if ((pEnt->chipset == PCI_CHIP_MGAG400 || pEnt->chipset == PCI_CHIP_MGAG550)) {
+ MGAEntPtr pMgaEnt = NULL;
+ DevUnion *pPriv;
+
+ xf86SetEntitySharable(usedChips[i]);
+ /* Allocate an entity private if necessary */
+ if (MGAEntityIndex < 0)
+ MGAEntityIndex = xf86AllocateEntityPrivateIndex();
+ pPriv = xf86GetEntityPrivate(pScrn->entityList[0], MGAEntityIndex);
+ if (!pPriv->ptr) {
+ pPriv->ptr = xnfcalloc(sizeof(MGAEntRec), 1);
+ pMgaEnt = pPriv->ptr;
+ pMgaEnt->lastInstance = -1;
+ } else {
+ pMgaEnt = pPriv->ptr;
+ }
+ /*
+ * Set the entity instance for this instance of the driver. For
+ * dual head per card, instance 0 is the "master" instance, driving
+ * the primary head, and instance 1 is the "slave".
+ */
+ pMgaEnt->lastInstance++;
+ xf86SetEntityInstanceForScreen(pScrn, pScrn->entityList[0],
+ pMgaEnt->lastInstance);
+ }
+ }
+
+ xfree(usedChips);
+
+ return foundScreen;
+}
+
+
+/*
+ * Should aim towards not relying on this.
+ */
+
+/*
+ * MGAReadBios - Read the video BIOS info block.
+ *
+ * DESCRIPTION
+ * Warning! This code currently does not detect a video BIOS.
+ * In the future, support for motherboards with the mga2064w
+ * will be added (no video BIOS) - this is not a huge concern
+ * for me today though. (XXX)
+ *
+ * EXTERNAL REFERENCES
+ * vga256InfoRec.BIOSbase IN Physical address of video BIOS.
+ * MGABios OUT The video BIOS info block.
+ *
+ * HISTORY
+ * August 31, 1997 - [ajv] Andrew van der Stock
+ * Fixed to understand Mystique and Millennium II
+ *
+ * January 11, 1997 - [aem] Andrew E. Mileski
+ * Set default values for GCLK (= MCLK / pre-scale ).
+ *
+ * October 7, 1996 - [aem] Andrew E. Mileski
+ * Written and tested.
+ */
+
+void
+MGAReadBios(ScrnInfoPtr pScrn)
+{
+ CARD8 BIOS[0x10000];
+ CARD16 offset;
+ CARD8 chksum;
+ CARD8 *pPINSInfo;
+ MGAPtr pMga;
+ MGABiosInfo *pBios;
+ MGABios2Info *pBios2;
+ Bool pciBIOS = TRUE;
+ int rlen;
+
+ pMga = MGAPTR(pScrn);
+ pBios = &pMga->Bios;
+ pBios2 = &pMga->Bios2;
+
+ /* Get the output mode set by the BIOS */
+ xf86ReadDomainMemory(pMga->PciTag, pMga->BiosAddress + 0x7ff1u,
+ sizeof(CARD8), &pMga->BiosOutputMode);
+
+ /*
+ * If the BIOS address was probed, it was found from the PCI config
+ * space. If it was given in the config file, try to guess when it
+ * looks like it might be controlled by the PCI config space.
+ */
+ if (pMga->BiosFrom == X_DEFAULT)
+ pciBIOS = FALSE;
+ else if (pMga->BiosFrom == X_CONFIG && pMga->BiosAddress < 0x100000)
+ pciBIOS = TRUE;
+
+ if (pciBIOS)
+ rlen = xf86ReadPciBIOS(0, pMga->PciTag, pMga->FbBaseReg,
+ BIOS, sizeof(BIOS));
+ else
+ rlen = xf86ReadDomainMemory(pMga->PciTag, pMga->BiosAddress,
+ sizeof(BIOS), BIOS);
+
+ if (rlen < (BIOS[2] << 9)) {
+ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+ "Could not retrieve video BIOS!\n");
+ return;
+ }
+
+ /* Get the video BIOS info block */
+ if (strncmp((char *)(&BIOS[45]), "MATROX", 6)) {
+ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+ "Video BIOS info block not detected!\n");
+ return;
+ }
+
+ /* Get the info block offset */
+ offset = (BIOS[0x7ffd] << 8) | BIOS[0x7ffc];
+
+ /* Let the world know what we are up to */
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+ "Video BIOS info block at offset 0x%05lX\n",
+ (long)(offset));
+
+#define MGADoBIOSRead(offset, buf, len) memcpy(buf, &BIOS[offset], len)
+
+ /* Copy the info block */
+ /* XXX What about big-endianness? */
+ switch (pMga->Chipset){
+ case PCI_CHIP_MGA2064:
+ MGADoBIOSRead(offset,
+ ( CARD8 * ) & pBios->StructLen, sizeof( MGABiosInfo ));
+ break;
+ default:
+ MGADoBIOSRead(offset,
+ ( CARD8 * ) & pBios2->PinID, sizeof( MGABios2Info ));
+ break;
+ }
+
+ /* matrox millennium-2 and mystique pins info */
+ if ( pBios2->PinID == 0x412e ) {
+ int i;
+ /* check that the pins info is correct */
+ if ( pBios2->StructLen != 0x40 ) {
+ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+ "Video BIOS info block not detected!\n");
+ pBios2->PinID = 0;
+ return;
+ }
+ /* check that the chksum is correct */
+ chksum = 0;
+ pPINSInfo = (CARD8 *) &pBios2->PinID;
+
+ for (i=0; i < pBios2->StructLen; i++) {
+ chksum += *pPINSInfo;
+ pPINSInfo++;
+ }
+
+ if ( chksum ) {
+ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+ "Video BIOS info block did not checksum!\n");
+ pBios2->PinID = 0;
+ return;
+ }
+
+ /* last check */
+ if ( pBios2->StructRev == 0 ) {
+ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+ "Video BIOS info block does not have a valid revision!\n");
+ pBios2->PinID = 0;
+ return;
+ }
+
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+ "Found and verified enhanced Video BIOS info block\n");
+
+ /* Set default MCLK values (scaled by 100 kHz) */
+ if ( pBios2->ClkMem == 0 )
+ pBios2->ClkMem = 50;
+ if ( pBios2->Clk4MB == 0 )
+ pBios2->Clk4MB = pBios->ClkBase;
+ if ( pBios2->Clk8MB == 0 )
+ pBios2->Clk8MB = pBios->Clk4MB;
+ pBios->StructLen = 0; /* not in use */
+#ifdef DEBUG
+ for (i = 0; i < 0x40; i++)
+ ErrorF("Pins[0x%02x] is 0x%02x\n", i,
+ ((unsigned char *)pBios2)[i]);
+#endif
+ } else {
+ /* Set default MCLK values (scaled by 10 kHz) */
+ if ( pBios->ClkBase == 0 )
+ pBios->ClkBase = 4500;
+ if ( pBios->Clk4MB == 0 )
+ pBios->Clk4MB = pBios->ClkBase;
+ if ( pBios->Clk8MB == 0 )
+ pBios->Clk8MB = pBios->Clk4MB;
+ pBios2->PinID = 0; /* not in use */
+ }
+}
+
+/*
+ * MGASoftReset --
+ *
+ * Resets drawing engine
+ */
+void
+MGASoftReset(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ pMga->FbMapSize = 8192 * 1024;
+ MGAMapMem(pScrn);
+
+ /* set soft reset bit */
+ OUTREG(MGAREG_Reset, 1);
+ usleep(200);
+ OUTREG(MGAREG_Reset, 0);
+
+ /* reset memory */
+ OUTREG(MGAREG_MACCESS, 1<<15);
+ usleep(10);
+
+#if 0
+ /* This will hang if the PLLs aren't on */
+
+ /* wait until drawing engine is ready */
+ while ( MGAISBUSY() )
+ usleep(1000);
+
+ /* flush FIFO */
+ i = 32;
+ WAITFIFO(i);
+ while ( i-- )
+ OUTREG(MGAREG_SHIFT, 0);
+#endif
+
+ MGAUnmapMem(pScrn);
+}
+
+/*
+ * MGACountRAM --
+ *
+ * Counts amount of installed RAM
+ */
+static int
+MGACountRam(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int ProbeSize = 8192;
+ int SizeFound = 2048;
+ CARD32 biosInfo = 0;
+
+#if 0
+ /* This isn't correct. It looks like this can have arbitrary
+ data for the memconfig even when the bios has initialized
+ it. At least, my cards don't advertise the documented
+ values (my 8 and 16 Meg G200s have the same values) */
+ if(pMga->Primary) /* can only trust this for primary cards */
+ biosInfo = pciReadLong(pMga->PciTag, PCI_OPTION_REG);
+#endif
+
+ switch(pMga->Chipset) {
+ case PCI_CHIP_MGA2164:
+ case PCI_CHIP_MGA2164_AGP:
+ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+ "Unable to probe memory amount due to hardware bug. "
+ "Assuming 4096 KB\n");
+ return 4096;
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG550:
+ if(biosInfo) {
+ switch((biosInfo >> 10) & 0x07) {
+ case 0:
+ return (biosInfo & (1 << 14)) ? 32768 : 16384;
+ case 1:
+ case 2:
+ return 16384;
+ case 3:
+ case 5:
+ return 65536;
+ case 4:
+ return 32768;
+ }
+ }
+ ProbeSize = 32768;
+ break;
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ if(biosInfo) {
+ switch((biosInfo >> 11) & 0x03) {
+ case 0:
+ return 8192;
+ default:
+ return 16384;
+ }
+ }
+ ProbeSize = 16384;
+ break;
+ case PCI_CHIP_MGAG100:
+ case PCI_CHIP_MGAG100_PCI:
+ if(biosInfo) /* I'm not sure if the docs are correct */
+ return (biosInfo & (1 << 12)) ? 16384 : 8192;
+ case PCI_CHIP_MGA1064:
+ case PCI_CHIP_MGA2064:
+ ProbeSize = 8192;
+ break;
+ default:
+ break;
+ }
+
+ if (pMga->FbAddress) {
+ volatile unsigned char* base;
+ unsigned char tmp;
+ int i;
+
+ pMga->FbMapSize = ProbeSize * 1024;
+ MGAMapMem(pScrn);
+ base = pMga->FbBase;
+
+ /* turn MGA mode on - enable linear frame buffer (CRTCEXT3) */
+ OUTREG8(MGAREG_CRTCEXT_INDEX, 3);
+ tmp = INREG8(MGAREG_CRTCEXT_DATA);
+ OUTREG8(MGAREG_CRTCEXT_DATA, tmp | 0x80);
+
+ /* write, read and compare method */
+ for(i = ProbeSize; i > 2048; i -= 2048) {
+ base[(i * 1024) - 1] = 0xAA;
+ OUTREG8(MGAREG_CRTC_INDEX, 0); /* flush the cache */
+ usleep(1); /* twart write combination */
+ if(base[(i * 1024) - 1] == 0xAA) {
+ SizeFound = i;
+ break;
+ }
+ }
+
+ /* restore CRTCEXT3 state */
+ OUTREG8(MGAREG_CRTCEXT_INDEX, 3);
+ OUTREG8(MGAREG_CRTCEXT_DATA, tmp);
+
+ MGAUnmapMem(pScrn);
+ }
+ return SizeFound;
+}
+
+static xf86MonPtr
+MGAdoDDC(ScrnInfoPtr pScrn)
+{
+ vgaHWPtr hwp;
+ MGAPtr pMga;
+ MGARamdacPtr MGAdac;
+ xf86MonPtr MonInfo = NULL;
+
+ hwp = VGAHWPTR(pScrn);
+ pMga = MGAPTR(pScrn);
+ MGAdac = &pMga->Dac;
+
+ /* Load DDC if we have the code to use it */
+ /* This gives us DDC1 */
+ if (pMga->ddc1Read || pMga->i2cInit) {
+ if (xf86LoadSubModule(pScrn, "ddc")) {
+ xf86LoaderReqSymLists(ddcSymbols, NULL);
+ } else {
+ /* ddc module not found, we can do without it */
+ pMga->ddc1Read = NULL;
+
+ /* Without DDC, we have no use for the I2C bus */
+ pMga->i2cInit = NULL;
+ return NULL;
+ }
+ } else
+ return NULL;
+
+#if MGAuseI2C
+ /* - DDC can use I2C bus */
+ /* Load I2C if we have the code to use it */
+ if (pMga->i2cInit) {
+ if ( xf86LoadSubModule(pScrn, "i2c") ) {
+ xf86LoaderReqSymLists(i2cSymbols,NULL);
+ } else {
+ /* i2c module not found, we can do without it */
+ pMga->i2cInit = NULL;
+ pMga->I2C = NULL;
+ }
+ }
+#endif /* MGAuseI2C */
+
+ /* Map the MGA memory and MMIO areas */
+ if (!MGAMapMem(pScrn))
+ return NULL;
+
+ /* Initialise the MMIO vgahw functions */
+ vgaHWSetMmioFuncs(hwp, pMga->IOBase, PORT_OFFSET);
+ vgaHWGetIOBase(hwp);
+
+ /* Map the VGA memory when the primary video */
+ if (pMga->Primary) {
+ hwp->MapSize = 0x10000;
+ if (!vgaHWMapMem(pScrn))
+ return NULL;
+ } else {
+ /* XXX Need to write an MGA mode ddc1SetSpeed */
+ if (pMga->DDC1SetSpeed == vgaHWddc1SetSpeed) {
+ pMga->DDC1SetSpeed = NULL;
+ xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
+ "DDC1 disabled - chip not in VGA mode\n");
+ }
+ }
+
+ /* Save the current state */
+ MGASave(pScrn);
+
+ /* It is now safe to talk to the card */
+
+#if MGAuseI2C
+ /* Initialize I2C bus - used by DDC if available */
+ if (pMga->i2cInit) {
+ pMga->i2cInit(pScrn);
+ }
+ /* Read and output monitor info using DDC2 over I2C bus */
+ if (pMga->I2C) {
+ MonInfo = xf86DoEDID_DDC2(pScrn->scrnIndex,pMga->I2C);
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "I2C Monitor info: %p\n", MonInfo);
+ xf86PrintEDID(MonInfo);
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "end of I2C Monitor info\n");
+ }
+ if (!MonInfo)
+#endif /* MGAuseI2C */
+ /* Read and output monitor info using DDC1 */
+ if (pMga->ddc1Read && pMga->DDC1SetSpeed) {
+ MonInfo = xf86DoEDID_DDC1(pScrn->scrnIndex,
+ pMga->DDC1SetSpeed,
+ pMga->ddc1Read ) ;
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "DDC Monitor info: %p\n", MonInfo);
+ xf86PrintEDID( MonInfo );
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "end of DDC Monitor info\n");
+ }
+ if (!MonInfo){
+ vbeInfoPtr pVbe;
+ if (xf86LoadSubModule(pScrn, "vbe")) {
+ pVbe = VBEInit(NULL,pMga->pEnt->index);
+ MonInfo = vbeDoEDID(pVbe, NULL);
+ vbeFree(pVbe);
+
+ if (MonInfo){
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VBE DDC Monitor info: %p\n", MonInfo);
+ xf86PrintEDID( MonInfo );
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "end of VBE DDC Monitor info\n\n");
+ }
+ }
+ }
+
+
+ /* Restore previous state and unmap MGA memory and MMIO areas */
+ MGARestore(pScrn);
+ MGAUnmapMem(pScrn);
+ /* Unmap vga memory if we mapped it */
+ if (xf86IsPrimaryPci(pMga->PciInfo) && !pMga->FBDev) {
+ vgaHWUnmapMem(pScrn);
+ }
+
+ xf86SetDDCproperties(pScrn, MonInfo);
+
+ return MonInfo;
+}
+
+#ifdef DISABLE_VGA_IO
+static void
+VgaIOSave(int i, void *arg)
+{
+ MgaSavePtr sMga = arg;
+ PCITAG tag = pciTag(sMga->pvp->bus,sMga->pvp->device,sMga->pvp->func);
+
+#ifdef DEBUG
+ ErrorF("mga: VgaIOSave: %d:%d:%d\n", sMga->pvp->bus, sMga->pvp->device,
+ sMga->pvp->func);
+#endif
+ sMga->enable = (pciReadLong(tag, PCI_OPTION_REG) & 0x100) != 0;
+}
+
+static void
+VgaIORestore(int i, void *arg)
+{
+ MgaSavePtr sMga = arg;
+ PCITAG tag = pciTag(sMga->pvp->bus,sMga->pvp->device,sMga->pvp->func);
+
+#ifdef DEBUG
+ ErrorF("mga: VgaIORestore: %d:%d:%d\n", sMga->pvp->bus, sMga->pvp->device,
+ sMga->pvp->func);
+#endif
+ pciSetBitsLong(tag, PCI_OPTION_REG, 0x100, sMga->enable ? 0x100 : 0x000);
+}
+
+static void
+VgaIODisable(void *arg)
+{
+ MGAPtr pMga = arg;
+
+#ifdef DEBUG
+ ErrorF("mga: VgaIODisable: %d:%d:%d, %s, xf86ResAccessEnter is %s\n",
+ pMga->PciInfo->bus, pMga->PciInfo->device, pMga->PciInfo->func,
+ pMga->Primary ? "primary" : "secondary",
+ BOOLTOSTRING(xf86ResAccessEnter));
+#endif
+ /* Turn off the vgaioen bit. */
+ pciSetBitsLong(pMga->PciTag, PCI_OPTION_REG, 0x100, 0x000);
+}
+
+static void
+VgaIOEnable(void *arg)
+{
+ MGAPtr pMga = arg;
+
+#ifdef DEBUG
+ ErrorF("mga: VgaIOEnable: %d:%d:%d, %s, xf86ResAccessEnter is %s\n",
+ pMga->PciInfo->bus, pMga->PciInfo->device, pMga->PciInfo->func,
+ pMga->Primary ? "primary" : "secondary",
+ BOOLTOSTRING(xf86ResAccessEnter));
+#endif
+ /* Turn on the vgaioen bit. */
+ if (pMga->Primary)
+ pciSetBitsLong(pMga->PciTag, PCI_OPTION_REG, 0x100, 0x100);
+}
+#endif /* DISABLE_VGA_IO */
+
+void
+MGAProbeDDC(ScrnInfoPtr pScrn, int index)
+{
+ vbeInfoPtr pVbe;
+ if (xf86LoadSubModule(pScrn, "vbe")) {
+ pVbe = VBEInit(NULL,index);
+ ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
+ vbeFree(pVbe);
+ }
+}
+
+/* Mandatory */
+static Bool
+MGAPreInit(ScrnInfoPtr pScrn, int flags)
+{
+ MGAPtr pMga;
+ MessageType from;
+ int i;
+ double real;
+ int bytesPerPixel;
+ ClockRangePtr clockRanges;
+ const char *s;
+ int flags24;
+ MGAEntPtr pMgaEnt = NULL;
+ Bool Default;
+#ifdef USEMGAHAL
+ ULONG status;
+ CARD8 MiscCtlReg;
+#endif
+
+ /*
+ * Note: This function is only called once at server startup, and
+ * not at the start of each server generation. This means that
+ * only things that are persistent across server generations can
+ * be initialised here. xf86Screens[] is (pScrn is a pointer to one
+ * of these). Privates allocated using xf86AllocateScrnInfoPrivateIndex()
+ * are too, and should be used for data that must persist across
+ * server generations.
+ *
+ * Per-generation data should be allocated with
+ * AllocateScreenPrivateIndex() from the ScreenInit() function.
+ */
+
+ /* Check the number of entities, and fail if it isn't one. */
+ if (pScrn->numEntities != 1)
+ return FALSE;
+
+ /* Allocate the MGARec driverPrivate */
+ if (!MGAGetRec(pScrn)) {
+ return FALSE;
+ }
+
+ pMga = MGAPTR(pScrn);
+ /* Set here until dri is enabled */
+#ifdef XF86DRI
+ pMga->haveQuiescense = 1;
+#endif
+ /* Get the entity, and make sure it is PCI. */
+ pMga->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
+ if (pMga->pEnt->location.type != BUS_PCI)
+ return FALSE;
+
+ /* Allocate an entity private if necessary */
+ if (xf86IsEntityShared(pScrn->entityList[0])) {
+ pMgaEnt = xf86GetEntityPrivate(pScrn->entityList[0],
+ MGAEntityIndex)->ptr;
+ pMga->entityPrivate = pMgaEnt;
+ }
+
+ /* Set pMga->device to the relevant Device section */
+ pMga->device = xf86GetDevFromEntity(pScrn->entityList[0],
+ pScrn->entityInstanceList[0]);
+
+ if (flags & PROBE_DETECT) {
+ MGAProbeDDC(pScrn, pMga->pEnt->index);
+ return TRUE;
+ }
+
+ /* The vgahw module should be loaded here when needed */
+ if (!xf86LoadSubModule(pScrn, "vgahw"))
+ return FALSE;
+
+ xf86LoaderReqSymLists(vgahwSymbols, NULL);
+
+ /*
+ * Allocate a vgaHWRec
+ */
+ if (!vgaHWGetHWRec(pScrn))
+ return FALSE;
+
+ /* Find the PCI info for this screen */
+ pMga->PciInfo = xf86GetPciInfoForEntity(pMga->pEnt->index);
+ pMga->PciTag = pciTag(pMga->PciInfo->bus, pMga->PciInfo->device,
+ pMga->PciInfo->func);
+
+ pMga->Primary = xf86IsPrimaryPci(pMga->PciInfo);
+
+#ifndef DISABLE_VGA_IO
+ xf86SetOperatingState(resVgaIo, pMga->pEnt->index, ResUnusedOpr);
+ xf86SetOperatingState(resVgaMem, pMga->pEnt->index, ResDisableOpr);
+#else
+ /*
+ * Set our own access functions, which control the vgaioen bit.
+ */
+ pMga->Access.AccessDisable = VgaIODisable;
+ pMga->Access.AccessEnable = VgaIOEnable;
+ pMga->Access.arg = pMga;
+ /* please check if this is correct. I've impiled that the VGA fb
+ is handled locally and not visible outside. If the VGA fb is
+ handeled by the same function the third argument has to be set,
+ too.*/
+ xf86SetAccessFuncs(pMga->pEnt, &pMga->Access, &pMga->Access,
+ &pMga->Access, NULL);
+#endif
+
+ /* Set pScrn->monitor */
+ pScrn->monitor = pScrn->confScreen->monitor;
+
+ /*
+ * Set the Chipset and ChipRev, allowing config file entries to
+ * override.
+ */
+ if (pMga->device->chipset && *pMga->device->chipset) {
+ pScrn->chipset = pMga->device->chipset;
+ pMga->Chipset = xf86StringToToken(MGAChipsets, pScrn->chipset);
+ from = X_CONFIG;
+ } else if (pMga->device->chipID >= 0) {
+ pMga->Chipset = pMga->device->chipID;
+ pScrn->chipset = (char *)xf86TokenToString(MGAChipsets, pMga->Chipset);
+ from = X_CONFIG;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipID override: 0x%04X\n",
+ pMga->Chipset);
+ } else {
+ from = X_PROBED;
+ pMga->Chipset = pMga->PciInfo->chipType;
+ pScrn->chipset = (char *)xf86TokenToString(MGAChipsets, pMga->Chipset);
+ }
+ if (pMga->device->chipRev >= 0) {
+ pMga->ChipRev = pMga->device->chipRev;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipRev override: %d\n",
+ pMga->ChipRev);
+ } else {
+ pMga->ChipRev = pMga->PciInfo->chipRev;
+ }
+
+ /*
+ * This shouldn't happen because such problems should be caught in
+ * MGAProbe(), but check it just in case.
+ */
+ if (pScrn->chipset == NULL) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "ChipID 0x%04X is not recognised\n", pMga->Chipset);
+ return FALSE;
+ }
+ if (pMga->Chipset < 0) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "Chipset \"%s\" is not recognised\n", pScrn->chipset);
+ return FALSE;
+ }
+
+ xf86DrvMsg(pScrn->scrnIndex, from, "Chipset: \"%s\"", pScrn->chipset);
+ if (pMga->Chipset == PCI_CHIP_MGAG400) {
+ if (pMga->ChipRev >= 0x80)
+ xf86ErrorF(" (G450)\n");
+ else
+ xf86ErrorF(" (G400)\n");
+ } else {
+ xf86ErrorF("\n");
+ }
+#ifdef USEMGAHAL
+ if (HAL_CHIPSETS) {
+ Bool loadHal = TRUE;
+
+ from = X_DEFAULT;
+ if (xf86FindOption(pMga->device->options, "NoHal")) {
+ loadHal = !xf86SetBoolOption(pMga->device->options,
+ "NoHal", !loadHal);
+ from = X_CONFIG;
+ } else if (xf86FindOption(pMga->device->options, "Hal")) {
+ loadHal = xf86SetBoolOption(pMga->device->options,
+ "Hal", loadHal);
+ from = X_CONFIG;
+ }
+ if (loadHal && xf86LoadSubModule(pScrn, "mga_hal")) {
+ xf86LoaderReqSymLists(halSymbols, NULL);
+ xf86DrvMsg(pScrn->scrnIndex, from,"Matrox HAL module used\n");
+ pMga->HALLoaded = TRUE;
+ } else {
+ xf86DrvMsg(pScrn->scrnIndex, from, "Matrox HAL module not loaded "
+ "- using builtin mode setup instead\n");
+ pMga->HALLoaded = FALSE;
+ }
+ }
+#endif
+
+ pMga->DualHeadEnabled = FALSE;
+ if (xf86IsEntityShared(pScrn->entityList[0])) {/* dual-head mode requested*/
+#ifdef USEMGAHAL
+ if (pMga->HALLoaded || !MGA_DH_NEEDS_HAL(pMga)) {
+#else
+ if (!MGA_DH_NEEDS_HAL(pMga)) {
+#endif
+ pMga->DualHeadEnabled = TRUE;
+ } else if (xf86IsPrimInitDone(pScrn->entityList[0])) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "This card requires the \"mga_hal\" module for dual-head operation\n"
+ "\tIt can be found at the Matrox web site <http://www.matrox.com>\n");
+ }
+ }
+
+ /*
+ * In case of DualHead, we need to determine if we are the 'master' head
+ * or the 'slave' head. In order to do that, at the end of the first
+ * initialisation, PrimInit is set as DONE to the shared entity. So that
+ * the second initialisation knows that something has been done before it.
+ * This always assume that the first device initialised is the master
+ * head, and the second the slave.
+ *
+ */
+ if (xf86IsEntityShared(pScrn->entityList[0])) { /* dual-head mode */
+ if (!xf86IsPrimInitDone(pScrn->entityList[0])) { /* Is it the first initialisation? */
+ /* First CRTC */
+ pMga->SecondCrtc = FALSE;
+ pMga->HWCursor = TRUE;
+ pMgaEnt->pScrn_1 = pScrn;
+ } else if (pMga->DualHeadEnabled) {
+ /* Second CRTC */
+ pMga->SecondCrtc = TRUE;
+ pMga->HWCursor = FALSE;
+ pMgaEnt->pScrn_2 = pScrn;
+ pScrn->AdjustFrame = MGAAdjustFrameCrtc2;
+ /*
+ * Fail initialization of second head if we are in MergeFB mode,
+ * since we do it ourselfs.
+ */
+ if(pMgaEnt->pScrn_1 && MGAPTR(pMgaEnt->pScrn_1)->MergedFB) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "Primary head in Merged framebuffer mode. \n"
+ "Don't let Xfree try to manage the second head.\n"
+ "Remove the second screen in the \"ServerLayout\"\n"
+ "Section of the config file.");
+ return FALSE;
+ }
+ } else {
+ return FALSE;
+ }
+ }
+
+ if (pMga->DualHeadEnabled) {
+#ifdef XF86DRI
+ pMga->GetQuiescence = MGAGetQuiescenceShared;
+#endif
+ } else { /* single-head mode */
+ pMga->SecondCrtc = FALSE;
+ pMga->HWCursor = TRUE;
+#ifdef XF86DRI
+ pMga->GetQuiescence = MGAGetQuiescence;
+#endif
+ }
+
+
+
+ /*
+ * The first thing we should figure out is the depth, bpp, etc.
+ * Our default depth is 8, so pass it to the helper function.
+ * We support both 24bpp and 32bpp layouts, so indicate that.
+ */
+
+ /* Prefer 24bpp fb unless the Overlay option is set, or DRI is
+ * supported.
+ */
+ flags24 = Support24bppFb | Support32bppFb | SupportConvert32to24;
+ s = xf86TokenToOptName(MGAOptions, OPTION_OVERLAY);
+#ifndef XF86DRI
+ if (!(xf86FindOption(pScrn->confScreen->options, s) ||
+ xf86FindOption(pMga->device->options, s))) {
+ flags24 |= PreferConvert32to24;
+ }
+#endif
+
+ if (pMga->SecondCrtc)
+ flags24 = Support32bppFb;
+
+ if (!xf86SetDepthBpp(pScrn, 8, 8, 8, flags24)) {
+ return FALSE;
+ } else {
+ /* Check that the returned depth is one we support */
+ switch (pScrn->depth) {
+ case 8:
+ case 15:
+ case 16:
+ case 24:
+ /* OK */
+ break;
+ default:
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "Given depth (%d) is not supported by this driver\n",
+ pScrn->depth);
+ return FALSE;
+ }
+ }
+ xf86PrintDepthBpp(pScrn);
+
+ /*
+ * This must happen after pScrn->display has been set because
+ * xf86SetWeight references it.
+ */
+ if (pScrn->depth > 8) {
+ /* The defaults are OK for us */
+ rgb zeros = {0, 0, 0};
+
+ if (!xf86SetWeight(pScrn, zeros, zeros)) {
+ return FALSE;
+ } else {
+ /* XXX check that weight returned is supported */
+ ;
+ }
+ }
+
+ bytesPerPixel = pScrn->bitsPerPixel / 8;
+
+ /* We use a programmable clock */
+ pScrn->progClock = TRUE;
+
+ /* Collect all of the relevant option flags (fill in pScrn->options) */
+ xf86CollectOptions(pScrn, NULL);
+
+ /* Process the options */
+ if (!(pMga->Options = xalloc(sizeof(MGAOptions))))
+ return FALSE;
+ memcpy(pMga->Options, MGAOptions, sizeof(MGAOptions));
+ xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pMga->Options);
+
+
+#if !defined(__powerpc__)
+ pMga->softbooted = FALSE;
+ if (pMga->Chipset >= PCI_CHIP_MGAG400
+ && !pMga->Primary
+ && !pMga->SecondCrtc)
+ Default = TRUE;
+ else
+ Default = FALSE;
+ if (xf86ReturnOptValBool(pMga->Options, OPTION_INT10, Default) &&
+ xf86LoadSubModule(pScrn, "int10")) {
+ xf86Int10InfoPtr pInt;
+
+ xf86LoaderReqSymLists(int10Symbols, NULL);
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Initializing int10\n");
+ pInt = xf86InitInt10(pMga->pEnt->index);
+ if (pInt) pMga->softbooted = TRUE;
+ xf86FreeInt10(pInt);
+ }
+#endif
+
+ /* Set the bits per RGB for 8bpp mode */
+ if (pScrn->depth == 8)
+ pScrn->rgbBits = 8;
+
+#ifdef XF86DRI
+ from = X_DEFAULT;
+ pMga->agpMode = MGA_DEFAULT_AGP_MODE;
+
+ if (xf86GetOptValInteger(pMga->Options,
+ OPTION_AGP_MODE, &(pMga->agpMode))) {
+ if (pMga->agpMode < 1) {
+ pMga->agpMode = 1;
+ }
+ if (pMga->agpMode > MGA_MAX_AGP_MODE) {
+ pMga->agpMode = MGA_MAX_AGP_MODE;
+ }
+ from = X_CONFIG;
+ }
+ if (xf86GetOptValInteger(pMga->Options,
+ OPTION_AGP_SIZE, &(pMga->agpSize))) {
+ /* check later */
+ xf86DrvMsg(pScrn->scrnIndex, from, "Using %d MB of AGP memory\n",
+ pMga->agpSize);
+ }
+
+ xf86DrvMsg(pScrn->scrnIndex, from, "Using AGP %dx mode\n",
+ pMga->agpMode);
+#endif
+
+ from = X_DEFAULT;
+
+ /*
+ * The preferred method is to use the "hw cursor" option as a tri-state
+ * option, with the default set above.
+ */
+ if (xf86GetOptValBool(pMga->Options, OPTION_HW_CURSOR, &pMga->HWCursor)) {
+ from = X_CONFIG;
+ }
+
+ /* For compatibility, accept this too (as an override) */
+ if (xf86ReturnOptValBool(pMga->Options, OPTION_NOACCEL, FALSE)) {
+ pMga->NoAccel = TRUE;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Acceleration disabled\n");
+ }
+ if (xf86ReturnOptValBool(pMga->Options, OPTION_PCI_RETRY, FALSE)) {
+ pMga->UsePCIRetry = TRUE;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "PCI retry enabled\n");
+ }
+ if (xf86ReturnOptValBool(pMga->Options, OPTION_SYNC_ON_GREEN, FALSE)) {
+ pMga->SyncOnGreen = TRUE;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Sync-on-Green enabled\n");
+ }
+ if (xf86ReturnOptValBool(pMga->Options, OPTION_SHOWCACHE, FALSE)) {
+ pMga->ShowCache = TRUE;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ShowCache enabled\n");
+ }
+ if (xf86ReturnOptValBool(pMga->Options, OPTION_MGA_SDRAM, FALSE)) {
+ pMga->HasSDRAM = TRUE;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Has SDRAM\n");
+ }
+ if (xf86GetOptValFreq(pMga->Options, OPTION_SET_MCLK, OPTUNITS_MHZ, &real)) {
+ pMga->MemClk = (int)(real * 1000.0);
+ }
+ if ((s = xf86GetOptValString(pMga->Options, OPTION_OVERLAY))) {
+ if (!*s || !xf86NameCmp(s, "8,24") || !xf86NameCmp(s, "24,8")) {
+ if(pScrn->bitsPerPixel == 32 && pMga->SecondCrtc == FALSE) {
+ pMga->Overlay8Plus24 = TRUE;
+ if(!xf86GetOptValInteger(
+ pMga->Options, OPTION_COLOR_KEY,&(pMga->colorKey)))
+ pMga->colorKey = TRANSPARENCY_KEY;
+ pScrn->colorKey = pMga->colorKey;
+ pScrn->overlayFlags = OVERLAY_8_32_PLANAR;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "PseudoColor overlay enabled\n");
+ } else {
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Option \"Overlay\" is only supported in 32 bits per pixel on"
+ "the first CRTC\n");
+ }
+ } else {
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "\"%s\" is not a valid value for Option \"Overlay\"\n", s);
+ }
+ }
+
+ if(xf86GetOptValInteger(pMga->Options, OPTION_VIDEO_KEY, &(pMga->videoKey))) {
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "video key set to 0x%x\n",
+ pMga->videoKey);
+ } else {
+ pMga->videoKey = (1 << pScrn->offset.red) |
+ (1 << pScrn->offset.green) |
+ (((pScrn->mask.blue >> pScrn->offset.blue) - 1) << pScrn->offset.blue);
+ }
+ if (xf86ReturnOptValBool(pMga->Options, OPTION_SHADOW_FB, FALSE)) {
+ pMga->ShadowFB = TRUE;
+ pMga->NoAccel = TRUE;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Using \"Shadow Framebuffer\" - acceleration disabled\n");
+ }
+ if (xf86ReturnOptValBool(pMga->Options, OPTION_FBDEV, FALSE)) {
+ pMga->FBDev = TRUE;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Using framebuffer device\n");
+ }
+ if (xf86ReturnOptValBool(pMga->Options, OPTION_OVERCLOCK_MEM, FALSE)) {
+ pMga->OverclockMem = TRUE;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Overclocking memory\n");
+ }
+ if (xf86ReturnOptValBool(pMga->Options, OPTION_TEXTURED_VIDEO, FALSE)) {
+ pMga->TexturedVideo = TRUE;
+ }
+ if (xf86ReturnOptValBool(pMga->Options, OPTION_MERGEDFB, FALSE)) {
+ if(!MGAISGx50(pMga)) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "\"Merged Framebuffer\" mode only supported on G450 and G550 boards.\n");
+ } else {
+#ifdef USEMGAHAL
+ if(pMga->HALLoaded)
+ {
+ pMga->MergedFB = TRUE;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Using \"Merged Framebuffer\" mode.\n");
+ /*
+ * a few options that won't work well together
+ */
+ if(pMga->HWCursor) /*Should we give the choice? */
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ " -- Hardware Cursor disabled.\n");
+ pMga->HWCursor = FALSE;
+ if(pMga->ShadowFB)
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ " -- Shadow Framebuffer disabled.\n");
+ pMga->ShadowFB = FALSE;
+ if(pMga->FBDev)
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ " -- Framebuffer device disabled.\n");
+ pMga->FBDev = FALSE;
+ } /* MGA_HAL */
+ else
+#endif
+ {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "HALLib not loaded! NOT using \"Merged Framebuffer\" mode.\n");
+ } /* MGA_NOT_HAL */
+ } /* ISMGAGx50() */
+ }
+ if (pMga->FBDev) {
+ /* check for linux framebuffer device */
+ if (!xf86LoadSubModule(pScrn, "fbdevhw"))
+ return FALSE;
+ xf86LoaderReqSymLists(fbdevHWSymbols, NULL);
+ if (!fbdevHWInit(pScrn, pMga->PciInfo, NULL))
+ return FALSE;
+ pScrn->SwitchMode = fbdevHWSwitchMode;
+ pScrn->AdjustFrame = fbdevHWAdjustFrame;
+ pScrn->EnterVT = MGAEnterVTFBDev;
+ pScrn->LeaveVT = fbdevHWLeaveVT;
+ pScrn->ValidMode = fbdevHWValidMode;
+ }
+ pMga->Rotate = 0;
+ if ((s = xf86GetOptValString(pMga->Options, OPTION_ROTATE))) {
+ if(!pMga->MergedFB) {
+ if(!xf86NameCmp(s, "CW")) {
+ pMga->ShadowFB = TRUE;
+ pMga->NoAccel = TRUE;
+ pMga->HWCursor = FALSE;
+ pMga->Rotate = 1;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Rotating screen clockwise - acceleration disabled\n");
+ } else
+ if(!xf86NameCmp(s, "CCW")) {
+ pMga->ShadowFB = TRUE;
+ pMga->NoAccel = TRUE;
+ pMga->HWCursor = FALSE;
+ pMga->Rotate = -1;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Rotating screen counter clockwise - acceleration disabled\n");
+ } else {
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "\"%s\" is not a valid value for Option \"Rotate\"\n", s);
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "Valid options are \"CW\" or \"CCW\"\n");
+ }
+ } else {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ " -- Rotation disabled.\n");
+ }
+ }
+
+ switch (pMga->Chipset) {
+ case PCI_CHIP_MGA2064:
+ case PCI_CHIP_MGA2164:
+ case PCI_CHIP_MGA2164_AGP:
+ MGA2064SetupFuncs(pScrn);
+ break;
+ case PCI_CHIP_MGA1064:
+ case PCI_CHIP_MGAG100:
+ case PCI_CHIP_MGAG100_PCI:
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG550:
+ MGAGSetupFuncs(pScrn);
+ break;
+ }
+
+ /* ajv changes to reflect actual values. see sdk pp 3-2. */
+ /* these masks just get rid of the crap in the lower bits */
+
+ /*
+ * For the 2064 and older rev 1064, base0 is the MMIO and base0 is
+ * the framebuffer is base1. Let the config file override these.
+ */
+ if (pMga->device->MemBase != 0) {
+ /* Require that the config file value matches one of the PCI values. */
+ if (!xf86CheckPciMemBase(pMga->PciInfo, pMga->device->MemBase)) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "MemBase 0x%08lX doesn't match any PCI base register.\n",
+ pMga->device->MemBase);
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+ pMga->FbAddress = pMga->device->MemBase;
+ from = X_CONFIG;
+ } else {
+ /* details: mgabase2 sdk pp 4-12 */
+ int i = ((pMga->Chipset == PCI_CHIP_MGA1064 && pMga->ChipRev < 3) ||
+ pMga->Chipset == PCI_CHIP_MGA2064) ? 1 : 0;
+ pMga->FbBaseReg = i;
+ if (pMga->PciInfo->memBase[i] != 0) {
+ pMga->FbAddress = pMga->PciInfo->memBase[i] & 0xff800000;
+ from = X_PROBED;
+ } else {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "No valid FB address in PCI config space\n");
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+ }
+
+ xf86DrvMsg(pScrn->scrnIndex, from, "Linear framebuffer at 0x%lX\n",
+ (unsigned long)pMga->FbAddress);
+
+#if !defined(__powerpc__)
+ if (pMga->device->IOBase != 0) {
+ /* Require that the config file value matches one of the PCI values. */
+ if (!xf86CheckPciMemBase(pMga->PciInfo, pMga->device->IOBase)) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "IOBase 0x%08lX doesn't match any PCI base register.\n",
+ pMga->device->IOBase);
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+ pMga->IOAddress = pMga->device->IOBase;
+ from = X_CONFIG;
+ } else {
+ /* details: mgabase1 sdk pp 4-11 */
+ int i = ((pMga->Chipset == PCI_CHIP_MGA1064 && pMga->ChipRev < 3) ||
+ pMga->Chipset == PCI_CHIP_MGA2064) ? 0 : 1;
+ if (pMga->PciInfo->memBase[i] != 0) {
+ pMga->IOAddress = pMga->PciInfo->memBase[i] & 0xffffc000;
+ from = X_PROBED;
+ } else {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "No valid MMIO address in PCI config space\n");
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+ }
+#else
+ pMga->IOAddress = pMga->PciInfo->memBase[0];
+#endif
+ xf86DrvMsg(pScrn->scrnIndex, from, "MMIO registers at 0x%lX\n",
+ (unsigned long)pMga->IOAddress);
+
+
+ pMga->ILOADAddress = 0;
+ if ( pMga->Chipset != PCI_CHIP_MGA2064 ) {
+ if (pMga->PciInfo->memBase[2] != 0) {
+ pMga->ILOADAddress = pMga->PciInfo->memBase[2] & 0xffffc000;
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+ "Pseudo-DMA transfer window at 0x%lX\n",
+ (unsigned long)pMga->ILOADAddress);
+ }
+ }
+
+#if !defined(__powerpc__)
+ /*
+ * Find the BIOS base. Get it from the PCI config if possible. Otherwise
+ * use the VGA default. Allow the config file to override this.
+ */
+
+ pMga->BiosFrom = X_NONE;
+ if (pMga->device->BiosBase != 0) {
+ /* XXX This isn't used */
+ pMga->BiosAddress = pMga->device->BiosBase;
+ pMga->BiosFrom = X_CONFIG;
+ } else {
+ /* details: rombase sdk pp 4-15 */
+ if (pMga->PciInfo->biosBase != 0) {
+ pMga->BiosAddress = pMga->PciInfo->biosBase & 0xffff0000;
+ pMga->BiosFrom = X_PROBED;
+ } else if (pMga->Primary) {
+ pMga->BiosAddress = 0xc0000;
+ pMga->BiosFrom = X_DEFAULT;
+ }
+ }
+ if (pMga->BiosAddress) {
+ xf86DrvMsg(pScrn->scrnIndex, pMga->BiosFrom, "BIOS at 0x%lX\n",
+ (unsigned long)pMga->BiosAddress);
+ }
+
+ if (xf86RegisterResources(pMga->pEnt->index, NULL, ResExclusive)) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "xf86RegisterResources() found resource conflicts\n");
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+
+ /*
+ * Read the BIOS data struct
+ */
+
+#if defined(__alpha__)
+ /*
+ * Some old Digital-OEMed Matrox Millennium I cards have a VGA
+ * disable switch. If the disable is on, we can't read the BIOS,
+ * and pMga->BiosAddress = 0x0. The disable switch is needed to
+ * allow multi-head operation with brain-dead console code... ;-}
+ */
+
+ if ((pMga->BiosAddress == 0) && !xf86IsPrimaryPci(pMga->PciInfo))
+ xf86DrvMsg(pScrn->scrnIndex, pMga->BiosFrom,
+ "BIOS not found, skipping read\n");
+ else
+#endif
+ MGAReadBios(pScrn);
+
+ /* Since the BIOS can swap DACs during the initialisation of G550, we need to
+ * store which DAC this instance of the driver is taking care of. This is done
+ * by checking a flag stored in the ROM by the BIOS at a fixed address. */
+
+ if (!pMga->SecondCrtc)
+ pMga->SecondOutput = FALSE;
+ else
+ pMga->SecondOutput = TRUE;
+
+ if (pMga->Chipset == PCI_CHIP_MGAG550) {
+ if (!pMga->SecondCrtc) {
+ pMga->SecondOutput = (pMga->BiosOutputMode & 0x1) ? TRUE : FALSE;
+ } else {
+ pMga->SecondOutput = (pMga->BiosOutputMode & 0x1) ? FALSE : TRUE;
+ }
+ }
+
+ xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
+ "MGABios.RamdacType = 0x%x\n", pMga->Bios.RamdacType);
+#endif /* !__powerpc__ */
+
+ /* HW bpp matches reported bpp */
+ pMga->HwBpp = pScrn->bitsPerPixel;
+
+ /*
+ * Reset card if it isn't primary one
+ */
+ if ( (!pMga->Primary && !pMga->FBDev) || xf86IsPc98() )
+ MGASoftReset(pScrn);
+
+ /*
+ * If the user has specified the amount of memory in the XF86Config
+ * file, we respect that setting.
+ */
+ from = X_PROBED;
+ if (pMga->device->videoRam != 0) {
+ pScrn->videoRam = pMga->device->videoRam;
+ from = X_CONFIG;
+ } else if (pMga->FBDev) {
+ pScrn->videoRam = fbdevHWGetVidmem(pScrn)/1024;
+ } else {
+ pScrn->videoRam = MGACountRam(pScrn);
+ }
+
+ if (pMga->DualHeadEnabled) {
+ /* This takes gives either half or 8 meg to the second head
+ * whichever is less. */
+ if(pMga->SecondCrtc == FALSE) {
+ Bool UseHalf = FALSE;
+ int adjust;
+
+ xf86GetOptValBool(pMga->Options, OPTION_CRTC2HALF, &UseHalf);
+ adjust = pScrn->videoRam / 2;
+
+ if (UseHalf == TRUE ||
+ xf86GetOptValInteger(pMga->Options, OPTION_CRTC2RAM, &adjust)) {
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Crtc2 will use %dK of VideoRam\n",
+ adjust);
+ } else {
+ adjust = min(adjust, 8192);
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+ "Crtc2 will use %dK of VideoRam\n",
+ adjust);
+ }
+ pMgaEnt->mastervideoRam = pScrn->videoRam - adjust;
+ pScrn->videoRam = pMgaEnt->mastervideoRam;
+ pMgaEnt->slavevideoRam = adjust;
+ pMgaEnt->masterFbAddress = pMga->FbAddress;
+ pMga->FbMapSize =
+ pMgaEnt->masterFbMapSize = pScrn->videoRam * 1024;
+ pMgaEnt->slaveFbAddress = pMga->FbAddress +
+ pMgaEnt->masterFbMapSize;
+ pMgaEnt->slaveFbMapSize = pMgaEnt->slavevideoRam * 1024;
+ pMga->realSrcOrg = pMga->SrcOrg = 0;
+ pMga->DstOrg = 0;
+ } else {
+ pMga->FbAddress = pMgaEnt->slaveFbAddress;
+ pMga->FbMapSize = pMgaEnt->slaveFbMapSize;
+ pScrn->videoRam = pMgaEnt->slavevideoRam;
+ pMga->DstOrg = pMga->realSrcOrg =
+ pMgaEnt->slaveFbAddress - pMgaEnt->masterFbAddress;
+ pMga->SrcOrg = 0; /* This is not stored in hw format!! */
+ }
+ pMgaEnt->refCount++;
+ } else {
+ /* Normal Handling of video ram etc */
+ pMga->FbMapSize = pScrn->videoRam * 1024;
+ switch(pMga->Chipset) {
+ case PCI_CHIP_MGAG550:
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ pMga->SrcOrg = 0;
+ pMga->DstOrg = 0;
+ break;
+ default:
+ break;
+ }
+ }
+ xf86DrvMsg(pScrn->scrnIndex, from, "VideoRAM: %d kByte\n",
+ pScrn->videoRam);
+
+ /* Set the bpp shift value */
+ pMga->BppShifts[0] = 0;
+ pMga->BppShifts[1] = 1;
+ pMga->BppShifts[2] = 0;
+ pMga->BppShifts[3] = 2;
+
+ /*
+ * fill MGAdac struct
+ * Warning: currently, it should be after RAM counting
+ */
+ (*pMga->PreInit)(pScrn);
+
+#if !defined(__powerpc__)
+
+ /* Read and print the Monitor DDC info */
+ pScrn->monitor->DDC = MGAdoDDC(pScrn);
+#endif /* !__powerpc__ */
+
+ /*
+ * If the driver can do gamma correction, it should call xf86SetGamma()
+ * here.
+ */
+
+ {
+ Gamma zeros = {0.0, 0.0, 0.0};
+
+ if (!xf86SetGamma(pScrn, zeros)) {
+ return FALSE;
+ }
+ }
+
+
+ /* XXX Set HW cursor use */
+
+ /* Set the min pixel clock */
+ pMga->MinClock = 12000; /* XXX Guess, need to check this */
+ xf86DrvMsg(pScrn->scrnIndex, X_DEFAULT, "Min pixel clock is %d MHz\n",
+ pMga->MinClock / 1000);
+ /*
+ * If the user has specified ramdac speed in the XF86Config
+ * file, we respect that setting.
+ */
+ if (pMga->device->dacSpeeds[0]) {
+ int speed = 0;
+
+ switch (pScrn->bitsPerPixel) {
+ case 8:
+ speed = pMga->device->dacSpeeds[DAC_BPP8];
+ break;
+ case 16:
+ speed = pMga->device->dacSpeeds[DAC_BPP16];
+ break;
+ case 24:
+ speed = pMga->device->dacSpeeds[DAC_BPP24];
+ break;
+ case 32:
+ speed = pMga->device->dacSpeeds[DAC_BPP32];
+ break;
+ }
+ if (speed == 0)
+ pMga->MaxClock = pMga->device->dacSpeeds[0];
+ else
+ pMga->MaxClock = speed;
+ from = X_CONFIG;
+ } else {
+ pMga->MaxClock = pMga->Dac.maxPixelClock;
+ from = pMga->Dac.ClockFrom;
+ }
+ if(pMga->SecondCrtc == TRUE) {
+ /* Override on 2nd crtc */
+ if ((pMga->ChipRev >= 0x80) || (pMga->Chipset == PCI_CHIP_MGAG550)) {
+ /* G450, G550 */
+ pMga->MaxClock = 234000;
+ } else {
+ pMga->MaxClock = 135000;
+ }
+ }
+ xf86DrvMsg(pScrn->scrnIndex, from, "Max pixel clock is %d MHz\n",
+ pMga->MaxClock / 1000);
+ /*
+ * Setup the ClockRanges, which describe what clock ranges are available,
+ * and what sort of modes they can be used for.
+ */
+ clockRanges = xnfcalloc(sizeof(ClockRange), 1);
+ clockRanges->next = NULL;
+ clockRanges->minClock = pMga->MinClock;
+ clockRanges->maxClock = pMga->MaxClock;
+ clockRanges->clockIndex = -1; /* programmable */
+ clockRanges->interlaceAllowed = TRUE;
+ clockRanges->doubleScanAllowed = TRUE;
+#ifdef USEMGAHAL
+ MGA_HAL(clockRanges->interlaceAllowed = FALSE);
+ MGA_HAL(clockRanges->doubleScanAllowed = FALSE);
+#endif
+ if (pMga->SecondCrtc == TRUE)
+ clockRanges->interlaceAllowed = FALSE;
+
+ clockRanges->ClockMulFactor = 1;
+ clockRanges->ClockDivFactor = 1;
+
+ /* Only set MemClk if appropriate for the ramdac */
+ if (pMga->Dac.SetMemClk) {
+ if (pMga->MemClk == 0) {
+ pMga->MemClk = pMga->Dac.MemoryClock;
+ from = pMga->Dac.MemClkFrom;
+ } else
+ from = X_CONFIG;
+ xf86DrvMsg(pScrn->scrnIndex, from, "MCLK used is %.1f MHz\n",
+ pMga->MemClk / 1000.0);
+ }
+
+ /*
+ * xf86ValidateModes will check that the mode HTotal and VTotal values
+ * don't exceed the chipset's limit if pScrn->maxHValue and
+ * pScrn->maxVValue are set. Since our MGAValidMode() already takes
+ * care of this, we don't worry about setting them here.
+ */
+ {
+ int Pitches1[] =
+ {640, 768, 800, 960, 1024, 1152, 1280, 1600, 1920, 2048, 0};
+ int Pitches2[] =
+ {512, 640, 768, 800, 832, 960, 1024, 1152, 1280, 1600, 1664,
+ 1920, 2048, 0};
+ int *linePitches = NULL;
+ int minPitch = 256;
+ int maxPitch = 2048;
+
+ switch(pMga->Chipset) {
+ case PCI_CHIP_MGA2064:
+ if (!pMga->NoAccel) {
+ linePitches = xalloc(sizeof(Pitches1));
+ memcpy(linePitches, Pitches1, sizeof(Pitches1));
+ minPitch = maxPitch = 0;
+ }
+ break;
+ case PCI_CHIP_MGA2164:
+ case PCI_CHIP_MGA2164_AGP:
+ case PCI_CHIP_MGA1064:
+ if (!pMga->NoAccel) {
+ linePitches = xalloc(sizeof(Pitches2));
+ memcpy(linePitches, Pitches2, sizeof(Pitches2));
+ minPitch = maxPitch = 0;
+ }
+ break;
+ case PCI_CHIP_MGAG100:
+ case PCI_CHIP_MGAG100_PCI:
+ maxPitch = 2048;
+ break;
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG550:
+ maxPitch = 4096;
+ break;
+ }
+
+ i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
+ pScrn->display->modes, clockRanges,
+ linePitches, minPitch, maxPitch,
+ pMga->Roundings[(pScrn->bitsPerPixel >> 3) - 1] *
+ pScrn->bitsPerPixel, 128, 2048,
+ pScrn->display->virtualX,
+ pScrn->display->virtualY,
+ pMga->FbMapSize,
+ LOOKUP_BEST_REFRESH);
+
+ if (linePitches)
+ xfree(linePitches);
+ }
+
+
+ if (i < 1 && pMga->FBDev) {
+ fbdevHWUseBuildinMode(pScrn);
+ pScrn->displayWidth = pScrn->virtualX; /* FIXME: might be wrong */
+ i = 1;
+ }
+ if (i == -1) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Validate Modes Failed\n");
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+
+ /* Prune the modes marked as invalid */
+ xf86PruneDriverModes(pScrn);
+
+ if (i == 0 || pScrn->modes == NULL) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+#ifdef USEMGAHAL
+ MGA_HAL(
+
+ if(pMga->SecondCrtc == FALSE) {
+
+ pMga->pBoard = xalloc(sizeof(CLIENTDATA) + MGAGetBOARDHANDLESize());
+ pMga->pClientStruct = xalloc(sizeof(CLIENTDATA));
+ pMga->pClientStruct->pMga = (MGAPtr) pMga;
+
+ MGAMapMem(pScrn);
+ /*
+ * For some reason the MGAOPM_DMA_BLIT bit needs to be set
+ * on G200 before opening the HALlib. I don't know why.
+ * MATROX: hint, hint.
+ */
+ /*if (pMga->Chipset == PCI_CHIP_MGAG200 ||
+ pMga->Chipset == PCI_CHIP_MGAG200_PCI) */{
+ CARD32 opmode;
+ opmode = INREG(MGAREG_OPMODE);
+ OUTREG(MGAREG_OPMODE, MGAOPM_DMA_BLIT | opmode);
+ }
+ /* wrapping OpenLibrary to fix broken registers. MATROX: hint, hint. */
+ MiscCtlReg = inMGAdac(MGA1064_MISC_CTL);
+ MGAOpenLibrary(pMga->pBoard,pMga->pClientStruct,sizeof(CLIENTDATA));
+ outMGAdac(MGA1064_MISC_CTL,MiscCtlReg);
+ MGAUnmapMem(pScrn);
+ pMga->pMgaHwInfo = xalloc(sizeof(MGAHWINFO));
+ MGAGetHardwareInfo(pMga->pBoard,pMga->pMgaHwInfo);
+
+ /* copy the board handles */
+ if (pMga->DualHeadEnabled) {
+ pMgaEnt->pClientStruct = pMga->pClientStruct;
+ pMgaEnt->pBoard = pMga->pBoard;
+ pMgaEnt->pMgaHwInfo = pMga->pMgaHwInfo;
+ }
+
+ } else { /* Second CRTC && entity is shared */
+ pMga->pBoard = pMgaEnt->pBoard;
+ pMga->pClientStruct = pMgaEnt->pClientStruct;
+ pMga->pMgaHwInfo = pMgaEnt->pMgaHwInfo;
+
+ }
+
+ MGAFillModeInfoStruct(pScrn,NULL);
+ /* Fields usually handled by MGAFillModeInfoStruct, but are unavailable
+ * because no mode is given
+ */
+ pMga->pMgaModeInfo->ulDispWidth = pScrn->virtualX;
+ pMga->pMgaModeInfo->ulDispHeight = pScrn->virtualY;
+
+
+ if (ISDIGITAL1(pMga))
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "Digital screen detected on first head.\n");
+ if (ISTV1(pMga))
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "TV detected on first head.\n");
+ if (ISDIGITAL2(pMga))
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "Digital screen detected on second head.\n");
+ if (ISTV2(pMga))
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "TV detected on second head.\n");
+
+
+ if((status = MGAValidateMode(pMga->pBoard,pMga->pMgaModeInfo)) != 0) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "MGAValidateMode from HALlib found the mode to be invalid.\n"
+ "\tError: 0x%lx\n", status);
+ return FALSE;
+ }
+ pScrn->displayWidth = pMga->pMgaModeInfo->ulFBPitch;
+ ); /* MGA_HAL */
+#endif
+
+ if (pMga->HasSDRAM) { /* don't bother checking */ }
+ else if ((pMga->PciInfo->subsysCard == PCI_CARD_MILL_G200_SD) ||
+ (pMga->PciInfo->subsysCard == PCI_CARD_MARV_G200_SD) ||
+ (pMga->PciInfo->subsysCard == PCI_CARD_MYST_G200_SD) ||
+ (pMga->PciInfo->subsysCard == PCI_CARD_PROD_G100_SD)) {
+ pMga->HasSDRAM = TRUE;
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "Has SDRAM\n");
+ }
+ /*
+ * Can we trust HALlib to set the memory configuration
+ * registers correctly?
+ */
+#ifdef USEMGAHAL
+ else if ((pMga->softbooted || pMga->Primary /*|| pMga->HALLoaded*/ ) &&
+#else
+ else if ((pMga->softbooted || pMga->Primary) &&
+#endif
+ (pMga->Chipset != PCI_CHIP_MGA2064) &&
+ (pMga->Chipset != PCI_CHIP_MGA2164) &&
+ (pMga->Chipset != PCI_CHIP_MGA2164_AGP)) {
+ CARD32 option_reg = pciReadLong(pMga->PciTag, PCI_OPTION_REG);
+ if(!(option_reg & (1 << 14))) {
+ pMga->HasSDRAM = TRUE;
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "Has SDRAM\n");
+ }
+ }
+
+ /*
+ * Set the CRTC parameters for all of the modes based on the type
+ * of mode, and the chipset's interlace requirements.
+ *
+ * Calling this is required if the mode->Crtc* values are used by the
+ * driver and if the driver doesn't provide code to set them. They
+ * are not pre-initialised at all.
+ */
+#ifdef USEMGAHAL
+ MGA_HAL(xf86SetCrtcForModes(pScrn, 0));
+#endif
+ MGA_NOT_HAL(xf86SetCrtcForModes(pScrn, INTERLACE_HALVE_V));
+
+ /* Set the current mode to the first in the list */
+ pScrn->currentMode = pScrn->modes;
+
+ /* Print the list of modes being used */
+ xf86PrintModes(pScrn);
+
+ /* Set display resolution */
+ xf86SetDpi(pScrn, 0, 0);
+
+ /*
+ * Compute the byte offset into the linear frame buffer where the
+ * frame buffer data should actually begin. According to DDK misc.c
+ * line 1023, if more than 4MB is to be displayed, YDSTORG must be set
+ * appropriately to align memory bank switching, and this requires a
+ * corresponding offset on linear frame buffer access.
+ * This is only needed for WRAM.
+ */
+
+ pMga->YDstOrg = 0;
+ if (((pMga->Chipset == PCI_CHIP_MGA2064) ||
+ (pMga->Chipset == PCI_CHIP_MGA2164) ||
+ (pMga->Chipset == PCI_CHIP_MGA2164_AGP)) &&
+ (pScrn->virtualX * pScrn->virtualY * bytesPerPixel > 4*1024*1024))
+ {
+ int offset, offset_modulo, ydstorg_modulo;
+
+ offset = (4*1024*1024) % (pScrn->displayWidth * bytesPerPixel);
+ offset_modulo = 4;
+ ydstorg_modulo = 64;
+ if (pScrn->bitsPerPixel == 24)
+ offset_modulo *= 3;
+ if (pMga->Interleave)
+ {
+ offset_modulo <<= 1;
+ ydstorg_modulo <<= 1;
+ }
+ pMga->YDstOrg = offset / bytesPerPixel;
+
+ /*
+ * When this was unconditional, it caused a line of horizontal garbage
+ * at the middle right of the screen at the 4Meg boundary in 32bpp
+ * (and presumably any other modes that use more than 4M). But it's
+ * essential for 24bpp (it may not matter either way for 8bpp & 16bpp,
+ * I'm not sure; I didn't notice problems when I checked with and
+ * without.)
+ * DRM Doug Merritt 12/97, submitted to XFree86 6/98 (oops)
+ */
+ if (bytesPerPixel < 4) {
+ while ((offset % offset_modulo) != 0 ||
+ (pMga->YDstOrg % ydstorg_modulo) != 0) {
+ offset++;
+ pMga->YDstOrg = offset / bytesPerPixel;
+ }
+ }
+ }
+
+ xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "YDstOrg is set to %d\n",
+ pMga->YDstOrg);
+ if(pMga->DualHeadEnabled) {
+ if(pMga->SecondCrtc == FALSE) {
+ pMga->FbUsableSize = pMgaEnt->masterFbMapSize;
+ /* Allocate HW cursor buffer at the end of video ram */
+ if( pMga->HWCursor && pMga->Dac.CursorOffscreenMemSize ) {
+ if( pScrn->virtualY * pScrn->displayWidth *
+ pScrn->bitsPerPixel / 8 <=
+ pMga->FbUsableSize - pMga->Dac.CursorOffscreenMemSize ) {
+ pMga->FbUsableSize -= pMga->Dac.CursorOffscreenMemSize;
+ pMga->FbCursorOffset =
+ pMgaEnt->masterFbMapSize -
+ pMga->Dac.CursorOffscreenMemSize;
+ } else {
+ pMga->HWCursor = FALSE;
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+ "Too little offscreen memory for HW cursor; "
+ "using SW cursor\n");
+ }
+ }
+ } else { /* Second CRTC */
+ pMga->FbUsableSize = pMgaEnt->slaveFbMapSize;
+ pMga->HWCursor = FALSE;
+ }
+ } else {
+ pMga->FbUsableSize = pMga->FbMapSize - pMga->YDstOrg * bytesPerPixel;
+ /* Allocate HW cursor buffer at the end of video ram */
+ if( pMga->HWCursor && pMga->Dac.CursorOffscreenMemSize ) {
+ if( pScrn->virtualY * pScrn->displayWidth *
+ pScrn->bitsPerPixel / 8 <=
+ pMga->FbUsableSize - pMga->Dac.CursorOffscreenMemSize ) {
+ pMga->FbUsableSize -= pMga->Dac.CursorOffscreenMemSize;
+ pMga->FbCursorOffset =
+ pMga->FbMapSize - pMga->Dac.CursorOffscreenMemSize;
+ } else {
+ pMga->HWCursor = FALSE;
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+ "Too little offscreen memory for HW cursor; "
+ "using SW cursor\n");
+ }
+ }
+ }
+ /*
+ * XXX This should be taken into account in some way in the mode valdation
+ * section.
+ */
+
+
+ /* Load the required framebuffer */
+ if (pMga->Overlay8Plus24) {
+ if (!xf86LoadSubModule(pScrn, "xf8_32bpp")) {
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+ xf86LoaderReqSymLists(xf8_32bppSymbols, NULL);
+ } else {
+ if (!xf86LoadSubModule(pScrn, "fb")) {
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+ xf86LoaderReqSymLists(fbSymbols, NULL);
+ }
+
+
+ /* Load XAA if needed */
+ if (!pMga->NoAccel) {
+ if (!xf86LoadSubModule(pScrn, "xaa")) {
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+ xf86LoaderReqSymLists(xaaSymbols, NULL);
+ }
+
+ /* Load ramdac if needed */
+ if (pMga->HWCursor) {
+ if (!xf86LoadSubModule(pScrn, "ramdac")) {
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+ xf86LoaderReqSymLists(ramdacSymbols, NULL);
+ }
+
+ /* Load shadowfb if needed */
+ if (pMga->ShadowFB) {
+ if (!xf86LoadSubModule(pScrn, "shadowfb")) {
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+ xf86LoaderReqSymLists(shadowSymbols, NULL);
+ }
+
+ pMga->CurrentLayout.bitsPerPixel = pScrn->bitsPerPixel;
+ pMga->CurrentLayout.depth = pScrn->depth;
+ pMga->CurrentLayout.displayWidth = pScrn->displayWidth;
+ pMga->CurrentLayout.weight.red = pScrn->weight.red;
+ pMga->CurrentLayout.weight.green = pScrn->weight.green;
+ pMga->CurrentLayout.weight.blue = pScrn->weight.blue;
+ pMga->CurrentLayout.Overlay8Plus24 = pMga->Overlay8Plus24;
+ pMga->CurrentLayout.mode = pScrn->currentMode;
+
+
+
+ if(pMga->MergedFB) {
+ MGAPreInitMergedFB(pScrn,flags);
+ };
+
+
+#ifdef USEMGAHAL
+ MGA_HAL(
+ /* Close the library after preinit */
+ /* This needs to only happen after this board has completed preinit
+ * both times
+ */
+
+ if(pMga->DualHeadEnabled) {
+ /* Entity is shared make sure refcount == 2 */
+ /* If ref count is 2 then reset it to 0 */
+ if(pMgaEnt->refCount == 2) {
+ /* Both boards have done there initialization */
+ MGACloseLibrary(pMga->pBoard);
+
+ if (pMga->pBoard)
+ xfree(pMga->pBoard);
+ if (pMga->pClientStruct)
+ xfree(pMga->pClientStruct);
+ if (pMga->pMgaModeInfo)
+ xfree(pMga->pMgaModeInfo);
+ if (pMga->pMgaHwInfo)
+ xfree(pMga->pMgaHwInfo);
+ pMgaEnt->refCount = 0;
+ }
+ } else {
+ MGACloseLibrary(pMga->pBoard);
+
+ if (pMga->pBoard)
+ xfree(pMga->pBoard);
+ if (pMga->pClientStruct)
+ xfree(pMga->pClientStruct);
+ if (pMga->pMgaModeInfo)
+ xfree(pMga->pMgaModeInfo);
+ if (pMga->pMgaHwInfo)
+ xfree(pMga->pMgaHwInfo);
+ }
+
+ ); /* MGA_HAL */
+#endif
+
+ xf86SetPrimInitDone(pScrn->entityList[0]);
+
+ return TRUE;
+}
+
+
+/*
+ * Map the framebuffer and MMIO memory.
+ */
+
+static Bool
+MGAMapMem(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga;
+
+ pMga = MGAPTR(pScrn);
+
+ /*
+ * Map IO registers to virtual address space
+ */
+ /*
+ * For Alpha, we need to map SPARSE memory, since we need
+ * byte/short access. This is taken care of automatically by the
+ * os-support layer.
+ */
+ pMga->IOBase = xf86MapPciMem(pScrn->scrnIndex,
+ VIDMEM_MMIO | VIDMEM_READSIDEEFFECT,
+ pMga->PciTag, pMga->IOAddress, 0x4000);
+ if (pMga->IOBase == NULL)
+ return FALSE;
+
+ pMga->FbBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_FRAMEBUFFER,
+ pMga->PciTag, pMga->FbAddress,
+ pMga->FbMapSize);
+ if (pMga->FbBase == NULL)
+ return FALSE;
+
+ pMga->FbStart = pMga->FbBase + pMga->YDstOrg * (pScrn->bitsPerPixel / 8);
+
+
+ /* Map the ILOAD transfer window if there is one. We only make
+ DWORD access on DWORD boundaries to this window */
+ if (pMga->ILOADAddress) {
+ pMga->ILOADBase = xf86MapPciMem(pScrn->scrnIndex,
+ VIDMEM_MMIO | VIDMEM_MMIO_32BIT |
+ VIDMEM_READSIDEEFFECT,
+ pMga->PciTag, pMga->ILOADAddress, 0x800000);
+ } else
+ pMga->ILOADBase = NULL;
+
+ return TRUE;
+}
+
+static Bool
+MGAMapMemFBDev(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga;
+
+ pMga = MGAPTR(pScrn);
+
+ pMga->FbBase = fbdevHWMapVidmem(pScrn);
+ if (pMga->FbBase == NULL)
+ return FALSE;
+
+ pMga->IOBase = fbdevHWMapMMIO(pScrn);
+ if (pMga->IOBase == NULL)
+ return FALSE;
+
+ pMga->FbStart = pMga->FbBase + pMga->YDstOrg * (pScrn->bitsPerPixel / 8);
+
+#if 1 /* can't ask matroxfb for a mapping of the iload window */
+
+ /* Map the ILOAD transfer window if there is one. We only make
+ DWORD access on DWORD boundaries to this window */
+ if(pMga->ILOADAddress)
+ pMga->ILOADBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_MMIO,
+ pMga->PciTag, pMga->ILOADAddress, 0x800000);
+ else pMga->ILOADBase = NULL;
+#endif
+ return TRUE;
+}
+
+
+
+/*
+ * Unmap the framebuffer and MMIO memory.
+ */
+
+static Bool
+MGAUnmapMem(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga;
+
+ pMga = MGAPTR(pScrn);
+
+ /*
+ * Unmap IO registers to virtual address space
+ */
+ xf86UnMapVidMem(pScrn->scrnIndex, (pointer)pMga->IOBase, 0x4000);
+ pMga->IOBase = NULL;
+
+ xf86UnMapVidMem(pScrn->scrnIndex, (pointer)pMga->FbBase, pMga->FbMapSize);
+ pMga->FbBase = NULL;
+ pMga->FbStart = NULL;
+
+ if(pMga->ILOADBase)
+ xf86UnMapVidMem(pScrn->scrnIndex, (pointer)pMga->ILOADBase, 0x800000);
+ pMga->ILOADBase = NULL;
+ return TRUE;
+}
+
+static Bool
+MGAUnmapMemFBDev(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga;
+
+ pMga = MGAPTR(pScrn);
+ fbdevHWUnmapVidmem(pScrn);
+ pMga->FbBase = NULL;
+ pMga->FbStart = NULL;
+ fbdevHWUnmapMMIO(pScrn);
+ pMga->IOBase = NULL;
+ /* XXX ILOADBase */
+ return TRUE;
+}
+
+
+
+
+/*
+ * This function saves the video state.
+ */
+static void
+MGASave(ScrnInfoPtr pScrn)
+{
+ vgaHWPtr hwp = VGAHWPTR(pScrn);
+ vgaRegPtr vgaReg = &hwp->SavedReg;
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr mgaReg = &pMga->SavedReg;
+
+ if(pMga->SecondCrtc == TRUE) return;
+#ifdef USEMGAHAL
+ MGA_HAL(if (pMga->pBoard != NULL) MGASaveVgaState(pMga->pBoard));
+#endif
+
+ /* I need to save the registers for the second head also */
+ /* Save the register for 0x80 to 0xa0 */
+ /* Could call it dac2Saved */
+
+ /* Only save text mode fonts/text for the primary card */
+ (*pMga->Save)(pScrn, vgaReg, mgaReg, pMga->Primary);
+}
+
+#ifdef USEMGAHAL
+/* Convert DisplayModeRec parameters in MGAMODEINFO parameters.
+* mode parameter optionnal. */
+void
+MGAFillModeInfoStruct(ScrnInfoPtr pScrn, DisplayModePtr mode)
+{
+ const char *s;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ Bool digital1 = FALSE;
+ Bool digital2 = FALSE;
+ Bool tv1 = FALSE;
+ Bool tv2 = FALSE;
+ Bool swap_head
+ = xf86ReturnOptValBool(pMga->Options, OPTION_SWAPPED_HEAD, FALSE);
+
+ if(pMga->MergedFB && mode && mode->Private && (mode->PrivSize == 0)) {
+ mode = pMga->SecondCrtc ?
+ ((MergedDisplayModePtr)mode->Private)->Monitor2
+ : ((MergedDisplayModePtr)mode->Private)->Monitor1;
+ }
+
+
+ if (pMga->pMgaHwInfo)
+ {
+ digital1 = ISDIGITAL1(pMga);
+ digital2 = ISDIGITAL2(pMga);
+ tv1 = ISTV1(pMga);
+ tv2 = ISTV2(pMga);
+ }
+
+ /*FIXME: causes segfault elsewhere if not commented*/
+ /*if(!pMga->pMgaModeInfo)*/ pMga->pMgaModeInfo = xalloc(sizeof(MGAMODEINFO));
+ pMga->pMgaModeInfo->flOutput = 0;
+ pMga->pMgaModeInfo->ulDeskWidth = pScrn->virtualX;
+ pMga->pMgaModeInfo->ulDeskHeight = pScrn->virtualY;
+ pMga->pMgaModeInfo->ulFBPitch = 0;
+ pMga->pMgaModeInfo->ulBpp = pScrn->bitsPerPixel;
+ pMga->pMgaModeInfo->ulZoom = 1;
+ pMga->pMgaModeInfo->flSignalMode = 0x10;
+
+ /* Set TV standard */
+ if ((s = xf86GetOptValString(pMga->Options, OPTION_TVSTANDARD))) {
+ if (!xf86NameCmp(s, "PAL")) {
+ pMga->pMgaModeInfo->flSignalMode = 0x00;
+ pMga->pMgaModeInfo->ulRefreshRate = 50;
+ pMga->pMgaModeInfo->ulTVStandard = TV_PAL;
+ } else {
+ pMga->pMgaModeInfo->ulRefreshRate = 60;
+ pMga->pMgaModeInfo->ulTVStandard = TV_NTSC;
+ }
+ } else {
+ pMga->pMgaModeInfo->ulRefreshRate = 0;
+ pMga->pMgaModeInfo->ulTVStandard = TV_NTSC;
+ }
+
+ /* Set Cable Type */
+ if ((s = xf86GetOptValString(pMga->Options, OPTION_CABLETYPE))) {
+ if (!xf86NameCmp(s, "SCART_RGB")) {
+ pMga->pMgaModeInfo->ulCableType = TV_SCART_RGB;
+ } else if (!xf86NameCmp(s, "SCART_COMPOSITE")) {
+ pMga->pMgaModeInfo->ulCableType = TV_SCART_COMPOSITE;
+ } else if (!xf86NameCmp(s, "SCART_TYPE2")) {
+ pMga->pMgaModeInfo->ulCableType = TV_SCART_TYPE2;
+ } else {
+ pMga->pMgaModeInfo->ulCableType = TV_YC_COMPOSITE;
+ }
+ } else {
+ pMga->pMgaModeInfo->ulCableType = TV_YC_COMPOSITE;
+ }
+
+ if(mode) {
+ pMga->pMgaModeInfo->ulHorizRate = 0;
+ pMga->pMgaModeInfo->ulDispWidth = mode->HDisplay;
+ pMga->pMgaModeInfo->ulDispHeight = mode->VDisplay;
+ pMga->pMgaModeInfo->ulPixClock = mode->Clock;
+ pMga->pMgaModeInfo->ulHFPorch = mode->HSyncStart - mode->HDisplay;
+ pMga->pMgaModeInfo->ulHSync = mode->HSyncEnd - mode->HSyncStart;
+ pMga->pMgaModeInfo->ulHBPorch = mode->HTotal - mode->HSyncEnd;
+ pMga->pMgaModeInfo->ulVFPorch = mode->VSyncStart - mode->VDisplay;
+ pMga->pMgaModeInfo->ulVSync = mode->VSyncEnd - mode->VSyncStart;
+ pMga->pMgaModeInfo->ulVBPorch = mode->VTotal - mode->VSyncEnd;
+ }
+ /* Use DstOrg directly */
+ /* This is an offset in pixels not memory */
+ pMga->pMgaModeInfo->ulDstOrg = pMga->DstOrg / (pScrn->bitsPerPixel / 8);
+ pMga->pMgaModeInfo->ulDisplayOrg = pMga->DstOrg / (pScrn->bitsPerPixel / 8);
+ pMga->pMgaModeInfo->ulPanXGran = 0;
+ pMga->pMgaModeInfo->ulPanYGran = 0;
+
+ if(pMga->SecondCrtc == TRUE) {
+ pMga->pMgaModeInfo->flOutput = MGAMODEINFO_SECOND_CRTC |
+ MGAMODEINFO_FORCE_PITCH |
+ MGAMODEINFO_FORCE_DISPLAYORG;
+ if (digital2) {
+ pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_DIGITAL2;
+ } else if (tv2) {
+ pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_TV;
+ } else {
+ if (!swap_head) {
+ pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_ANALOG2;
+ } else {
+ pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_ANALOG1;
+ }
+ }
+ } else {
+ pMga->pMgaModeInfo->flOutput = MGAMODEINFO_FORCE_PITCH;
+ if (digital1) {
+ pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_DIGITAL1;
+ } else if (tv1) {
+ pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_TV;
+ } else {
+ if (!swap_head) {
+ pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_ANALOG1;
+ } else {
+ pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_ANALOG2;
+ }
+ }
+ }
+ pMga->pMgaModeInfo->ulFBPitch = pScrn->displayWidth;
+}
+#endif
+
+/*
+ * Initialise a new mode. This is currently still using the old
+ * "initialise struct, restore/write struct to HW" model. That could
+ * be changed.
+ */
+
+static Bool
+MGAModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
+{
+ vgaHWPtr hwp = VGAHWPTR(pScrn);
+ vgaRegPtr vgaReg;
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr mgaReg;
+
+#ifdef USEMGAHAL
+ ULONG status;
+#endif
+ vgaHWUnlock(hwp);
+
+/* if(pMga->MergedFB && mode && mode->Private && (mode->PrivSize == 0)) {
+ mode = (DisplayModePtr)mode->Private;
+ }*/
+
+ /* Initialise the ModeReg values */
+ if (!vgaHWInit(pScrn, mode))
+ return FALSE;
+ pScrn->vtSema = TRUE;
+
+ if (!(*pMga->ModeInit)(pScrn, mode))
+ return FALSE;
+
+ /* Program the registers */
+ vgaHWProtect(pScrn, TRUE);
+ vgaReg = &hwp->ModeReg;
+ mgaReg = &pMga->ModeReg;
+#ifdef USEMGAHAL
+ MGA_HAL(
+ MGAFillModeInfoStruct(pScrn,mode);
+
+ /* Validate the parameters */
+ if ((status = MGAValidateMode(pMga->pBoard, pMga->pMgaModeInfo)) != 0) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "MGAValidateMode from HALlib found the mode to be invalid.\n"
+ "\tError: %lx\n", status);
+ return FALSE;
+ }
+
+ /*
+ * Find mode for second head.
+ */
+ if(pMga->MergedFB) {
+
+ MGAFillModeInfoStruct(pMga->pScrn2,mode);
+ /* Validates the Video parameters */
+ if ((status = MGAValidateVideoParameters(pMga->pBoard, MGAPTR(pMga->pScrn2)->pMgaModeInfo))
+ != 0) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "MGAValidateVideoParameters from HALlib found the mode to be invalid.\n\tError: %lx\n", status);
+ return FALSE;
+ }
+ }
+ ); /*MGA_HAL */
+
+#endif
+
+#ifdef USEMGAHAL
+MGA_HAL(
+
+ /*************************** ESC *****************************/
+ TmpMgaModeInfo[0] = *pMga->pMgaModeInfo;
+
+ if(pMga->SecondCrtc == TRUE)
+ pMgaModeInfo[1] = pMga->pMgaModeInfo;
+ else
+ pMgaModeInfo[0] = pMga->pMgaModeInfo;
+
+ TmpMgaModeInfo[0].ulDispWidth = 0;
+
+ if(!pMga->MergedFB) /* FIXME: Must deal with this once PowerDesk & MergedFB
+ compatibility will exist */
+ MGAFillDisplayModeStruct(mode, pMga->pMgaModeInfo);
+ /*************************************************************/
+
+); /* MGA_HAL */
+#endif
+
+#ifdef XF86DRI
+ if (pMga->directRenderingEnabled) {
+ DRILock(screenInfo.screens[pScrn->scrnIndex], 0);
+ }
+#endif
+
+#ifdef USEMGAHAL
+ MGA_HAL(
+ /* Initialize the board */
+ if(MGASetMode(pMga->pBoard,pMga->pMgaModeInfo) != 0) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "MGASetMode returned an error."
+ " Make sure to validate the mode before.\n");
+ return FALSE;
+ }
+ if(pMga->MergedFB
+ && MGASetMode(pMga->pBoard,MGAPTR(pMga->pScrn2)->pMgaModeInfo) != 0) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "MGASetMode returned an error."
+ " Make sure to validate the mode before.\n");
+ }
+
+ ); /* MGA_HAL */
+
+ /* getting around bugs in the HAL lib. MATROX: hint, hint. */
+ MGA_HAL(
+ switch (pMga->Chipset) {
+ case PCI_CHIP_MGA1064:
+ case PCI_CHIP_MGAG100:
+ case PCI_CHIP_MGAG100_PCI:
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG550:
+ if(pMga->SecondCrtc == FALSE && pMga->HWCursor == TRUE) {
+ outMGAdac(MGA1064_CURSOR_BASE_ADR_LOW,
+ pMga->FbCursorOffset >> 10);
+ outMGAdac(MGA1064_CURSOR_BASE_ADR_HI,
+ pMga->FbCursorOffset >> 18);
+ outMGAdac(MGA1064_CURSOR_CTL, 0x00);
+ }
+ if (pMga->Overlay8Plus24 == TRUE) {
+ outMGAdac(MGA1064_MUL_CTL, MGA1064_MUL_CTL_32bits);
+ outMGAdac(MGA1064_COL_KEY_MSK_LSB,0xFF);
+ outMGAdac(MGA1064_COL_KEY_LSB,pMga->colorKey);
+ outMGAdac(MGA1064_COL_KEY_MSK_MSB,0xFF);
+ outMGAdac(MGA1064_COL_KEY_MSB,0xFF);
+ }
+ break;
+ default:
+ break;
+ }
+ ); /* MGA_HAL */
+#endif
+
+ MGA_NOT_HAL((*pMga->Restore)(pScrn, vgaReg, mgaReg, FALSE));
+
+ MGAStormSync(pScrn);
+ MGAStormEngineInit(pScrn);
+
+ vgaHWProtect(pScrn, FALSE);
+
+ if (xf86IsPc98()) {
+ if (pMga->Chipset == PCI_CHIP_MGA2064)
+ outb(0xfac, 0x01);
+ else
+ outb(0xfac, 0x02);
+ }
+
+ pMga->CurrentLayout.mode = mode;
+
+ if(pMga->MergedFB && mode->Private && (mode->PrivSize == 0)) {
+ pMga->M1currentMode = (DisplayModePtr)mode->Private;
+ }
+
+#ifdef XF86DRI
+ if (pMga->directRenderingEnabled)
+ DRIUnlock(screenInfo.screens[pScrn->scrnIndex]);
+#endif
+#ifdef DEBUG
+ MGAG450PrintPLL(pScrn);
+#endif
+ return TRUE;
+}
+
+static
+void MGARestoreSecondCrtc(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if (MGAISGx50(pMga)) {
+ /* Force to return in clone mode */
+ if (pMga->SecondOutput
+ && (xf86IsEntityShared(pScrn->entityList[0]) || pMga->SecondCrtc)
+ && !pMga->MergedFB) {
+ /* Do this branch if
+ * SecondOutput
+ * and not Unshared Primary
+ * and not Merged Mode (usualy means Unshared Primary)
+ */
+ CARD8 ucXDispCtrl = inMGAdac(MGA1064_DISP_CTL);
+
+ ucXDispCtrl &= ~0x0c; /* dac2outsel mask */
+ ucXDispCtrl |= 0x04; /* dac2 -> crtc1 */
+
+ outMGAdac(MGA1064_DISP_CTL, ucXDispCtrl);
+
+ } else {
+ CARD8 ucXDispCtrl = inMGAdac(MGA1064_DISP_CTL);
+ CARD32 ulC2CTL = INREG(MGAREG_C2CTL);
+
+ ucXDispCtrl &= ~0x0c; /* dac2outsel mask */
+ ucXDispCtrl |= 0x5; /* dac1outsel -> crtcdacsel, dac2 -> crtc1 */
+ ulC2CTL &= ~0x00100000; /* crtcdacsel -> crtc1 */
+
+ outMGAdac(MGA1064_DISP_CTL, ucXDispCtrl);
+ OUTREG(MGAREG_C2CTL, ulC2CTL);
+ }
+
+ } else {
+ /* Force to close second crtc */
+ CARD32 ulC2CTL = INREG(MGAREG_C2CTL);
+
+ ulC2CTL &= ~0x1; /* crtc2 disabled */
+
+ OUTREG(MGAREG_C2CTL, ulC2CTL);
+ }
+
+ return;
+}
+
+/*
+ * Restore the initial (text) mode.
+ */
+static void
+MGARestore(ScrnInfoPtr pScrn)
+{
+ vgaHWPtr hwp = VGAHWPTR(pScrn);
+ vgaRegPtr vgaReg = &hwp->SavedReg;
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr mgaReg = &pMga->SavedReg;
+
+ if (pScrn->pScreen != NULL)
+ MGAStormSync(pScrn);
+
+ /*
+ * Restore the second crtc if:
+ * first and only driver entity
+ * second entity
+ * Merged Framebuffer mode (first and only driver entity)
+ */
+ if((!xf86IsEntityShared(pScrn->entityList[0]) && !pMga->SecondCrtc)
+ || pMga->SecondCrtc || pMga->MergedFB) {
+ /* if(pMga->MergedFB) {
+ if(pMga->pScrn2)
+ MGARestoreSecondCrtc(pMga->pScrn2);
+ } else*/
+ MGARestoreSecondCrtc(pScrn);
+ /* if we are second instance of driver, we've done our job, exit */
+ if(pMga->SecondCrtc) return;
+ }
+
+ /* Only restore text mode fonts/text for the primary card */
+ vgaHWProtect(pScrn, TRUE);
+ if (pMga->Primary) {
+#ifdef USEMGAHAL
+ MGA_HAL(
+ if(pMga->pBoard != NULL) {
+ MGASetVgaMode(pMga->pBoard);
+ MGARestoreVgaState(pMga->pBoard);
+ }
+ ); /* MGA_HAL */
+#endif
+ (*pMga->Restore)(pScrn, vgaReg, mgaReg, TRUE);
+ } else {
+ vgaHWRestore(pScrn, vgaReg, VGA_SR_MODE);
+ }
+ vgaHWProtect(pScrn, FALSE);
+}
+
+
+/* Workaround for a G400 CRTC2 display problem */
+static void
+MGACrtc2FillStrip(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if (pMga->NoAccel) {
+ /* Clears the whole screen, but ... */
+ bzero(pMga->FbStart,
+ (pScrn->bitsPerPixel >> 3) * pScrn->displayWidth * pScrn->virtualY);
+ } else {
+ xf86SetLastScrnFlag(pScrn->entityList[0], pScrn->scrnIndex);
+ pMga->RestoreAccelState(pScrn);
+ pMga->SetupForSolidFill(pScrn, 0, GXcopy, 0xFFFFFFFF);
+ pMga->SubsequentSolidFillRect(pScrn, pScrn->virtualX, 0,
+ pScrn->displayWidth - pScrn->virtualX,
+ pScrn->virtualY);
+ MGAStormSync(pScrn);
+ }
+}
+
+
+/* Mandatory */
+
+/* This gets called at the start of each server generation */
+
+static Bool
+MGAScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
+{
+ ScrnInfoPtr pScrn;
+ vgaHWPtr hwp;
+ MGAPtr pMga;
+ MGARamdacPtr MGAdac;
+ int ret;
+ VisualPtr visual;
+ unsigned char *FBStart;
+ int width, height, displayWidth;
+ MGAEntPtr pMgaEnt = NULL;
+ int f;
+#ifdef XF86DRI
+ MessageType driFrom = X_DEFAULT;
+#endif
+
+ /*
+ * First get the ScrnInfoRec
+ */
+ pScrn = xf86Screens[pScreen->myNum];
+
+ hwp = VGAHWPTR(pScrn);
+ pMga = MGAPTR(pScrn);
+ MGAdac = &pMga->Dac;
+
+
+ /* Map the MGA memory and MMIO areas */
+ if (pMga->FBDev) {
+ if (!MGAMapMemFBDev(pScrn))
+ return FALSE;
+ } else {
+ if (!MGAMapMem(pScrn))
+ return FALSE;
+ }
+
+ if ((pMga->Chipset == PCI_CHIP_MGAG100)
+ || (pMga->Chipset == PCI_CHIP_MGAG100_PCI))
+ MGAG100BlackMagic(pMga);
+
+ if (pMga->DualHeadEnabled) {
+ DevUnion *pPriv;
+ pPriv = xf86GetEntityPrivate(pScrn->entityList[0], MGAEntityIndex);
+ pMgaEnt = pPriv->ptr;
+ pMgaEnt->refCount++;
+#ifdef USEMGAHAL
+ MGA_HAL(
+ if(pMgaEnt->refCount == 1) {
+ CARD8 MiscCtlReg;
+ pMga->pBoard = xalloc(sizeof(CLIENTDATA) + MGAGetBOARDHANDLESize());
+ pMga->pClientStruct = xalloc(sizeof(CLIENTDATA));
+ pMga->pClientStruct->pMga = (MGAPtr) pMga;
+
+ /* wrapping OpenLibrary to fix broken registers. MATROX: hint,hint.*/
+ MiscCtlReg = inMGAdac(MGA1064_MISC_CTL);
+ MGAOpenLibrary(pMga->pBoard,pMga->pClientStruct,sizeof(CLIENTDATA));
+ outMGAdac(MGA1064_MISC_CTL,MiscCtlReg);
+ pMga->pMgaHwInfo = xalloc(sizeof(MGAHWINFO));
+ MGAGetHardwareInfo(pMga->pBoard,pMga->pMgaHwInfo);
+
+ /* Detecting for type of display */
+ if (pMga->pMgaHwInfo->ulCapsSecondOutput & MGAHWINFOCAPS_OUTPUT_TV) {
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "TV detected\n");
+ }
+ if (pMga->pMgaHwInfo->ulCapsFirstOutput &
+ MGAHWINFOCAPS_OUTPUT_DIGITAL) {
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+ "Digital Screen detected\n");
+ }
+ if (pMga->pMgaHwInfo->ulCapsSecondOutput &
+ MGAHWINFOCAPS_OUTPUT_DIGITAL) {
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+ "Digital Screen detected\n");
+ }
+
+ /* Now copy these to the entitystructure */
+ pMgaEnt->pClientStruct = pMga->pClientStruct;
+ pMgaEnt->pBoard = pMga->pBoard;
+ pMgaEnt->pMgaHwInfo = pMga->pMgaHwInfo;
+ } else { /* Ref count is 2 */
+ pMga->pClientStruct = pMgaEnt->pClientStruct;
+ pMga->pBoard = pMgaEnt->pBoard;
+ pMga->pMgaHwInfo = pMgaEnt->pMgaHwInfo;
+ }
+ ); /* MGA_HAL */
+#endif
+ } else {
+#ifdef USEMGAHAL
+ CARD8 MiscCtlReg;
+
+ MGA_HAL(
+ pMga->pBoard = xalloc(sizeof(CLIENTDATA) + MGAGetBOARDHANDLESize());
+ pMga->pClientStruct = xalloc(sizeof(CLIENTDATA));
+ pMga->pClientStruct->pMga = (MGAPtr) pMga;
+
+ MiscCtlReg = inMGAdac(MGA1064_MISC_CTL);
+ /* wrapping OpenLibrary to fix broken registers. MATROX: hint,hint.*/
+ MGAOpenLibrary(pMga->pBoard,pMga->pClientStruct,sizeof(CLIENTDATA));
+ outMGAdac(MGA1064_MISC_CTL,MiscCtlReg);
+ pMga->pMgaHwInfo = xalloc(sizeof(MGAHWINFO));
+ MGAGetHardwareInfo(pMga->pBoard,pMga->pMgaHwInfo);
+ ); /* MGA_HAL */
+#endif
+ }
+#ifdef USEMGAHAL
+ MGA_HAL(
+ /* There is a problem in the HALlib: set soft reset bit */
+ /* MATROX: hint, hint. */
+ if (!pMga->Primary && !pMga->FBDev &&
+ (pMga->PciInfo->subsysCard == PCI_CARD_MILL_G200_SG) ) {
+ OUTREG(MGAREG_Reset, 1);
+ usleep(200);
+ OUTREG(MGAREG_Reset, 0);
+ }
+ ); /* MGA_HAL */
+#endif
+
+ /* Initialise the MMIO vgahw functions */
+ vgaHWSetMmioFuncs(hwp, pMga->IOBase, PORT_OFFSET);
+ vgaHWGetIOBase(hwp);
+
+ /* Map the VGA memory when the primary video */
+ if (pMga->Primary && !pMga->FBDev) {
+ hwp->MapSize = 0x10000;
+ if (!vgaHWMapMem(pScrn))
+ return FALSE;
+ }
+
+ if (pMga->FBDev) {
+ fbdevHWSave(pScrn);
+ /* Disable VGA core, and leave memory access on */
+ pciSetBitsLong(pMga->PciTag, PCI_OPTION_REG, 0x100, 0x000);
+ if (!fbdevHWModeInit(pScrn, pScrn->currentMode))
+ return FALSE;
+ if(pMga->SecondCrtc == FALSE && pMga->HWCursor == TRUE) {
+ switch (pMga->Chipset) {
+ case PCI_CHIP_MGA1064:
+ case PCI_CHIP_MGAG100:
+ case PCI_CHIP_MGAG100_PCI:
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG550:
+ outMGAdac(MGA1064_CURSOR_BASE_ADR_LOW, pMga->FbCursorOffset >> 10);
+ outMGAdac(MGA1064_CURSOR_BASE_ADR_HI, pMga->FbCursorOffset >> 18);
+ break;
+ default:
+ break;
+ }
+ }
+
+ MGAStormEngineInit(pScrn);
+ } else {
+ /* Save the current state */
+ MGASave(pScrn);
+ /* Initialise the first mode */
+ if (!MGAModeInit(pScrn, pScrn->currentMode))
+ return FALSE;
+ }
+ /* Darken the screen for aesthetic reasons and set the viewport */
+ if (pMga->SecondCrtc == TRUE && !pMga->MergedFB) {
+ MGASaveScreenCrtc2(pScreen, SCREEN_SAVER_ON);
+ }
+ if (pMga->SecondCrtc == FALSE && !pMga->MergedFB) {
+ MGASaveScreen(pScreen, SCREEN_SAVER_ON);
+ }
+ if( pMga->MergedFB ) {
+ MGASaveScreenMerged( pScreen, SCREEN_SAVER_ON );
+ }
+ pScrn->AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
+
+ /*
+ * The next step is to setup the screen's visuals, and initialise the
+ * framebuffer code. In cases where the framebuffer's default
+ * choices for things like visual layouts and bits per RGB are OK,
+ * this may be as simple as calling the framebuffer's ScreenInit()
+ * function. If not, the visuals will need to be setup before calling
+ * a fb ScreenInit() function and fixed up after.
+ *
+ * For most PC hardware at depths >= 8, the defaults that cfb uses
+ * are not appropriate. In this driver, we fixup the visuals after.
+ */
+
+ /*
+ * Reset the visual list.
+ */
+ miClearVisualTypes();
+
+ /* Setup the visuals we support. */
+
+ /* All MGA support DirectColor and can do overlays in 32bpp */
+ if(pMga->Overlay8Plus24 && (pScrn->bitsPerPixel == 32)) {
+ if (!miSetVisualTypes(8, PseudoColorMask | GrayScaleMask,
+ pScrn->rgbBits, PseudoColor))
+ return FALSE;
+ if (!miSetVisualTypes(24, TrueColorMask, pScrn->rgbBits, TrueColor))
+ return FALSE;
+ } else if (pMga->SecondCrtc) {
+ /* No DirectColor on the second head */
+ if (!miSetVisualTypes(pScrn->depth, TrueColorMask, pScrn->rgbBits,
+ TrueColor))
+ return FALSE;
+ if (!miSetPixmapDepths ())
+ return FALSE;
+ } else {
+ if (!xf86SetDefaultVisual(pScrn, -1))
+ return FALSE;
+
+ if (!miSetVisualTypes(pScrn->depth,
+ miGetDefaultVisualMask(pScrn->depth),
+ pScrn->rgbBits, pScrn->defaultVisual))
+ return FALSE;
+ if (!miSetPixmapDepths ())
+ return FALSE;
+ }
+
+ /*
+ * Call the framebuffer layer's ScreenInit function, and fill in other
+ * pScreen fields.
+ */
+
+ width = pScrn->virtualX;
+ height = pScrn->virtualY;
+ displayWidth = pScrn->displayWidth;
+
+
+ if(pMga->Rotate) {
+ height = pScrn->virtualX;
+ width = pScrn->virtualY;
+ }
+
+ if(pMga->ShadowFB) {
+ pMga->ShadowPitch = BitmapBytePad(pScrn->bitsPerPixel * width);
+ pMga->ShadowPtr = xalloc(pMga->ShadowPitch * height);
+ displayWidth = pMga->ShadowPitch / (pScrn->bitsPerPixel >> 3);
+ FBStart = pMga->ShadowPtr;
+ } else {
+ pMga->ShadowPtr = NULL;
+ FBStart = pMga->FbStart;
+ }
+
+#ifdef XF86DRI
+ /*
+ * Setup DRI after visuals have been established, but before cfbScreenInit
+ * is called. cfbScreenInit will eventually call into the drivers
+ * InitGLXVisuals call back.
+ * The DRI does not work when textured video is enabled at this time.
+ */
+ if (!xf86ReturnOptValBool(pMga->Options, OPTION_DRI, TRUE)) {
+ driFrom = X_CONFIG;
+ } else if ( pMga->NoAccel ) {
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "Acceleration disabled, not initializing the DRI\n" );
+ pMga->directRenderingEnabled = FALSE;
+ driFrom = X_CONFIG;
+ }
+ else if ( pMga->TexturedVideo == TRUE ) {
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "Textured video enabled, not initializing the DRI\n" );
+ pMga->directRenderingEnabled = FALSE;
+ driFrom = X_CONFIG;
+ }
+ else if (pMga->SecondCrtc == TRUE) {
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "Not initializing the DRI on the second head\n" );
+ pMga->directRenderingEnabled = FALSE;
+ }
+ else if ((pMga->FbMapSize /
+ (width * (pScrn->bitsPerPixel >> 3))) <= height * 3) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "Static buffer allocation failed, not initializing the DRI\n");
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "Need at least %d kB video memory at this resolution, bit depth\n",
+ (3 * displayWidth * height * (pScrn->bitsPerPixel >> 3)) / 1024 );
+ pMga->directRenderingEnabled = FALSE;
+ driFrom = X_PROBED;
+ }
+ else {
+ pMga->directRenderingEnabled = MGADRIScreenInit(pScreen);
+ }
+#endif
+
+
+ if (pMga->Overlay8Plus24) {
+ ret = cfb8_32ScreenInit(pScreen, FBStart,
+ width, height,
+ pScrn->xDpi, pScrn->yDpi,
+ displayWidth);
+ } else {
+ ret = fbScreenInit(pScreen, FBStart, width, height,
+ pScrn->xDpi, pScrn->yDpi,
+ displayWidth, pScrn->bitsPerPixel);
+ }
+
+ if (!ret)
+ 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;
+ }
+ }
+ }
+
+ /* must be after RGB ordering fixed */
+ if (!pMga->Overlay8Plus24)
+ fbPictureInit (pScreen, 0, 0);
+
+ xf86SetBlackWhitePixels(pScreen);
+
+ pMga->BlockHandler = pScreen->BlockHandler;
+ pScreen->BlockHandler = MGABlockHandler;
+
+ if(!pMga->ShadowFB) /* hardware cursor needs to wrap this layer */
+ MGADGAInit(pScreen);
+
+ if (!pMga->NoAccel)
+ MGAStormAccelInit(pScreen);
+
+ miInitializeBackingStore(pScreen);
+ xf86SetBackingStore(pScreen);
+ xf86SetSilkenMouse(pScreen);
+
+ /* Initialize software cursor.
+ Must precede creation of the default colormap */
+ miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
+
+ /* Initialize HW cursor layer.
+ Must follow software cursor initialization*/
+ if (pMga->HWCursor) {
+ if(!MGAHWCursorInit(pScreen))
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "Hardware cursor initialization failed\n");
+ }
+ if(pMga->MergedFB) {
+ /* Rotate and MergedFB are mutiualy exclusive, so we can use this
+ * variable.
+ */
+ if (!pMga->PointerMoved)
+ pMga->PointerMoved = pScrn->PointerMoved;
+ pScrn->PointerMoved = MGAMergePointerMoved;
+
+ }
+
+ /* Initialise default colourmap */
+ if (!miCreateDefColormap(pScreen))
+ return FALSE;
+
+ /* Initialize colormap layer.
+ Must follow initialization of the default colormap */
+ if (!pMga->SecondCrtc)
+ f = CMAP_PALETTED_TRUECOLOR | CMAP_RELOAD_ON_MODE_SWITCH;
+ else
+ f = CMAP_RELOAD_ON_MODE_SWITCH;
+ if(!xf86HandleColormaps(pScreen, 256, 8,
+ (pMga->FBDev ? fbdevHWLoadPalette : MGAdac->LoadPalette), NULL, f))
+ return FALSE;
+
+ if(pMga->Overlay8Plus24) { /* Must come after colormap initialization */
+ if(!xf86Overlay8Plus32Init(pScreen))
+ return FALSE;
+ }
+
+ if(pMga->ShadowFB) {
+ RefreshAreaFuncPtr refreshArea = MGARefreshArea;
+
+ if(pMga->Rotate) {
+ if (!pMga->PointerMoved) {
+ pMga->PointerMoved = pScrn->PointerMoved;
+ pScrn->PointerMoved = MGAPointerMoved;
+ }
+
+ switch(pScrn->bitsPerPixel) {
+ case 8: refreshArea = MGARefreshArea8; break;
+ case 16: refreshArea = MGARefreshArea16; break;
+ case 24: refreshArea = MGARefreshArea24; break;
+ case 32: refreshArea = MGARefreshArea32; break;
+ }
+ }
+
+ ShadowFBInit(pScreen, refreshArea);
+ }
+
+ if(pMga->SecondCrtc == TRUE && !pMga->MergedFB) {
+ xf86DPMSInit(pScreen, MGADisplayPowerManagementSetCrtc2, 0);
+ }
+ if(pMga->SecondCrtc == FALSE && !pMga->MergedFB) {
+ xf86DPMSInit(pScreen, MGADisplayPowerManagementSet, 0);
+ }
+ if(pMga->MergedFB) {
+ xf86DPMSInit(pScreen, MGADisplayPowerManagementSetMerged, 0);
+ }
+
+ pScrn->memPhysBase = pMga->FbAddress;
+ pScrn->fbOffset = pMga->YDstOrg * (pScrn->bitsPerPixel / 8);
+
+ if(!pMga->MergedFB) {
+ if(pMga->SecondCrtc == TRUE) {
+ pScreen->SaveScreen = MGASaveScreenCrtc2;
+ } else {
+ pScreen->SaveScreen = MGASaveScreen;
+ }
+ } else { /* Merged FB */
+ pScreen->SaveScreen = MGASaveScreenMerged;
+ }
+
+ MGAInitVideo(pScreen);
+
+#ifdef XF86DRI
+ if (pMga->directRenderingEnabled) {
+ /* Now that mi, cfb, drm and others have done their thing,
+ * complete the DRI setup.
+ */
+ pMga->directRenderingEnabled = MGADRIFinishScreenInit(pScreen);
+ }
+ if (pMga->directRenderingEnabled) {
+ xf86DrvMsg(pScrn->scrnIndex, driFrom, "Direct rendering enabled\n");
+ } else {
+ xf86DrvMsg(pScrn->scrnIndex, driFrom, "Direct rendering disabled\n");
+ }
+ if (pMga->DualHeadEnabled && pMga->SecondCrtc == FALSE)
+ pMgaEnt->directRenderingEnabled = pMga->directRenderingEnabled;
+ pMga->haveQuiescense = 1;
+#endif
+
+ /* Wrap the current CloseScreen function */
+ pMga->CloseScreen = pScreen->CloseScreen;
+ pScreen->CloseScreen = MGACloseScreen;
+
+ /* Report any unused options (only for the first generation) */
+ if (serverGeneration == 1) {
+ xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
+ }
+
+ /* For the second head, work around display problem. */
+ if (!pMga->MergedFB && pMga->SecondCrtc) {
+ MGACrtc2FillStrip(pScrn);
+ }
+
+ /* Done */
+ return TRUE;
+}
+
+
+/* Usually mandatory */
+Bool
+MGASwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
+{
+#ifdef USEMGAHAL
+ char sCmdIn[256];
+ char sCmdOut[256];
+ FILE* fdIn;
+ FILE* fdOut;
+#endif
+ MGAPtr pMga;
+ ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+ pMga = MGAPTR(pScrn);
+
+ if (mode->Flags & 0x80000000) {
+#ifdef USEMGAHAL
+ MGA_HAL(
+ fdIn = fopen("/tmp/mgaDriverIn", "rt");
+ fdOut = fopen("/tmp/mgaDriverOut", "wt");
+
+ if(fdIn && fdOut)
+ {
+
+ fgets(sCmdIn, 255, fdIn);
+
+ if(sCmdIn)
+ {
+
+ MGAExecuteEscCmd(xf86Screens[scrnIndex], sCmdIn, sCmdOut, mode);
+
+ /* Remove file and close file descriptor */
+ remove("/tmp/mgaDriverIn");
+ fclose(fdIn);
+
+ /* Write output data to output file for calling application */
+ fputs(sCmdOut, fdOut);
+ fclose(fdOut);
+
+ mode->Flags &= 0x7FFFFFFF;
+ return TRUE;
+ }
+ else
+ {
+ mode->Flags &= 0x7FFFFFFF;
+ return FALSE;
+ }
+ }
+ else
+ {
+ mode->Flags &= 0x7FFFFFFF;
+ return FALSE;
+ }
+ )
+#endif
+ return FALSE;
+ } else
+ return MGAModeInit(xf86Screens[scrnIndex], mode);
+}
+
+ /* Adjusts coordinates to match Panning granularity.
+ * does nothing if the HALlib is not loaded
+ */
+void
+MGAAdjustGranularity(ScrnInfoPtr pScrn, int* x, int* y)
+{
+#ifdef USEMGAHAL
+ MGA_HAL(
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAPtr pMga2;
+ int xg = 1;
+ int yg = 1;
+ if(pMga->pMgaModeInfo && pMga->pMgaModeInfo->ulPanXGran && pMga->pMgaModeInfo->ulPanYGran) {
+ xg = pMga->pMgaModeInfo->ulPanXGran;
+ yg = pMga->pMgaModeInfo->ulPanYGran;
+ }
+ if(pMga->pScrn2 && (pMga2 = MGAPTR(pMga->pScrn2)) ) {
+
+ if(pMga2->pMgaModeInfo && pMga2->pMgaModeInfo->ulPanXGran && pMga2->pMgaModeInfo->ulPanYGran) {
+ xg = max(xg,pMga2->pMgaModeInfo->ulPanXGran);
+ yg = max(yg,pMga2->pMgaModeInfo->ulPanYGran);
+ }
+ }
+ xg=16; /*ncoder: temporary */
+ *x -= *x % xg;
+ *y -= *y % yg;
+ );
+#endif
+}
+
+
+/*
+ * This function is used to initialize the Start Address - the first
+ * displayed location in the video memory.
+ */
+/* Usually mandatory */
+void
+MGAAdjustFrame(int scrnIndex, int x, int y, int flags)
+{
+ ScrnInfoPtr pScrn;
+ int Base, tmp, count;
+
+ MGAFBLayout *pLayout;
+ MGAPtr pMga;
+
+
+ pScrn = xf86Screens[scrnIndex];
+ pMga = MGAPTR(pScrn);
+ pLayout = &pMga->CurrentLayout;
+
+ /* wanted to improve panning granularity problems without risking
+ * compatibility issues. Existing code looked hardware dependent.
+ */
+#ifdef USEMGAHAL
+ MGA_HAL(
+ pMga->HALGranularityOffX = x;
+ pMga->HALGranularityOffY = y;
+ MGAAdjustGranularity(pScrn,&x,&y);
+ pMga->HALGranularityOffX = pMga->HALGranularityOffX - x;
+ pMga->HALGranularityOffY = pMga->HALGranularityOffY - y;
+ HALSetDisplayStart(pMga->pBoard,x,y,0);
+ );
+#endif
+ MGA_NOT_HAL(
+ if(pMga->ShowCache && y && pScrn->vtSema)
+ y += pScrn->virtualY - 1;
+
+ Base = (y * pLayout->displayWidth + x + pMga->YDstOrg) >>
+ (3 - pMga->BppShifts[(pLayout->bitsPerPixel >> 3) - 1]);
+
+ if (pLayout->bitsPerPixel == 24) {
+ if (pMga->Chipset == PCI_CHIP_MGAG400 || pMga->Chipset == PCI_CHIP_MGAG550)
+ Base &= ~1; /*1 Not sure why */
+ Base *= 3;
+ }
+
+ /* find start of retrace */
+ while (INREG8(0x1FDA) & 0x08);
+ while (!(INREG8(0x1FDA) & 0x08));
+ /* wait until we're past the start (fixseg.c in the DDK) */
+ count = INREG(MGAREG_VCOUNT) + 2;
+ while(INREG(MGAREG_VCOUNT) < count);
+
+ OUTREG16(MGAREG_CRTC_INDEX, (Base & 0x00FF00) | 0x0C);
+ OUTREG16(MGAREG_CRTC_INDEX, ((Base & 0x0000FF) << 8) | 0x0D);
+ OUTREG8(MGAREG_CRTCEXT_INDEX, 0x00);
+ tmp = INREG8(MGAREG_CRTCEXT_DATA);
+ OUTREG8(MGAREG_CRTCEXT_DATA, (tmp & 0xF0) | ((Base & 0x0F0000) >> 16));
+ );
+
+}
+
+#define C2STARTADD0 0x3C28
+
+void
+MGAAdjustFrameCrtc2(int scrnIndex, int x, int y, int flags)
+{
+ ScrnInfoPtr pScrn;
+ int Base;
+ MGAFBLayout *pLayout;
+ MGAPtr pMga;
+
+ pScrn = xf86Screens[scrnIndex];
+ pMga = MGAPTR(pScrn);
+ pLayout = &pMga->CurrentLayout;
+#ifdef USEMGAHAL
+ MGA_HAL(
+ MGAAdjustGranularity(pScrn,&x,&y);
+ HALSetDisplayStart(pMga->pBoard,x,y,1);
+ );
+#endif
+ MGA_NOT_HAL(
+ if(pMga->ShowCache && y && pScrn->vtSema)
+ y += pScrn->virtualY - 1;
+
+ /* 3-85 c2offset
+ * 3-93 c2startadd0
+ * 3-96 c2vcount
+ */
+
+ Base = (y * pLayout->displayWidth + x) * pLayout->bitsPerPixel >> 3;
+ Base += pMga->DstOrg;
+ Base &= 0x01ffffc0;
+ OUTREG(C2STARTADD0, Base);
+ );
+}
+
+/*
+ * This is called when VT switching back to the X server. Its job is
+ * to reinitialise the video mode.
+ *
+ * We may wish to unmap video/MMIO memory too.
+ */
+
+/* Mandatory */
+static Bool
+MGAEnterVT(int scrnIndex, int flags)
+{
+ ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+ MGAPtr pMga;
+
+ pMga = MGAPTR(pScrn);
+
+#ifdef XF86DRI
+ if (pMga->directRenderingEnabled) {
+ if (pMga->irq) {
+ /* Need to make sure interrupts are enabled */
+ OUTREG(MGAREG_IEN, pMga->reg_ien);
+ }
+ DRIUnlock(screenInfo.screens[scrnIndex]);
+ }
+#endif
+
+ if (!MGAModeInit(pScrn, pScrn->currentMode))
+ return FALSE;
+ pScrn->AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
+
+ /* For the second head, work around display problem. */
+ if (pMga->SecondCrtc) {
+ MGACrtc2FillStrip(pScrn);
+ }
+
+ return TRUE;
+}
+
+static Bool
+MGAEnterVTFBDev(int scrnIndex, int flags)
+{
+ ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+#ifdef XF86DRI
+ ScreenPtr pScreen;
+ MGAPtr pMga;
+
+ pMga = MGAPTR(pScrn);
+ if (pMga->directRenderingEnabled) {
+ pScreen = screenInfo.screens[scrnIndex];
+ DRIUnlock(pScreen);
+ }
+#endif
+
+ fbdevHWEnterVT(scrnIndex,flags);
+ MGAStormEngineInit(pScrn);
+ return TRUE;
+}
+
+#define RESTORE_TEXTMODE_ON_DVI(x) \
+ if (MGAISGx50(x) && \
+ (ISDIGITAL1(x) || ISDIGITAL2(x))) { \
+ /* Reset DUALDVI register */ \
+ outMGAdac(MGA1064_DVI_PIPE_CTL, 0x0); \
+ /* Set Panel mode between 20 and 54 MHz */ \
+ outMGAdac(MGA1064_PAN_CTL, 0x7); \
+ }
+
+
+/*
+ * This is called when VT switching away from the X server. Its job is
+ * to restore the previous (text) mode.
+ *
+ * We may wish to remap video/MMIO memory too.
+ */
+
+/* Mandatory */
+static void
+MGALeaveVT(int scrnIndex, int flags)
+{
+ ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+ vgaHWPtr hwp = VGAHWPTR(pScrn);
+#ifdef XF86DRI
+ MGAPtr pMga = MGAPTR(pScrn);
+ ScreenPtr pScreen;
+#endif
+
+ MGARestore(pScrn);
+ vgaHWLock(hwp);
+
+ if (xf86IsPc98())
+ outb(0xfac, 0x00);
+#ifdef XF86DRI
+ if (pMga->directRenderingEnabled) {
+ pScreen = screenInfo.screens[scrnIndex];
+ DRILock(pScreen, 0);
+ }
+#endif
+#ifdef USEMGAHAL
+ MGA_HAL( RESTORE_TEXTMODE_ON_DVI(pMga); );
+#endif
+}
+
+
+/*
+ * This is called at the end of each server generation. It restores the
+ * original (text) mode. It should also unmap the video memory, and free
+ * any per-generation data allocated by the driver. It should finish
+ * by unwrapping and calling the saved CloseScreen function.
+ */
+
+/* Mandatory */
+static Bool
+MGACloseScreen(int scrnIndex, ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+ vgaHWPtr hwp = VGAHWPTR(pScrn);
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAEntPtr pMgaEnt = NULL;
+
+#ifdef USEMGAHAL
+ MGA_HAL( RESTORE_TEXTMODE_ON_DVI(pMga); );
+#endif
+ if (pMga->MergedFB)
+ MGACloseScreenMerged(scrnIndex, pScreen);
+
+ if (pScrn->vtSema) {
+ if (pMga->FBDev) {
+ fbdevHWRestore(pScrn);
+ MGAUnmapMemFBDev(pScrn);
+ } else {
+ MGARestore(pScrn);
+ vgaHWLock(hwp);
+ MGAUnmapMem(pScrn);
+ vgaHWUnmapMem(pScrn);
+ }
+ }
+#ifdef XF86DRI
+ if (pMga->directRenderingEnabled) {
+ MGADRICloseScreen(pScreen);
+ pMga->directRenderingEnabled=FALSE;
+ }
+#endif
+
+ if (pMga->DualHeadEnabled) {
+ DevUnion *pPriv;
+ pPriv = xf86GetEntityPrivate(pScrn->entityList[0], MGAEntityIndex);
+ pMgaEnt = pPriv->ptr;
+ pMgaEnt->refCount--;
+ }
+
+#ifdef USEMGAHAL
+ MGA_HAL(
+ if(pMga->DualHeadEnabled) {
+ if(pMgaEnt->refCount == 0) {
+ /* Both boards have closed there screen */
+ MGACloseLibrary(pMga->pBoard);
+
+ if (pMga->pBoard)
+ xfree(pMga->pBoard);
+ if (pMga->pClientStruct)
+ xfree(pMga->pClientStruct);
+ if (pMga->pMgaModeInfo)
+ xfree(pMga->pMgaModeInfo);
+ if (pMga->pMgaHwInfo)
+ xfree(pMga->pMgaHwInfo);
+ }
+ } else {
+ MGACloseLibrary(pMga->pBoard);
+
+ if (pMga->pBoard)
+ xfree(pMga->pBoard);
+ if (pMga->pClientStruct)
+ xfree(pMga->pClientStruct);
+ if (pMga->pMgaModeInfo)
+ xfree(pMga->pMgaModeInfo);
+ if (pMga->pMgaHwInfo)
+ xfree(pMga->pMgaHwInfo);
+ }
+ ); /* MGA_HAL */
+#endif
+
+ if (pMga->AccelInfoRec)
+ XAADestroyInfoRec(pMga->AccelInfoRec);
+ if (pMga->CursorInfoRec)
+ xf86DestroyCursorInfoRec(pMga->CursorInfoRec);
+ if (pMga->ShadowPtr)
+ xfree(pMga->ShadowPtr);
+ if (pMga->DGAModes)
+ xfree(pMga->DGAModes);
+ if (pMga->adaptor)
+ xfree(pMga->adaptor);
+ if (pMga->portPrivate)
+ xfree(pMga->portPrivate);
+ if (pMga->ScratchBuffer)
+ xfree(pMga->ScratchBuffer);
+
+ pScrn->vtSema = FALSE;
+
+ if (xf86IsPc98())
+ outb(0xfac, 0x00);
+
+ xf86ClearPrimInitDone(pScrn->entityList[0]);
+
+ if(pMga->BlockHandler)
+ pScreen->BlockHandler = pMga->BlockHandler;
+
+ pScreen->CloseScreen = pMga->CloseScreen;
+
+ return (*pScreen->CloseScreen)(scrnIndex, pScreen);
+}
+
+
+/* Free up any persistent data structures */
+
+/* Optional */
+static void
+MGAFreeScreen(int scrnIndex, int flags)
+{
+
+ /*
+ * This only gets called when a screen is being deleted. It does not
+ * get called routinely at the end of a server generation.
+ */
+ if (xf86LoaderCheckSymbol("vgaHWFreeHWRec"))
+ vgaHWFreeHWRec(xf86Screens[scrnIndex]);
+ MGAFreeRec(xf86Screens[scrnIndex]);
+
+}
+
+
+/* Checks if a mode is suitable for the selected chipset. */
+
+/* Optional */
+static int
+MGAValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
+{
+ int lace;
+ ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ lace = 1 + ((mode->Flags & V_INTERLACE) != 0);
+
+ if ((mode->CrtcHDisplay <= 2048) &&
+ (mode->CrtcHSyncStart <= 4096) &&
+ (mode->CrtcHSyncEnd <= 4096) &&
+ (mode->CrtcHTotal <= 4096) &&
+ (mode->CrtcVDisplay <= 2048 * lace) &&
+ (mode->CrtcVSyncStart <= 4096 * lace) &&
+ (mode->CrtcVSyncEnd <= 4096 * lace) &&
+ (mode->CrtcVTotal <= 4096 * lace)) {
+
+ /* Can't have horizontal panning for second head of G400 */
+ if (pMga->SecondCrtc) {
+ if (flags == MODECHECK_FINAL) {
+ if (pMga->allowedWidth == 0)
+ pMga->allowedWidth = pScrn->virtualX;
+ if (mode->HDisplay != pMga->allowedWidth)
+ return(MODE_ONE_WIDTH);
+ }
+ }
+
+ return(MODE_OK);
+ } else {
+ return(MODE_BAD);
+ }
+}
+
+
+/*
+ * This routine is required but since we can't easily blank the
+ * second display without risking powering off the monitor, return
+ * FALSE and let the X server do something generic.
+ */
+static Bool
+MGASaveScreenCrtc2(ScreenPtr pScreen, int mode)
+{
+ return FALSE;
+}
+
+/* Do screen blanking */
+
+static Bool
+MGASaveScreen(ScreenPtr pScreen, int mode)
+{
+ return vgaHWSaveScreen(pScreen, mode);
+}
+
+
+/*
+ * MGADisplayPowerManagementSet --
+ *
+ * Sets VESA Display Power Management Signaling (DPMS) Mode.
+ */
+void
+MGADisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode,
+ int flags)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ unsigned char seq1 = 0, crtcext1 = 0;
+
+ switch (PowerManagementMode)
+ {
+ case DPMSModeOn:
+ /* Screen: On; HSync: On, VSync: On */
+ seq1 = 0x00;
+ crtcext1 = 0x00;
+ break;
+ case DPMSModeStandby:
+ /* Screen: Off; HSync: Off, VSync: On */
+ seq1 = 0x20;
+ crtcext1 = 0x10;
+ break;
+ case DPMSModeSuspend:
+ /* Screen: Off; HSync: On, VSync: Off */
+ seq1 = 0x20;
+ crtcext1 = 0x20;
+ break;
+ case DPMSModeOff:
+ /* Screen: Off; HSync: Off, VSync: Off */
+ seq1 = 0x20;
+ crtcext1 = 0x30;
+ break;
+ }
+ /* XXX Prefer an implementation that doesn't depend on VGA specifics */
+ OUTREG8(MGAREG_SEQ_INDEX, 0x01); /* Select SEQ1 */
+ seq1 |= INREG8(MGAREG_SEQ_DATA) & ~0x20;
+ OUTREG8(MGAREG_SEQ_DATA, seq1);
+ OUTREG8(MGAREG_CRTCEXT_INDEX, 0x01); /* Select CRTCEXT1 */
+ crtcext1 |= INREG8(MGAREG_CRTCEXT_DATA) & ~0x30;
+ OUTREG8(MGAREG_CRTCEXT_DATA, crtcext1);
+}
+
+
+void
+MGADisplayPowerManagementSetCrtc2(ScrnInfoPtr pScrn, int PowerManagementMode,
+ int flags)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ CARD32 crtc2 = 0;
+
+ if (PowerManagementMode != DPMSModeOn)
+ crtc2 = 0x8; /* c2pixclkdis */
+ crtc2 |= INREG(MGAREG_C2CTL) & ~0x8;
+ OUTREG(MGAREG_C2CTL, crtc2);
+}
+
+
+static void
+MGABlockHandler (
+ int i,
+ pointer blockData,
+ pointer pTimeout,
+ pointer pReadmask
+){
+ ScreenPtr pScreen = screenInfo.screens[i];
+ ScrnInfoPtr pScrn = xf86Screens[i];
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if(pMga->PaletteLoadCallback)
+ (*pMga->PaletteLoadCallback)(pScrn);
+
+ pScreen->BlockHandler = pMga->BlockHandler;
+ (*pScreen->BlockHandler) (i, blockData, pTimeout, pReadmask);
+ pScreen->BlockHandler = MGABlockHandler;
+
+ if(pMga->VideoTimerCallback) {
+ UpdateCurrentTime();
+ (*pMga->VideoTimerCallback)(pScrn, currentTime.milliseconds);
+ }
+
+ if(pMga->RenderCallback)
+ (*pMga->RenderCallback)(pScrn);
+}
+
+#if defined (DEBUG)
+/*
+ * some functions to track input/output in the server
+ */
+
+CARD8
+dbg_inreg8(ScrnInfoPtr pScrn,int addr,int verbose)
+{
+ MGAPtr pMga;
+ CARD8 ret;
+
+ pMga = MGAPTR(pScrn);
+ ret = *(volatile CARD8 *)(pMga->IOBase + (addr));
+ if(verbose)
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "inreg8 : 0x%8x = 0x%x\n",addr,ret);
+ return ret;
+}
+
+CARD16
+dbg_inreg16(ScrnInfoPtr pScrn,int addr,int verbose)
+{
+ MGAPtr pMga;
+ CARD16 ret;
+
+ pMga = MGAPTR(pScrn);
+ ret = *(volatile CARD16 *)(pMga->IOBase + (addr));
+ if(verbose)
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "inreg16: 0x%8x = 0x%x\n",addr,ret);
+ return ret;
+}
+
+CARD32
+dbg_inreg32(ScrnInfoPtr pScrn,int addr,int verbose)
+{
+ MGAPtr pMga;
+ CARD32 ret;
+
+ pMga = MGAPTR(pScrn);
+ ret = *(volatile CARD32 *)(pMga->IOBase + (addr));
+ if(verbose)
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "inreg32: 0x%8x = 0x%x\n",addr,ret);
+ return ret;
+}
+
+void
+dbg_outreg8(ScrnInfoPtr pScrn,int addr,int val)
+{
+ MGAPtr pMga;
+ CARD8 ret;
+
+ pMga = MGAPTR(pScrn);
+#if 0
+ if( addr = MGAREG_CRTCEXT_DATA )
+ return;
+#endif
+ if( addr != 0x3c00 ) {
+ ret = dbg_inreg8(pScrn,addr,0);
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "outreg8 : 0x%8x = 0x%x was 0x%x\n",addr,val,ret);
+ }
+ else {
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "outreg8 : index 0x%x\n",val);
+ }
+ *(volatile CARD8 *)(pMga->IOBase + (addr)) = (val);
+}
+
+void
+dbg_outreg16(ScrnInfoPtr pScrn,int addr,int val)
+{
+ MGAPtr pMga;
+ CARD16 ret;
+
+#if 0
+ if (addr == MGAREG_CRTCEXT_INDEX)
+ return;
+#endif
+ pMga = MGAPTR(pScrn);
+ ret = dbg_inreg16(pScrn,addr,0);
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "outreg16 : 0x%8x = 0x%x was 0x%x\n",addr,val,ret);
+ *(volatile CARD16 *)(pMga->IOBase + (addr)) = (val);
+}
+
+void
+dbg_outreg32(ScrnInfoPtr pScrn,int addr,int val)
+{
+ MGAPtr pMga;
+ CARD32 ret;
+
+ if (((addr & 0xff00) == 0x1c00)
+ && (addr != 0x1c04)
+/* && (addr != 0x1c1c) */
+ && (addr != 0x1c20)
+ && (addr != 0x1c24)
+ && (addr != 0x1c80)
+ && (addr != 0x1c8c)
+ && (addr != 0x1c94)
+ && (addr != 0x1c98)
+ && (addr != 0x1c9c)
+ ) {
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "refused address 0x%x\n",addr);
+ return;
+ }
+ pMga = MGAPTR(pScrn);
+ ret = dbg_inreg32(pScrn,addr,0);
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "outreg32 : 0x%8x = 0x%x was 0x%x\n",addr,val,ret);
+ *(volatile CARD32 *)(pMga->IOBase + (addr)) = (val);
+}
+#endif /* DEBUG */
+
+static void
+MGAG100BlackMagic(MGAPtr pMga)
+{
+ OUTREG(MGAREG_PLNWT, ~(CARD32)0x0);
+ /* reset memory */
+ OUTREG(MGAREG_MACCESS, 1<<15);
+ usleep(10);
+}
+
diff --git a/src/mga_esc.c b/src/mga_esc.c
new file mode 100644
index 0000000..dc0b7b3
--- /dev/null
+++ b/src/mga_esc.c
@@ -0,0 +1,791 @@
+/****************************************************************************
+* mga_esc.c
+*
+* ESC call implementation
+*
+* (C) Matrox Graphics, Inc.
+*****************************************************************************/
+
+#ifdef USEMGAHAL
+
+/* All drivers should typically include these */
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+
+/* All drivers need this */
+#include "xf86_ansic.h"
+
+#include "compiler.h"
+
+/* Drivers for PCI hardware need this */
+#include "xf86PciInfo.h"
+
+/* Drivers that need to access the PCI config space directly need this */
+#include "xf86Pci.h"
+
+/* All drivers initialising the SW cursor need this */
+#include "mipointer.h"
+
+/* All drivers implementing backing store need this */
+#include "mibstore.h"
+
+#include "micmap.h"
+
+#include "xf86DDC.h"
+#include "xf86RAC.h"
+#include "vbe.h"
+
+#include "fb.h"
+#include "cfb8_32.h"
+#include "dixstruct.h"
+
+#include "mga_reg.h"
+#include "mga.h"
+#include "mga_macros.h"
+
+/* ESC */
+LPMGAMODEINFO pMgaModeInfo[2] = {NULL};
+MGAMODEINFO TmpMgaModeInfo[2] = {{0}};
+
+/* ESC Implementation */
+static void EscHLeft(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscHRight(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscVUp(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscVDown(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscHLarger(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscHSmaller(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscVTaller(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscVSmaller(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscRefresh(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscRestoreVidParm(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscRead(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscWrite(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscHal(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscTest(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+static void EscMerged(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode);
+
+static LPMGAMODEINFO GetModeInfoPtr(ULONG ulScreen);
+static void GetVideoParameterStr(LPMGAMODEINFO pModeInfo, char *sResult);
+static Bool convertNumber(unsigned long *pulNumber, char *sNumber);
+
+
+static MGAEscFuncRec FunctionTable[] = {
+ {"hal", EscHal},
+ {"test", EscTest},
+ {"read", EscRead},
+ {"write", EscWrite},
+ {"left", EscHLeft},
+ {"right", EscHRight},
+ {"down", EscVDown},
+ {"up", EscVUp},
+ {"h+", EscHLarger},
+ {"h-", EscHSmaller},
+ {"v+", EscVTaller},
+ {"v-", EscVSmaller},
+ {"refresh", EscRefresh},
+ {"undo", EscRestoreVidParm},
+ {"merged", EscMerged},
+ {NULL,NULL}
+};
+
+
+void MGAFillDisplayModeStruct(DisplayModePtr pMode, LPMGAMODEINFO pModeInfo)
+{
+ pMode->Clock = pModeInfo->ulPixClock;
+
+ pMode->HDisplay = pModeInfo->ulDispWidth;
+ pMode->HSyncStart = pModeInfo->ulDispWidth
+ + pModeInfo->ulHFPorch;
+ pMode->HSyncEnd = pModeInfo->ulDispWidth
+ + pModeInfo->ulHFPorch
+ + pModeInfo->ulHSync;
+ pMode->HTotal = pModeInfo->ulDispWidth
+ + pModeInfo->ulHFPorch
+ + pModeInfo->ulHSync
+ + pModeInfo->ulHBPorch;
+
+ pMode->VDisplay = pModeInfo->ulDispHeight;
+ pMode->VSyncStart = pModeInfo->ulDispHeight
+ + pModeInfo->ulVFPorch;
+ pMode->VSyncEnd = pModeInfo->ulDispHeight
+ + pModeInfo->ulVFPorch
+ + pModeInfo->ulVSync;
+ pMode->VTotal = pModeInfo->ulDispHeight
+ + pModeInfo->ulVFPorch
+ + pModeInfo->ulVSync
+ + pModeInfo->ulVBPorch;
+
+ pMode->VRefresh = pModeInfo->ulRefreshRate;
+}
+
+static LPMGAMODEINFO GetModeInfoPtr(ULONG ulScreen)
+{
+
+ if ( !TmpMgaModeInfo[ulScreen].ulDispWidth )
+ {
+ TmpMgaModeInfo[ulScreen] = *pMgaModeInfo[ulScreen];
+ }
+
+ return &TmpMgaModeInfo[ulScreen];
+}
+
+
+static void GetVideoParameterStr(LPMGAMODEINFO pModeInfo, char *sResult)
+{
+ sprintf(sResult, "%d %d %d %d %d %d %d %d %d %d %d",
+ pModeInfo->ulDispWidth,
+ pModeInfo->ulDispHeight,
+ pModeInfo->ulBpp,
+ pModeInfo->ulPixClock,
+ pModeInfo->ulHFPorch,
+ pModeInfo->ulHSync,
+ pModeInfo->ulHBPorch,
+ pModeInfo->ulVFPorch,
+ pModeInfo->ulVSync,
+ pModeInfo->ulVBPorch,
+ pModeInfo->flSignalMode);
+}
+
+
+static float GetVRefresh(LPMGAMODEINFO pModeInfo)
+{
+ ULONG ulHTotal;
+ ULONG ulVTotal;
+
+ ulHTotal =
+ pModeInfo->ulDispWidth +
+ pModeInfo->ulHFPorch +
+ pModeInfo->ulHSync +
+ pModeInfo->ulHBPorch;
+
+ ulVTotal =
+ pModeInfo->ulDispHeight +
+ pModeInfo->ulVFPorch +
+ pModeInfo->ulVSync +
+ pModeInfo->ulVBPorch;
+
+ return ((float)pModeInfo->ulPixClock * 1000.0) / (ulHTotal * ulVTotal);
+}
+
+static void EscHal(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMGA = MGAPTR(pScrn);
+
+ if(pMGA->HALLoaded)
+ strcpy(sResult, "YES");
+ else
+ strcpy(sResult, "NO");
+
+}
+
+static void EscTest(ScrnInfoPtr pScrn, unsigned long *param, char
+*sResult, DisplayModePtr pMode)
+{
+ strcpy(sResult, "YES");
+}
+
+static void EscMerged(ScrnInfoPtr pScrn, unsigned long *param, char
+*sResult, DisplayModePtr pMode)
+{
+ strcpy(sResult, "YES");
+}
+
+static void EscRead(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ ULONG ulSource, ulAddr, ulData;
+ UCHAR ucIndex;
+
+ if ( (param[0] & 0xffff) < 2 )
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+
+ ulSource = param[1] >> 16;
+ ulAddr = param[1] & 0xffff;
+
+
+ switch( ulSource )
+ {
+ case 0:
+ ulData = INREG(ulAddr);
+ sprintf(sResult, "MGA[%04X] = 0x%08X", ulAddr, ulData);
+ break;
+ case 1:
+ ucIndex = INREG8(0x3c00);
+ OUTREG(0x3c00, (UCHAR)ulAddr);
+ ulData = (ULONG)INREG8(0x3c0a);
+ OUTREG(0x3c00, ucIndex);
+ sprintf(sResult, "DAC[%02X] = 0x%02X", ulAddr, ulData);
+ break;
+ case 2:
+ ucIndex = INREG8(0x1fd4);
+ OUTREG(0x1fd4, (UCHAR)ulAddr);
+ ulData = (ULONG)INREG8(0x1fd5);
+ OUTREG(0x1fd4, ucIndex);
+ sprintf(sResult, "CRTC[%02X] = 0x%02X", ulAddr, ulData);
+ break;
+ case 3:
+ ucIndex = INREG8(0x1fde);
+ OUTREG(0x1fde, (UCHAR)ulAddr);
+ ulData = (ULONG)INREG8(0x1fdf);
+ OUTREG(0x1fde, ucIndex);
+ sprintf(sResult, "CRTCEXT[%02X] = 0x%02X", ulAddr, ulData);
+ break;
+ default:
+ strcpy(sResult, "ERROR# 2");
+ break;
+ }
+}
+
+static void EscWrite(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ ULONG ulSource, ulAddr, ulData;
+ UCHAR ucIndex;
+
+ if ( (param[0] & 0xffff) < 3 )
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+ ulSource = param[1] >> 16;
+ ulAddr = param[1] & 0xffff;
+ ulData = param[2];
+
+
+ switch( ulSource )
+ {
+ case 0:
+ OUTREG(ulAddr, ulData);
+ strcpy(sResult, "OK");
+ break;
+ case 1:
+ ucIndex = INREG8(0x3c00);
+ OUTREG(0x3c00, (UCHAR)ulAddr);
+ OUTREG(0x3c0a, (UCHAR)ulData);
+ OUTREG(0x3c00, ucIndex);
+ strcpy(sResult, "OK");
+ break;
+ case 2:
+ ucIndex = INREG8(0x1fd4);
+ OUTREG(0x1fd4, (UCHAR)ulAddr);
+ OUTREG(0x1fd5, (UCHAR)ulData);
+ OUTREG(0x1fd4, ucIndex);
+ strcpy(sResult, "OK");
+ break;
+ case 3:
+ ucIndex = INREG8(0x1fde);
+ OUTREG(0x1fde, (UCHAR)ulAddr);
+ OUTREG(0x1fdf, (UCHAR)ulData);
+ OUTREG(0x1fde, ucIndex);
+ strcpy(sResult, "OK");
+ break;
+ default:
+ strcpy(sResult, "ERROR# 2");
+ break;
+ }
+}
+
+static void EscHLeft(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ LPMGAMODEINFO pModeInfo;
+
+ pModeInfo = GetModeInfoPtr(param[0] >> 16);
+
+ if ( !pMgaModeInfo )
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+
+ if (pModeInfo->ulHBPorch > (8 * param[1]) )
+ {
+ pModeInfo->ulHBPorch -=8 * param[1];
+ pModeInfo->ulHFPorch +=8 * param[1];
+ MGASetMode(pMga->pBoard, pModeInfo);
+ }
+
+ MGAFillDisplayModeStruct(pMode, pModeInfo);
+
+ GetVideoParameterStr(pModeInfo, sResult);
+}
+
+
+static void EscHRight(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ LPMGAMODEINFO pModeInfo;
+
+ pModeInfo = GetModeInfoPtr(param[0] >> 16);
+
+ if ( !pMgaModeInfo )
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+ if (pModeInfo->ulHFPorch > (8 * param[1]) )
+ {
+ pModeInfo->ulHFPorch -=8 * param[1];
+ pModeInfo->ulHBPorch +=8 * param[1];
+ MGASetMode(pMga->pBoard, pModeInfo);
+ }
+
+ MGAFillDisplayModeStruct(pMode, pModeInfo);
+
+ GetVideoParameterStr(pModeInfo, sResult);
+}
+
+
+
+static void EscVUp(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ LPMGAMODEINFO pModeInfo;
+
+ pModeInfo = GetModeInfoPtr(param[0] >> 16);
+
+ if ( !pMgaModeInfo )
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+ if (pModeInfo->ulVBPorch > (param[1]) )
+ {
+ pModeInfo->ulVBPorch -= param[1];
+ pModeInfo->ulVFPorch += param[1];
+ MGASetMode(pMga->pBoard, pModeInfo);
+ }
+
+ MGAFillDisplayModeStruct(pMode, pModeInfo);
+
+ GetVideoParameterStr(pModeInfo, sResult);
+}
+
+
+static void EscVDown(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ LPMGAMODEINFO pModeInfo;
+
+ pModeInfo = GetModeInfoPtr(param[0] >> 16);
+
+ if ( !pMgaModeInfo )
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+ if (pModeInfo->ulVFPorch >= (param[1]) )
+ {
+ pModeInfo->ulVFPorch -= param[1];
+ pModeInfo->ulVBPorch += param[1];
+ MGASetMode(pMga->pBoard, pModeInfo);
+ }
+
+ MGAFillDisplayModeStruct(pMode, pModeInfo);
+
+ GetVideoParameterStr(pModeInfo, sResult);
+}
+
+
+static void EscHLarger(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ LPMGAMODEINFO pModeInfo;
+ float fRefresh, fPixelClock;
+ ULONG ulStep;
+
+ pModeInfo = GetModeInfoPtr(param[0] >> 16);
+
+ if ( !pMgaModeInfo )
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+ if ((param[0] & 0xffff) > 1)
+ {
+
+ ulStep = param[1] * 8;
+ }
+ else
+ {
+
+ ulStep = 8;
+ }
+
+ fRefresh = GetVRefresh(pModeInfo);
+ fPixelClock = (float)pModeInfo->ulPixClock;
+ if (pModeInfo->ulHBPorch >= ulStep )
+ {
+ pModeInfo->ulHBPorch -= ulStep;
+ }
+ else
+ {
+ pModeInfo->ulHBPorch = 0;
+ }
+ pModeInfo->ulPixClock = (ULONG)( (fRefresh * fPixelClock) / GetVRefresh(pModeInfo));
+ MGASetMode(pMga->pBoard, pModeInfo);
+
+ MGAFillDisplayModeStruct(pMode, pModeInfo);
+
+ GetVideoParameterStr(pModeInfo, sResult);
+}
+
+
+static void EscHSmaller(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ LPMGAMODEINFO pModeInfo;
+ float fRefresh, fPixelClock;
+ ULONG ulStep;
+
+ pModeInfo = GetModeInfoPtr(param[0] >> 16);
+
+ if ( !pMgaModeInfo )
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+ if ((param[0] & 0xffff) > 1)
+ {
+
+ ulStep = param[1] * 8;
+ }
+ else
+ {
+
+ ulStep = 8;
+ }
+
+
+ fRefresh = GetVRefresh(pModeInfo);
+ fPixelClock = (float)pModeInfo->ulPixClock;
+ pModeInfo->ulHBPorch += ulStep;
+ pModeInfo->ulPixClock = (ULONG)( (fRefresh * fPixelClock) / GetVRefresh(pModeInfo));
+
+ MGASetMode(pMga->pBoard, pModeInfo);
+
+ MGAFillDisplayModeStruct(pMode, pModeInfo);
+
+ GetVideoParameterStr(pModeInfo, sResult);
+}
+
+static void EscVTaller(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ LPMGAMODEINFO pModeInfo;
+ float fRefresh, fPixelClock;
+ ULONG ulStep;
+
+ pModeInfo = GetModeInfoPtr(param[0] >> 16);
+
+ if ( !pMgaModeInfo )
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+ if ((param[0] & 0xffff) > 1)
+ {
+
+ ulStep = param[1];
+ }
+ else
+ {
+
+ ulStep = 1;
+ }
+
+ fRefresh = GetVRefresh(pModeInfo);
+ fPixelClock = (float)pModeInfo->ulPixClock;
+
+ if (pModeInfo->ulVBPorch >= ulStep )
+ {
+ pModeInfo->ulVBPorch -= ulStep;
+ }
+ else
+ {
+ pModeInfo->ulVBPorch = 0;
+ }
+
+ pModeInfo->ulPixClock = (ULONG)( (fRefresh * fPixelClock) / GetVRefresh(pModeInfo));
+ MGASetMode(pMga->pBoard, pModeInfo);
+
+ MGAFillDisplayModeStruct(pMode, pModeInfo);
+
+ GetVideoParameterStr(pModeInfo, sResult);
+}
+
+static void EscVSmaller(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ LPMGAMODEINFO pModeInfo;
+ float fRefresh, fPixelClock;
+ ULONG ulStep;
+
+ pModeInfo = GetModeInfoPtr(param[0] >> 16);
+
+ if ( !pMgaModeInfo )
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+ if ((param[0] & 0xffff) > 1)
+ {
+
+ ulStep = param[1];
+ }
+ else
+ {
+
+ ulStep = 1;
+ }
+
+
+ fRefresh = GetVRefresh(pModeInfo);
+ fPixelClock = (float)pModeInfo->ulPixClock;
+ pModeInfo->ulVFPorch += ulStep;
+ pModeInfo->ulPixClock = (ULONG)( (fRefresh * fPixelClock) / GetVRefresh(pModeInfo));
+ MGASetMode(pMga->pBoard, pModeInfo);
+
+ MGAFillDisplayModeStruct(pMode, pModeInfo);
+
+ GetVideoParameterStr(pModeInfo, sResult);
+}
+
+
+static void EscRefresh(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ LPMGAMODEINFO pModeInfo;
+ float fRefresh, fPixelClock;
+
+ pModeInfo = GetModeInfoPtr(param[0] >> 16);
+
+ if ( !pMgaModeInfo )
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+ if ((param[0] & 0xffff) < 2)
+ {
+ strcpy(sResult, "#error 1");
+ return;
+ }
+
+ fRefresh = GetVRefresh(pModeInfo);
+
+ fPixelClock = (float)pModeInfo->ulPixClock;
+ pModeInfo->ulPixClock = (ULONG)( ((float)param[1] * fPixelClock) / fRefresh);
+
+ pModeInfo->ulRefreshRate = param[1];
+
+ MGASetMode(pMga->pBoard, pModeInfo);
+
+ MGAFillDisplayModeStruct(pMode, pModeInfo);
+
+ GetVideoParameterStr(pModeInfo, sResult);
+}
+
+static void EscRestoreVidParm(ScrnInfoPtr pScrn, unsigned long *param, char *sResult, DisplayModePtr pMode)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ TmpMgaModeInfo[param[0] >> 16].ulDispWidth = 0;
+ MGASetMode(pMga->pBoard, pMgaModeInfo[param[0] >> 16]);
+
+ MGAFillDisplayModeStruct(pMode, pMgaModeInfo[param[0] >> 16]);
+
+ GetVideoParameterStr(pMgaModeInfo[param[0] >> 16], sResult);
+}
+
+static Bool convertNumber(unsigned long *pulNumber, char *sNumber)
+{
+ unsigned long i, ulDigit, shiftHex;
+ Bool bResult = TRUE;
+
+ if (sNumber == NULL)
+ {
+ return FALSE;
+ }
+
+
+ /* Convert number */
+ if ( (sNumber[0] == '0') && (sNumber[1] == 'x') )
+ {
+ shiftHex = 0;
+ *pulNumber = 0;
+
+ for (i = strlen(sNumber) - 1; i > 1; i--)
+ {
+ if (shiftHex > 28)
+ {
+ bResult = FALSE;
+ break;
+ }
+
+ if ( !isxdigit(sNumber[i]) )
+ {
+ bResult = FALSE;
+ break;
+ }
+
+ ulDigit = toupper(sNumber[i]) - '0';
+ if (ulDigit > 9)
+ {
+ ulDigit -= 7;
+ }
+ *pulNumber += ulDigit << shiftHex;
+ shiftHex += 4;
+ }
+ }
+ else
+ {
+ for (i = 0; i < strlen(sNumber); i++)
+ {
+ if ( !isdigit(sNumber[i]) )
+ {
+ bResult = FALSE;
+ break;
+ }
+ }
+ *pulNumber = atoi(sNumber);
+ }
+
+ return bResult;
+}
+
+static Bool GetEscCommand(char *cmdline, EscCmdStruct *escCmd)
+{
+ unsigned long i, paramIndex, ulHI;
+ Bool bResult;
+ char *pParameter, *function;
+
+ bResult = TRUE; /* success */
+
+ function = strtok(cmdline, " \t\n,");
+
+
+ escCmd->parameters[0] = 0;
+ if (function)
+ {
+ /* Find Screen */
+ if (function[1] == ':' )
+ {
+ escCmd->parameters[0] = (unsigned long)(function[0] - '0') << 16;
+ strncpy(escCmd->function, function+2, 32);
+ }
+ else
+ {
+ strncpy(escCmd->function, function, 32);
+ }
+
+ }
+ else
+ {
+ strcpy(escCmd->function, "#ERROR -1");
+ escCmd->parameters[0] = 0;
+ return FALSE;
+ }
+
+ paramIndex = 1;
+ while ( (pParameter = strtok(NULL, " \t\n,")) != NULL )
+ {
+ if (paramIndex > 31)
+ {
+ /* 32 parameters supported */
+ break;
+ }
+
+ i = 0;
+ while(pParameter[i] && pParameter[i] != ':')
+ {
+ i++;
+ }
+
+ if ( pParameter[i] )
+ {
+ pParameter[i] = '\0';
+ bResult = convertNumber(&escCmd->parameters[paramIndex], &pParameter[i+1]);
+ bResult |= convertNumber(&ulHI, pParameter);
+ escCmd->parameters[paramIndex] &= 0xffff;
+ escCmd->parameters[paramIndex] += ulHI << 16;
+ pParameter[i] = ':';
+ }
+ else
+ {
+ bResult = convertNumber(&escCmd->parameters[paramIndex], pParameter);
+ }
+
+
+ if (!bResult)
+ {
+ break;
+ }
+ paramIndex++;
+ }
+
+ escCmd->parameters[0] += paramIndex;
+ return bResult;
+
+}
+
+void MGAExecuteEscCmd(ScrnInfoPtr pScrn, char *cmdline , char *sResult, DisplayModePtr pMode)
+{
+ int i = 0;
+ int ulScreen = 0;
+ MGAPtr pMga = MGAPTR(pScrn);
+ EscCmdStruct EscCmd;
+
+ if (pMga->SecondCrtc)
+ {
+ ulScreen = 1;
+ }
+ else
+ {
+ ulScreen = 0;
+ }
+
+
+ if (FunctionTable[0].function && GetEscCommand(cmdline, &EscCmd) )
+ {
+ i = 0;
+
+ while ( FunctionTable[i].function && strcmp(FunctionTable[i].function, EscCmd.function) )
+ {
+ i++;
+ }
+
+ if (FunctionTable[i].function)
+ {
+ EscCmd.parameters[0] &= 0xffff;
+ EscCmd.parameters[0] |= ulScreen << 16;
+
+ FunctionTable[i].funcptr(pScrn, EscCmd.parameters, sResult, pMode);
+ }
+ else
+ {
+ strcpy(sResult, "error# -1");
+ }
+ }
+ else
+ {
+ strcpy(sResult, "error# -1");
+ }
+}
+#else
+int mga_foo;
+#endif
diff --git a/src/mga_g450pll.c b/src/mga_g450pll.c
new file mode 100644
index 0000000..6176549
--- /dev/null
+++ b/src/mga_g450pll.c
@@ -0,0 +1,523 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_g450pll.c,v 1.8 2002/09/16 18:05:56 eich Exp $ */
+
+/* All drivers should typically include these */
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+
+/* Drivers for PCI hardware need this */
+#include "xf86PciInfo.h"
+
+/* Drivers that need to access the PCI config space directly need this */
+#include "xf86Pci.h"
+
+#include "mga_bios.h"
+#include "mga_reg.h"
+#include "mga.h"
+
+#define MNP_TABLE_SIZE 64
+#define CLKSEL_MGA 0x0c
+#define PLLLOCK 0x40
+
+static CARD32 G450ApplyPFactor(ScrnInfoPtr pScrn, CARD8 ucP, CARD32 *pulFIn)
+{
+ if(!(ucP & 0x40))
+ {
+ *pulFIn = *pulFIn / (2L << (ucP & 3));
+ }
+
+ return TRUE;
+}
+
+
+static CARD32 G450RemovePFactor(ScrnInfoPtr pScrn, CARD8 ucP, CARD32 *pulFIn)
+{
+ if(!(ucP & 0x40))
+ {
+ *pulFIn = *pulFIn * (2L << (ucP & 3));
+ }
+
+ return TRUE;
+}
+
+
+static CARD32 G450CalculVCO(ScrnInfoPtr pScrn, CARD32 ulMNP, CARD32 *pulF)
+{
+ CARD8 ucM, ucN, ucP;
+
+ ucM = (CARD8)((ulMNP >> 16) & 0xff);
+ ucN = (CARD8)((ulMNP >> 8) & 0xff);
+ ucP = (CARD8)(ulMNP & 0x03);
+
+ *pulF = (27000 * (2 * (ucN + 2)) + ((ucM + 1) >> 1)) / (ucM + 1);
+
+ return TRUE;
+}
+
+
+static CARD32 G450CalculDeltaFreq(ScrnInfoPtr pScrn, CARD32 ulF1,
+ CARD32 ulF2, CARD32 *pulDelta)
+{
+ if(ulF2 < ulF1)
+ {
+ *pulDelta = ((ulF1 - ulF2) * 1000) / ulF1;
+ }
+ else
+ {
+ *pulDelta = ((ulF2 - ulF1) * 1000) / ulF1;
+ }
+
+ return TRUE;
+}
+
+
+
+
+static CARD32 G450FindNextPLLParam(ScrnInfoPtr pScrn, CARD32 ulFout,
+ CARD32 *pulPLLMNP)
+{
+ CARD8 ucM, ucN, ucP, ucS;
+ CARD32 ulVCO, ulVCOMin;
+
+ ucM = (CARD8)((*pulPLLMNP >> 16) & 0xff);
+ ucN = (CARD8)((*pulPLLMNP >> 8) & 0xff);
+ ucP = (CARD8)(*pulPLLMNP & 0x43);
+
+ ulVCOMin = 256000;
+
+ if(ulVCOMin >= (255L * 8000))
+ {
+ ulVCOMin = 230000;
+ }
+
+ if((ucM == 9) && (ucP & 0x40))
+ {
+ *pulPLLMNP = 0xffffffff;
+ } else if (ucM == 9)
+ {
+ if(ucP)
+ {
+ ucP--;
+ }
+ else
+ {
+ ucP = 0x40;
+ }
+ ucM = 0;
+ }
+ else
+ {
+ ucM++;
+ }
+
+ ulVCO = ulFout;
+
+ G450RemovePFactor(pScrn, ucP, &ulVCO);
+
+ if(ulVCO < ulVCOMin)
+ {
+ *pulPLLMNP = 0xffffffff;
+ }
+
+ if(*pulPLLMNP != 0xffffffff)
+ {
+ ucN = (CARD8)(((ulVCO * (ucM+1) + 27000)/(27000 * 2)) - 2);
+
+ ucS = 5;
+ if(ulVCO < 1300000) ucS = 4;
+ if(ulVCO < 1100000) ucS = 3;
+ if(ulVCO < 900000) ucS = 2;
+ if(ulVCO < 700000) ucS = 1;
+ if(ulVCO < 550000) ucS = 0;
+
+ ucP |= (CARD8)(ucS << 3);
+
+ *pulPLLMNP &= 0xff000000;
+ *pulPLLMNP |= (CARD32)ucM << 16;
+ *pulPLLMNP |= (CARD32)ucN << 8;
+ *pulPLLMNP |= (CARD32)ucP;
+
+#ifdef DEBUG
+ ErrorF("FINS_S: VCO = %d, S = %02X, *pulPLLMNP = %08X\n", ulVCO, (ULONG)ucS, *pulPLLMNP);
+#endif
+ }
+
+ return TRUE;
+}
+
+
+static CARD32 G450FindFirstPLLParam(ScrnInfoPtr pScrn, CARD32 ulFout,
+ CARD32 *pulPLLMNP)
+{
+ CARD8 ucP;
+ CARD32 ulVCO;
+ CARD32 ulVCOMax;
+
+ /* Default value */
+ ulVCOMax = 1300000;
+
+ if(ulFout > (ulVCOMax/2))
+ {
+ ucP = 0x40;
+ ulVCO = ulFout;
+ }
+ else
+ {
+ ucP = 3;
+ ulVCO = ulFout;
+ G450RemovePFactor(pScrn, ucP, &ulVCO);
+ while(ucP && (ulVCO > ulVCOMax))
+ {
+ ucP--;
+ ulVCO = ulFout;
+ G450RemovePFactor(pScrn, ucP, &ulVCO);
+ }
+ }
+
+ if(ulVCO > ulVCOMax)
+ {
+ *pulPLLMNP = 0xffffffff;
+ }
+ else
+ {
+ /* Pixel clock: 1 */
+ *pulPLLMNP = (1 << 24) + 0xff0000 + ucP;
+ G450FindNextPLLParam(pScrn, ulFout, pulPLLMNP);
+ }
+
+ return TRUE;
+
+}
+
+
+static CARD32 G450WriteMNP(ScrnInfoPtr pScrn, CARD32 ulMNP)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr pReg;
+
+ pReg = &pMga->ModeReg;
+
+ if (!pMga->SecondCrtc) {
+ outMGAdac(MGA1064_PIX_PLLC_M, (CARD8)(ulMNP >> 16));
+ outMGAdac(MGA1064_PIX_PLLC_N, (CARD8)(ulMNP >> 8));
+ outMGAdac(MGA1064_PIX_PLLC_P, (CARD8) ulMNP);
+ } else {
+ outMGAdac(MGA1064_VID_PLL_M, (CARD8)(ulMNP >> 16));
+ outMGAdac(MGA1064_VID_PLL_N, (CARD8)(ulMNP >> 8));
+ outMGAdac(MGA1064_VID_PLL_P, (CARD8) ulMNP);
+ }
+ return TRUE;
+}
+
+static CARD32 G450ReadMNP(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARegPtr pReg;
+ CARD32 ret = 0;
+
+ pReg = &pMga->ModeReg;
+
+ if (!pMga->SecondCrtc) {
+ ret = (CARD8)inMGAdac(MGA1064_PIX_PLLC_M) << 16;
+ ret |= (CARD8)inMGAdac(MGA1064_PIX_PLLC_N) << 8;
+ ret |= (CARD8)inMGAdac(MGA1064_PIX_PLLC_P);
+ } else {
+ ret = (CARD8)inMGAdac(MGA1064_VID_PLL_M) << 16;
+ ret |= (CARD8)inMGAdac(MGA1064_VID_PLL_N) << 8;
+ ret |= (CARD8)inMGAdac(MGA1064_VID_PLL_P);
+ }
+ return ret;
+}
+
+
+static CARD32 G450CompareMNP(ScrnInfoPtr pScrn, CARD32 ulFout, CARD32 ulMNP1,
+ CARD32 ulMNP2, long *pulResult)
+{
+ CARD32 ulFreq, ulDelta1, ulDelta2;
+
+ G450CalculVCO(pScrn, ulMNP1, &ulFreq);
+ G450ApplyPFactor(pScrn, (CARD8) ulMNP1, &ulFreq);
+ G450CalculDeltaFreq(pScrn, ulFout, ulFreq, &ulDelta1);
+
+ G450CalculVCO(pScrn, ulMNP2, &ulFreq);
+ G450ApplyPFactor(pScrn, (CARD8) ulMNP2, &ulFreq);
+ G450CalculDeltaFreq(pScrn, ulFout, ulFreq, &ulDelta2);
+
+ if(ulDelta1 < ulDelta2)
+ {
+ *pulResult = -1;
+ }
+ else if(ulDelta1 > ulDelta2)
+ {
+ *pulResult = 1;
+ }
+ else
+ {
+ *pulResult = 0;
+ }
+
+ if((ulDelta1 <= 5) && (ulDelta2 <= 5))
+ {
+ if((ulMNP1 & 0xff0000) < (ulMNP2 & 0xff0000))
+ {
+ *pulResult = -1;
+ }
+ else if((ulMNP1 & 0xff0000) > (ulMNP2 & 0xff0000))
+ {
+ *pulResult = 1;
+ }
+ }
+
+ return TRUE;
+}
+
+
+static CARD32 G450IsPllLocked(ScrnInfoPtr pScrn, Bool *lpbLocked)
+{
+ CARD32 ulFallBackCounter, ulLockCount, ulCount;
+ CARD8 ucPLLStatus;
+
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ /* Pixel PLL */
+ if (!pMga->SecondCrtc)
+ OUTREG8(0x3c00, 0x4f); /* Pixel PLL */
+ else
+ OUTREG8(0x3c00, 0x8c); /* Video PLL */
+
+ ulFallBackCounter = 0;
+
+ do
+ {
+ ucPLLStatus = INREG8(0x3c0a);
+ ulFallBackCounter++;
+ } while(!(ucPLLStatus & PLLLOCK) && (ulFallBackCounter < 1000));
+
+ ulLockCount = 0;
+ if(ulFallBackCounter < 1000)
+ {
+ for(ulCount = 0; ulCount < 100; ulCount++)
+ {
+ ucPLLStatus = INREG8(0x3c0a);
+ if(ucPLLStatus & PLLLOCK)
+ {
+ ulLockCount++;
+ }
+ }
+ }
+
+ *lpbLocked = ulLockCount >= 90;
+
+ return TRUE;
+}
+
+
+double MGAG450SetPLLFreq(ScrnInfoPtr pScrn, long f_out)
+{
+ Bool bFoundValidPLL;
+ Bool bLocked;
+ CARD8 ucMisc, ucSIndex, ucSTable[4];
+ CARD32 ulMaxIndex;
+ CARD32 ulMNP;
+ CARD32 ulMNPTable[MNP_TABLE_SIZE];
+ CARD32 ulIndex;
+ CARD32 ulTryMNP;
+ long lCompareResult;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+#ifdef DEBUG
+ xf86DrvMsg(pScrn->scrnIndex,X_INFO, "Restoring PLLClk = %d\n",f_out);
+#endif
+ G450FindFirstPLLParam(pScrn, f_out, &ulMNP);
+ ulMNPTable[0] = ulMNP;
+ G450FindNextPLLParam(pScrn, f_out, &ulMNP);
+ ulMaxIndex = 1;
+ while(ulMNP != 0xffffffff)
+ {
+ int ulIndex;
+ Bool bSkipValue;
+
+ bSkipValue = FALSE;
+ if(ulMaxIndex == MNP_TABLE_SIZE)
+ {
+ G450CompareMNP(pScrn, f_out, ulMNP, ulMNPTable[MNP_TABLE_SIZE - 1],
+ &lCompareResult);
+
+ if(lCompareResult > 0)
+ {
+ bSkipValue = TRUE;
+ }
+ else
+ {
+ ulMaxIndex--;
+ }
+ }
+
+ if(!bSkipValue)
+ {
+ for(ulIndex = ulMaxIndex; !bSkipValue && (ulIndex > 0); ulIndex--)
+ {
+ G450CompareMNP(pScrn, f_out, ulMNP, ulMNPTable[ulIndex - 1],
+ &lCompareResult);
+
+ if(lCompareResult < 0)
+ {
+ ulMNPTable[ulIndex] = ulMNPTable[ulIndex - 1];
+ }
+ else
+ {
+ break;
+ }
+ }
+ ulMNPTable[ulIndex] = ulMNP;
+ ulMaxIndex++;
+ }
+
+ G450FindNextPLLParam(pScrn, f_out, &ulMNP);
+ }
+
+ bFoundValidPLL = FALSE;
+ ulMNP = 0;
+
+ /* For pixel pll */
+ if (!pMga->SecondCrtc) {
+ ucMisc = INREG8(0x1FCC);
+ OUTREG8(0x1fc2, (CARD8)(ucMisc | CLKSEL_MGA));
+ }
+
+ for(ulIndex = 0; !bFoundValidPLL && (ulIndex < ulMaxIndex); ulIndex++)
+ {
+ ulTryMNP = ulMNPTable[ulIndex];
+
+ ucSTable[3] = 0xff;
+ ucSTable[2] = 0xff;
+ ucSTable[0] = (CARD8) (ulTryMNP & 0x38);
+
+ if (ucSTable[0] != 0) {
+ ucSTable[1] = ucSTable[0] - 8;
+ if (ucSTable[0] != 0x38) {
+ ucSTable[2] = ucSTable[0] + 8;
+ }
+ } else {
+ ucSTable[1] = 8;
+ }
+
+ for(ucSIndex = 0; !bFoundValidPLL && (ucSTable[ucSIndex] != 0xff);
+ ucSIndex++) {
+ ulTryMNP &= 0xffffffc7;
+ ulTryMNP |= (CARD32)ucSTable[ucSIndex];
+
+ bLocked = TRUE;
+ if((ulMNPTable[ulIndex] & 0xff00) < 0x300 ||
+ (ulMNPTable[ulIndex] & 0xff00) > 0x7a00)
+ {
+ bLocked = FALSE;
+ }
+
+ if(bLocked)
+ {
+ G450WriteMNP(pScrn, ulTryMNP - 0x300);
+ G450IsPllLocked(pScrn, &bLocked);
+ }
+
+ if(bLocked)
+ {
+ G450WriteMNP(pScrn, ulTryMNP + 0x300);
+ G450IsPllLocked(pScrn, &bLocked);
+ }
+
+ if(bLocked)
+ {
+ G450WriteMNP(pScrn, ulTryMNP - 0x200);
+ G450IsPllLocked(pScrn, &bLocked);
+ }
+
+ if(bLocked)
+ {
+ G450WriteMNP(pScrn, ulTryMNP + 0x200);
+ G450IsPllLocked(pScrn, &bLocked);
+ }
+
+ if(bLocked)
+ {
+ G450WriteMNP(pScrn, ulTryMNP - 0x100);
+ G450IsPllLocked(pScrn, &bLocked);
+ }
+
+ if(bLocked)
+ {
+ G450WriteMNP(pScrn, ulTryMNP + 0x100);
+ G450IsPllLocked(pScrn, &bLocked);
+ }
+
+ if(bLocked)
+ {
+ G450WriteMNP(pScrn, ulTryMNP);
+ G450IsPllLocked(pScrn, &bLocked);
+ }
+ else if(!ulMNP)
+ {
+ G450WriteMNP(pScrn, ulTryMNP);
+ G450IsPllLocked(pScrn, &bLocked);
+ if(bLocked)
+ {
+ ulMNP = ulMNPTable[ulIndex];
+ }
+ bLocked = FALSE;
+ }
+
+ if(bLocked)
+ {
+ bFoundValidPLL = TRUE;
+ }
+ }
+ }
+
+ if(!bFoundValidPLL)
+ {
+ if(ulMNP)
+ {
+ G450WriteMNP(pScrn, ulMNP);
+ }
+ else
+ {
+ G450WriteMNP(pScrn, ulMNPTable[0]);
+ }
+ }
+
+ return TRUE;
+}
+
+long
+MGAG450SavePLLFreq(ScrnInfoPtr pScrn)
+{
+ CARD32 ulMNP = G450ReadMNP(pScrn);
+ CARD8 ucP;
+ CARD32 freq;
+
+ G450CalculVCO(pScrn, ulMNP, &freq);
+ ucP = (CARD8)(ulMNP & 0x03);
+ G450ApplyPFactor(pScrn, ucP, &freq);
+
+#ifdef DEBUG
+ xf86DrvMsg(pScrn->scrnIndex,X_INFO,"Saved PLLClk = %d\n",freq);
+#endif
+ return freq;
+}
+
+#ifdef DEBUG
+void
+MGAG450PrintPLL(ScrnInfoPtr pScrn)
+{
+ CARD32 ulMNP = G450ReadMNP(pScrn);
+ CARD8 ucP;
+ CARD32 freq;
+
+ G450CalculVCO(pScrn, ulMNP, &freq);
+ ucP = (CARD8)(ulMNP & 0x03);
+ G450ApplyPFactor(pScrn, ucP, &freq);
+
+ xf86DrvMsg(pScrn->scrnIndex,X_INFO,"MGAGClock = %d -- MNP = 0x%x\n",
+ freq,ulMNP);
+}
+#endif
diff --git a/src/mga_halmod.c b/src/mga_halmod.c
new file mode 100644
index 0000000..4308f85
--- /dev/null
+++ b/src/mga_halmod.c
@@ -0,0 +1,38 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_halmod.c,v 1.1 2000/12/06 15:35:21 eich Exp $ */
+#include "xf86Module.h"
+
+#ifdef XFree86LOADER
+
+#define HAL_MAJOR_VERSION 1
+#define HAL_MINOR_VERSION 0
+#define HAL_PATCHLEVEL 0
+
+static MODULESETUPPROTO(halSetup);
+
+static XF86ModuleVersionInfo halVersRec =
+{
+ "mga_hal",
+ MODULEVENDORSTRING,
+ MODINFOSTRING1,
+ MODINFOSTRING2,
+ XF86_VERSION_CURRENT,
+ HAL_MAJOR_VERSION, HAL_MINOR_VERSION, HAL_PATCHLEVEL,
+ ABI_CLASS_VIDEODRV, /* This is a video driver */
+ ABI_VIDEODRV_VERSION,
+ MOD_CLASS_NONE,
+ {0,0,0,0}
+};
+
+/*
+ * This is the module init data.
+ * Its name has to be the driver name followed by ModuleData.
+ */
+XF86ModuleData mga_halModuleData = { &halVersRec, halSetup, NULL };
+
+static pointer
+halSetup(pointer module, pointer opts, int *errmaj, int *errmin)
+{
+ return (pointer)1;
+}
+
+#endif /* XFree86LOADER */
diff --git a/src/mga_hwcurs.c b/src/mga_hwcurs.c
new file mode 100644
index 0000000..8b4e66b
--- /dev/null
+++ b/src/mga_hwcurs.c
@@ -0,0 +1,41 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_hwcurs.c,v 1.9 1999/03/14 03:22:00 dawes Exp $ */
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+
+#include "xf86Pci.h"
+#include "xf86PciInfo.h"
+
+#include "mga_bios.h"
+#include "mga.h"
+#include "mga_reg.h"
+
+Bool
+MGAHWCursorInit(ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGARamdacPtr MGAdac = &pMga->Dac;
+ xf86CursorInfoPtr infoPtr;
+
+ if (!MGAdac->isHwCursor)
+ return FALSE;
+
+ infoPtr = xf86CreateCursorInfoRec();
+ if(!infoPtr) return FALSE;
+
+ pMga->CursorInfoRec = infoPtr;
+
+ infoPtr->MaxWidth = MGAdac->CursorMaxWidth;
+ infoPtr->MaxHeight = MGAdac->CursorMaxHeight;
+ infoPtr->Flags = MGAdac->CursorFlags;
+ infoPtr->SetCursorColors = MGAdac->SetCursorColors;
+ infoPtr->SetCursorPosition = MGAdac->SetCursorPosition;
+ infoPtr->LoadCursorImage = MGAdac->LoadCursorImage;
+ infoPtr->HideCursor = MGAdac->HideCursor;
+ infoPtr->ShowCursor = MGAdac->ShowCursor;
+ infoPtr->UseHWCursor = MGAdac->UseHWCursor;
+
+ return(xf86InitCursor(pScreen, infoPtr));
+}
diff --git a/src/mga_macros.h b/src/mga_macros.h
new file mode 100644
index 0000000..d985081
--- /dev/null
+++ b/src/mga_macros.h
@@ -0,0 +1,118 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_macros.h,v 1.22 2002/02/20 17:17:50 dawes Exp $ */
+
+#ifndef _MGA_MACROS_H_
+#define _MGA_MACROS_H_
+
+#ifndef PSZ
+#define PSZ 8
+#endif
+
+#if PSZ == 8
+#define REPLICATE(r) r &= 0xFF; r |= r << 8; r |= r << 16
+#elif PSZ == 16
+#define REPLICATE(r) r &= 0xFFFF; r |= r << 16
+#elif PSZ == 24
+#define REPLICATE(r) r &= 0xFFFFFF; r |= r << 24
+#else
+#define REPLICATE(r) /* */
+#endif
+
+#define RGBEQUAL(c) (!((((c) >> 8) ^ (c)) & 0xffff))
+
+#ifdef XF86DRI
+#define MGA_SYNC_XTAG 0x275f4200
+
+#define MGABUSYWAIT() do { \
+OUTREG(MGAREG_DWGSYNC, MGA_SYNC_XTAG); \
+while(INREG(MGAREG_DWGSYNC) != MGA_SYNC_XTAG) ; \
+}while(0);
+
+#endif
+
+#define MGAISBUSY() (INREG8(MGAREG_Status + 2) & 0x01)
+
+#define WAITFIFO(cnt) \
+ if(!pMga->UsePCIRetry) {\
+ register int n = cnt; \
+ if(n > pMga->FifoSize) n = pMga->FifoSize; \
+ while(pMga->fifoCount < (n))\
+ pMga->fifoCount = INREG8(MGAREG_FIFOSTATUS);\
+ pMga->fifoCount -= n;\
+ }
+
+#define XYADDRESS(x,y) \
+ ((y) * pMga->CurrentLayout.displayWidth + (x) + pMga->YDstOrg)
+
+#define MAKEDMAINDEX(index) ((((index) >> 2) & 0x7f) | (((index) >> 6) & 0x80))
+
+#define DMAINDICES(one,two,three,four) \
+ ( MAKEDMAINDEX(one) | \
+ (MAKEDMAINDEX(two) << 8) | \
+ (MAKEDMAINDEX(three) << 16) | \
+ (MAKEDMAINDEX(four) << 24) )
+
+#if PSZ == 24
+#define SET_PLANEMASK(p) /**/
+#else
+#define SET_PLANEMASK(p) \
+ if(!(pMga->AccelFlags & MGA_NO_PLANEMASK) && ((p) != pMga->PlaneMask)) { \
+ pMga->PlaneMask = (p); \
+ REPLICATE((p)); \
+ OUTREG(MGAREG_PLNWT,(p)); \
+ }
+#endif
+
+#define SET_FOREGROUND(c) \
+ if((c) != pMga->FgColor) { \
+ pMga->FgColor = (c); \
+ REPLICATE((c)); \
+ OUTREG(MGAREG_FCOL,(c)); \
+ }
+
+#define SET_BACKGROUND(c) \
+ if((c) != pMga->BgColor) { \
+ pMga->BgColor = (c); \
+ REPLICATE((c)); \
+ OUTREG(MGAREG_BCOL,(c)); \
+ }
+
+#define DISABLE_CLIP() { \
+ pMga->AccelFlags &= ~CLIPPER_ON; \
+ WAITFIFO(1); \
+ OUTREG(MGAREG_CXBNDRY, 0xFFFF0000); }
+
+#ifdef XF86DRI
+#define CHECK_DMA_QUIESCENT(pMGA, pScrn) { \
+ if (!pMGA->haveQuiescense) { \
+ pMGA->GetQuiescence( pScrn ); \
+ } \
+}
+#else
+#define CHECK_DMA_QUIESCENT(pMGA, pScrn)
+#endif
+
+#ifdef USEMGAHAL
+#define HAL_CHIPSETS ((pMga->Chipset == PCI_CHIP_MGAG200_PCI) || \
+ (pMga->Chipset == PCI_CHIP_MGAG200) || \
+ (pMga->Chipset == PCI_CHIP_MGAG400) || \
+ (pMga->Chipset == PCI_CHIP_MGAG550))
+
+#define MGA_HAL(x) { \
+ MGAPtr pMga = MGAPTR(pScrn); \
+ if (pMga->HALLoaded && HAL_CHIPSETS) { x; } \
+}
+#define MGA_NOT_HAL(x) { \
+ MGAPtr pMga = MGAPTR(pScrn); \
+ if (!pMga->HALLoaded || !HAL_CHIPSETS) { x; } \
+}
+#else
+#define MGA_NOT_HAL(x) { x; }
+#endif
+
+#define MGAISGx50(x) ( (((x)->Chipset == PCI_CHIP_MGAG400) && ((x)->ChipRev >= 0x80)) || \
+ ((x)->Chipset == PCI_CHIP_MGAG550) )
+
+#define MGA_DH_NEEDS_HAL(x) (((x)->Chipset == PCI_CHIP_MGAG400) && \
+ ((x)->ChipRev < 0x80))
+
+#endif /* _MGA_MACROS_H_ */
diff --git a/src/mga_map.h b/src/mga_map.h
new file mode 100644
index 0000000..b41ca69
--- /dev/null
+++ b/src/mga_map.h
@@ -0,0 +1,17 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_map.h,v 1.2 2001/07/25 15:05:06 dawes Exp $ */
+
+#if !defined(UNIXCPP) || defined(ANSICPP)
+#define CATNAME(prefix,subname) prefix##subname
+#else
+#define CATNAME(prefix,subname) prefix/**/subname
+#endif
+
+#if PSZ == 8
+#define MGANAME(subname) CATNAME(Mga8,subname)
+#elif PSZ == 16
+#define MGANAME(subname) CATNAME(Mga16,subname)
+#elif PSZ == 24
+#define MGANAME(subname) CATNAME(Mga24,subname)
+#elif PSZ == 32
+#define MGANAME(subname) CATNAME(Mga32,subname)
+#endif
diff --git a/src/mga_merge.c b/src/mga_merge.c
new file mode 100644
index 0000000..e70382f
--- /dev/null
+++ b/src/mga_merge.c
@@ -0,0 +1,960 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_merge.c,v 1.2 2002/09/18 21:25:45 tsi Exp $ */
+
+/* All drivers should typically include these */
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+
+/* All drivers need this */
+#include "xf86_ansic.h"
+
+#include "compiler.h"
+
+/* Drivers for PCI hardware need this */
+#include "xf86PciInfo.h"
+#include "mga.h"
+#include "mga_macros.h"
+#include "mga_reg.h"
+#include "mga_merge.h"
+
+#include "fbdevhw.h"
+
+static int
+StrToRanges(range* r, char* s) {
+ float num=0.0;
+ int rangenum=0;
+ Bool gotdash = FALSE;
+ Bool nextdash = FALSE;
+ char* strnum=NULL;
+ do {
+ switch(*s) {
+ case '0': case '1': case '2': case '3': case '4': case '5':
+ case '6': case '7': case '8': case '9': case '.':
+ if(strnum == NULL) {
+ strnum = s;
+ gotdash = nextdash;
+ nextdash = FALSE;
+ }
+
+ break;
+ case '-':
+ case ' ': case 0:
+ if(strnum == NULL) break; /*is extra seperator */
+ if(strnum != NULL) sscanf(strnum,"%f",&num);
+ if(gotdash) /*if wasn't singlet: correct. */
+ r[rangenum-1].hi = num;
+ else { /*first, assume singlet */
+ r[rangenum].lo = num;
+ r[rangenum].hi = num;
+ rangenum++;
+ }
+ strnum = NULL;
+ if(*s == '-')
+ nextdash = (rangenum != 0); /*ignore dash if before any number.*/
+ break;
+ default :
+ return 0;
+ }
+ } while(*(s++) != 0); /* run loop for every char including null terminator.*/
+
+ return rangenum;
+}
+
+
+/* Copys mode i, links the result to dest, and returns it.
+ * Links i and j in Private record.
+ * if dest is NULL, return value is copy of i linked to itself.
+ */
+static DisplayModePtr
+CopyModeNLink(ScrnInfoPtr pScrn, DisplayModePtr dest, DisplayModePtr i, DisplayModePtr j, MgaScrn2Rel srel) {
+ DisplayModePtr mode;
+ int dx = 0,dy = 0;
+ /* start with first node */
+ mode = xalloc(sizeof(DisplayModeRec));
+ memcpy(mode,i, sizeof(DisplayModeRec));
+ mode->Private = xalloc(sizeof(MergedDisplayModeRec));
+ ((MergedDisplayModePtr)mode->Private)->Monitor1 = i;
+ ((MergedDisplayModePtr)mode->Private)->Monitor2 = j;
+ ((MergedDisplayModePtr)mode->Private)->Monitor2Pos = srel;
+ mode->PrivSize = 0;
+
+ switch(srel) {
+ case mgaLeftOf:
+ case mgaRightOf:
+ dx = min(pScrn->virtualX,i->HDisplay + j->HDisplay) - mode->HDisplay;
+ dy = min(pScrn->virtualY, max(i->VDisplay,j->VDisplay)) - mode->VDisplay;
+ break;
+ case mgaAbove:
+ case mgaBelow:
+ dy = min(pScrn->virtualY,i->VDisplay + j->VDisplay) - mode->VDisplay;
+ dx = min(pScrn->virtualX, max(i->HDisplay,j->HDisplay)) - mode->HDisplay;
+ break;
+ case mgaClone:
+ dx = min(pScrn->virtualX, max(i->HDisplay,j->HDisplay)) - mode->HDisplay;
+ dy = min(pScrn->virtualY, max(i->VDisplay,j->VDisplay)) - mode->VDisplay;
+ break;
+ }
+ mode->HDisplay += dx;
+ mode->HSyncStart += dx;
+ mode->HSyncEnd += dx;
+ mode->HTotal += dx;
+ mode->VDisplay += dy;
+ mode->VSyncStart += dy;
+ mode->VSyncEnd += dy;
+ mode->VTotal += dy;
+ mode->Clock = 0; /* Shows we're in Merge mode. */
+
+ mode->next = mode;
+ mode->prev = mode;
+
+ if(dest) {
+ /* Insert node after "dest" */
+ mode->next = dest->next;
+ dest->next->prev = mode;
+ mode->prev = dest;
+ dest->next = mode;
+ }
+
+ return mode;
+}
+
+static DisplayModePtr
+GetModeFromName(char* str, DisplayModePtr i)
+{
+ DisplayModePtr c = i;
+ if(!i) return NULL;
+ do {
+ if(strcmp(str,c->name) == 0) return c;
+ c = c->next;
+ } while(c != i);
+ return NULL;
+}
+
+/* takes a config file string of MetaModes and generates a MetaModeList */
+static DisplayModePtr
+GenerateModeList(ScrnInfoPtr pScrn, char* str,
+ DisplayModePtr i, DisplayModePtr j, MgaScrn2Rel srel) {
+ char* strmode = str;
+ char modename[256];
+ Bool gotdash = FALSE;
+ MgaScrn2Rel sr;
+
+ DisplayModePtr mode1 = NULL;
+ DisplayModePtr mode2 = NULL;
+ DisplayModePtr result = NULL;
+ do {
+ switch(*str) {
+ case 0:
+ case '-':
+ case ' ':
+ if((strmode != str)) {/*we got a mode */
+ /* read new entry */
+ strncpy(modename,strmode,str - strmode);
+ modename[str - strmode] = 0;
+
+ if(gotdash) {
+ if(mode1 == NULL) return NULL;
+ mode2 = GetModeFromName(modename,j);
+ if(!mode2) {
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Mode: \"%s\" is not a supported mode for monitor 2\n",modename);
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Skipping metamode \"%s-%s\".\n",mode1->name,modename);
+ mode1 = NULL;
+ }
+ } else {
+ mode1 = GetModeFromName(modename,i);
+ if(!mode1) {
+ char* tmps = str;
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Mode: \"%s\" is not a supported mode for monitor 1\n",modename);
+ /* find if a monitor2 mode follows */
+ gotdash = FALSE;
+ while(*tmps == ' ') tmps++;
+ if(*tmps == '-') { /* skip the next mode */
+ tmps++;
+ while((*tmps == ' ') && (*tmps != 0)) tmps++; /*skip spaces */
+ while((*tmps != ' ') && (*tmps != '-') && (*tmps != 0)) tmps++; /*skip modename */
+ /* for error message */
+ strncpy(modename,strmode,tmps - strmode);
+ modename[tmps - strmode] = 0;
+ str = tmps-1;
+ }
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Skipping metamode \"%s\".\n",modename);
+ mode1 = NULL;
+ }
+ }
+ gotdash = FALSE;
+ }
+ strmode = str+1; /* number starts on next char */
+ gotdash |= (*str == '-');
+
+ if(*str != 0) break; /* if end of string, we wont get a chance to catch a char and run the
+ default case. do it now */
+
+ default:
+ if(!gotdash && mode1) { /* complete previous pair */
+ sr = srel;
+ if(!mode2) {
+ mode2 = GetModeFromName(mode1->name,j);
+ sr = mgaClone;
+ }
+ if(!mode2) {
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Mode: \"%s\" is not a supported mode for monitor 2\n",mode1->name);
+ xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ "Skipping clone mode \"%s\".\n");
+ mode1 = NULL;
+ } else {
+ result = CopyModeNLink(pScrn,result,mode1,mode2,sr);
+ mode1 = NULL;
+ mode2 = NULL;
+ }
+ }
+ break;
+
+ }
+ } while(*(str++) != 0);
+ return result;
+}
+
+
+/* second CRTC init funcitons. Used to check monitor timings and refreshes.
+ * this function looses lots of maintainability points due to redundancy,
+ * but it still was the cleanest and least-intrusive way I found. */
+
+Bool
+MGAPreInitMergedFB(ScrnInfoPtr pScrn1, int flags)
+{
+ ScrnInfoPtr pScrn;
+ MGAPtr pMga;
+ MGAPtr pMga1;
+ MessageType from;
+ int i;
+ char* s;
+ ClockRangePtr clockRanges;
+#ifdef USEMGAHAL
+ ULONG status;
+#endif
+ MgaScrn2Rel Monitor2Pos;
+
+ xf86DrvMsg(pScrn1->scrnIndex, X_INFO, "==== Start of second screen initialization ====\n");
+ pScrn = xalloc(sizeof(ScrnInfoRec));
+ memcpy(pScrn,pScrn1,sizeof(ScrnInfoRec));
+
+ pScrn->driverPrivate = NULL;
+ /* Allocate the MGARec driverPrivate */
+ if (!MGAGetRec(pScrn)) {
+ return FALSE;
+ }
+
+ pMga = MGAPTR(pScrn);
+#ifdef USEMGAHAL
+ pMga->pMgaModeInfo = NULL; /*will be allocated later if NULL*/
+#endif
+ pMga1 = MGAPTR(pScrn1);
+ pMga1->pScrn2 = pScrn;
+
+ /* Get the entity, and make sure it is PCI. */
+ pMga->pEnt = pMga1->pEnt;
+
+ /* Set pMga->device to the relevant Device section */
+ pMga->device = pMga1->device;
+
+ if (flags & PROBE_DETECT) {
+ MGAProbeDDC(pScrn, pMga->pEnt->index); /*FIXME make shure this probes second monitor */
+ return TRUE;
+ }
+
+ pMga->PciTag = pMga1->PciTag;
+
+ pMga->Primary = pMga1->Primary;
+
+ /* Set pScrn->monitor */
+ {
+ pScrn->monitor = xalloc(sizeof(MonRec));
+ /* copy everything we don't care about */
+ memcpy(pScrn->monitor,pScrn1->monitor,sizeof(MonRec));
+ pScrn->monitor->DDC = NULL; /*FIXME:have to try this */
+ if ((s = xf86GetOptValString(pMga1->Options, OPTION_HSYNC2))) {
+ pScrn->monitor->nHsync = StrToRanges(pScrn->monitor->hsync,s);
+ }
+ if ((s = xf86GetOptValString(pMga1->Options, OPTION_VREFRESH2))) {
+ pScrn->monitor->nVrefresh = StrToRanges(pScrn->monitor->vrefresh,s);
+ }
+
+
+
+ }
+
+ pMga->SecondCrtc = TRUE;
+ pMga->HWCursor = FALSE;
+ pScrn->AdjustFrame = MGAAdjustMergeFrames;
+ pScrn1->AdjustFrame = MGAAdjustMergeFrames;
+
+/* if (!xf86SetDepthBpp(pScrn, 8, 8, 8, flags24)) FIXME:have to copy result form scrn1
+ if (!xf86SetWeight(pScrn, zeros, zeros)) {
+*/
+
+ /* We use a programamble clock */
+ pScrn->progClock = TRUE;
+
+ /* Collect all of the relevant option flags (fill in pScrn->options) */
+ pScrn->options = pScrn1->options;
+
+/* xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pMga->Options);*/
+ pMga->Options = pMga1->Options;
+
+
+ /* Set the bits per RGB for 8bpp mode */
+ if (pScrn->depth == 8)
+ pScrn->rgbBits = 8;
+
+ /*
+ * Set the Chipset and ChipRev, allowing config file entries to
+ * override.
+ */
+ pScrn->chipset = pScrn1->chipset;
+ pMga->Chipset = pMga1->Chipset;
+ pMga->ChipRev = pMga1->ChipRev;
+
+#ifdef XF86DRI
+ pMga->agpMode = pMga1->agpMode;
+#endif
+
+ pMga->NoAccel = pMga1->NoAccel;
+ pMga->UsePCIRetry = pMga1->UsePCIRetry;
+ pMga->SyncOnGreen = pMga1->SyncOnGreen;
+ pMga->ShowCache = pMga1->ShowCache;
+ pMga->HasSDRAM = pMga1->HasSDRAM;
+ pMga->MemClk = pMga1->MemClk;
+ pMga->Overlay8Plus24 = pMga1->Overlay8Plus24;
+ pMga->colorKey = pMga1->colorKey;
+ pScrn->colorKey = pScrn1->colorKey;
+ pScrn->overlayFlags = pScrn1->overlayFlags;
+ pMga->videoKey = pMga1->videoKey;
+ /* unsupported options */
+ pMga->HWCursor = FALSE;
+ pMga->ShadowFB = FALSE;
+ pMga->FBDev = FALSE;
+
+ pMga->OverclockMem = pMga1->OverclockMem;
+ pMga->TexturedVideo = pMga1->TexturedVideo;
+ pMga->MergedFB = TRUE;
+
+ pMga->Rotate = 0;
+
+ switch (pMga->Chipset) {
+ case PCI_CHIP_MGA2064:
+ case PCI_CHIP_MGA2164:
+ case PCI_CHIP_MGA2164_AGP:
+ MGA2064SetupFuncs(pScrn);
+ break;
+ case PCI_CHIP_MGA1064:
+ case PCI_CHIP_MGAG100:
+ case PCI_CHIP_MGAG100_PCI:
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG550:
+ MGAGSetupFuncs(pScrn);
+ break;
+ }
+
+ pMga->FbAddress = pMga1->FbAddress;
+ pMga->FbBaseReg = pMga1->FbBaseReg;
+ pMga->PciInfo = pMga1->PciInfo;
+ pMga->IOAddress = pMga1->IOAddress;
+ pMga->ILOADAddress = pMga1->ILOADAddress;
+ pMga->BiosFrom = pMga1->BiosFrom;
+ pMga->BiosAddress = pMga1->BiosAddress;
+
+ /*
+ * Read the BIOS data struct
+ */
+
+ MGAReadBios(pScrn);
+
+ /* HW bpp matches reported bpp */
+ pMga->HwBpp = pMga1->HwBpp;
+
+ /*
+ * Reset card if it isn't primary one
+ */
+ if ( (!pMga->Primary && !pMga->FBDev) || xf86IsPc98() )
+ MGASoftReset(pScrn);
+
+
+ pScrn->videoRam = pScrn1->videoRam;
+ pMga->FbMapSize = pMga1->FbMapSize;
+ pMga->SrcOrg = pMga1->SrcOrg;
+ pMga->DstOrg = pMga1->DstOrg;
+
+ /* Set the bpp shift value */
+ pMga->BppShifts[0] = 0;
+ pMga->BppShifts[1] = 1;
+ pMga->BppShifts[2] = 0;
+ pMga->BppShifts[3] = 2;
+
+ /*
+ * fill MGAdac struct
+ * Warning: currently, it should be after RAM counting
+ */
+ (*pMga->PreInit)(pScrn);
+
+#if !defined(__powerpc__)
+
+ /* Read and print the Monitor DDC info */
+/* pScrn->monitor->DDC = MGAdoDDC(pScrn);*/ /*FIXME: have to try this*/
+#endif /* !__powerpc__ */
+
+ /*
+ * If the driver can do gamma correction, it should call xf86SetGamma()
+ * here.
+ */
+ {
+ Gamma zeros = {0.0, 0.0, 0.0};
+
+ if (!xf86SetGamma(pScrn, zeros)) {
+ return FALSE;
+ }
+ }
+
+
+ /* Set the min pixel clock */
+ pMga->MinClock = pMga1->MinClock; /* XXX Guess, need to check this */
+ xf86DrvMsg(pScrn->scrnIndex, X_DEFAULT, "CRTC2: Min pixel clock is %d MHz\n",
+ pMga->MinClock / 1000);
+ /* Override on 2nd crtc */
+
+ if (pMga->ChipRev >= 0x80) { /* G450 */
+ pMga->MaxClock = 234000;
+ } else {
+ pMga->MaxClock = 135000;
+ }
+ xf86DrvMsg(pScrn->scrnIndex, X_DEFAULT, "CRTC2: Max pixel clock is %d MHz\n",
+ pMga->MaxClock / 1000);
+ /*
+ * Setup the ClockRanges, which describe what clock ranges are available,
+ * and what sort of modes they can be used for.
+ */
+ clockRanges = xnfcalloc(sizeof(ClockRange), 1);
+ clockRanges->next = NULL;
+ clockRanges->minClock = pMga->MinClock;
+ clockRanges->maxClock = pMga->MaxClock;
+ clockRanges->clockIndex = -1; /* programmable */
+ clockRanges->interlaceAllowed = TRUE;
+ clockRanges->doubleScanAllowed = TRUE;
+#ifdef USEMGAHAL
+ MGA_HAL(clockRanges->interlaceAllowed = FALSE);
+ MGA_HAL(clockRanges->doubleScanAllowed = FALSE);
+#endif
+ clockRanges->interlaceAllowed = FALSE; /*no interlace on CRTC2 */
+
+ clockRanges->ClockMulFactor = 1;
+ clockRanges->ClockDivFactor = 1;
+ /* Only set MemClk if appropriate for the ramdac */
+ if (pMga->Dac.SetMemClk) {
+ if (pMga->MemClk == 0) {
+ pMga->MemClk = pMga->Dac.MemoryClock;
+ from = pMga->Dac.MemClkFrom;
+ } else
+ from = X_CONFIG;
+ xf86DrvMsg(pScrn->scrnIndex, from, "CRTC2: MCLK used is %.1f MHz\n",
+ pMga->MemClk / 1000.0);
+ }
+
+ /*
+ * xf86ValidateModes will check that the mode HTotal and VTotal values
+ * don't exceed the chipset's limit if pScrn->maxHValue and
+ * pScrn->maxVValue are set. Since our MGAValidMode() already takes
+ * care of this, we don't worry about setting them here.
+ */
+ {
+ int Pitches1[] =
+ {640, 768, 800, 960, 1024, 1152, 1280, 1600, 1920, 2048, 0};
+ int Pitches2[] =
+ {512, 640, 768, 800, 832, 960, 1024, 1152, 1280, 1600, 1664,
+ 1920, 2048, 0};
+ int *linePitches = NULL;
+ int minPitch = 256;
+ int maxPitch = 2048;
+
+ switch(pMga->Chipset) {
+ case PCI_CHIP_MGA2064:
+ if (!pMga->NoAccel) {
+ linePitches = xalloc(sizeof(Pitches1));
+ memcpy(linePitches, Pitches1, sizeof(Pitches1));
+ minPitch = maxPitch = 0;
+ }
+ break;
+ case PCI_CHIP_MGA2164:
+ case PCI_CHIP_MGA2164_AGP:
+ case PCI_CHIP_MGA1064:
+ if (!pMga->NoAccel) {
+ linePitches = xalloc(sizeof(Pitches2));
+ memcpy(linePitches, Pitches2, sizeof(Pitches2));
+ minPitch = maxPitch = 0;
+ }
+ break;
+ case PCI_CHIP_MGAG100:
+ case PCI_CHIP_MGAG100_PCI:
+ maxPitch = 2048;
+ break;
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG550:
+ maxPitch = 4096;
+ break;
+ }
+
+ pScrn->modePool=NULL;
+ pScrn->modes = NULL;
+ i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
+ pScrn->display->modes, clockRanges,
+ linePitches, minPitch, maxPitch,
+ pMga->Roundings[(pScrn->bitsPerPixel >> 3) - 1] *
+ pScrn->bitsPerPixel, 128, 2048,
+ pScrn->display->virtualX,
+ pScrn->display->virtualY,
+ pMga->FbMapSize,
+ LOOKUP_BEST_REFRESH);
+
+ if (linePitches)
+ xfree(linePitches);
+ }
+
+
+ if (i < 1 && pMga->FBDev) {
+ fbdevHWUseBuildinMode(pScrn);
+ pScrn->displayWidth = pScrn->virtualX; /* FIXME: might be wrong */
+ i = 1;
+ }
+ if (i == -1) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "CRTC2: Validate Modes Failed\n");
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+
+ /* Prune the modes marked as invalid */
+ xf86PruneDriverModes(pScrn);
+
+ if (i == 0 || pScrn->modes == NULL) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "CRTC2: No valid modes found\n");
+ MGAFreeRec(pScrn);
+ return FALSE;
+ }
+#ifdef USEMGAHAL
+ MGA_HAL(
+
+ pMga->pBoard = pMga1->pBoard;
+ pMga->pClientStruct = pMga1->pClientStruct;
+ pMga->pMgaHwInfo = pMga1->pMgaHwInfo;
+
+
+ MGAFillModeInfoStruct(pScrn,NULL);
+ /* Fields usually handled by MGAFillModeInfoStruct, but are unavailable
+ * because no mode is given
+ */
+ pMga->pMgaModeInfo->ulDispWidth = pScrn->virtualX;
+ pMga->pMgaModeInfo->ulDispHeight = pScrn->virtualY;
+
+ if((status = MGAValidateMode(pMga->pBoard,pMga->pMgaModeInfo)) != 0) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "MGAValidateMode from HALlib found the mode to be invalid.\n"
+ "\tError: 0x%lx\n", status);
+ return FALSE;
+ }
+ pScrn->displayWidth = pMga->pMgaModeInfo->ulFBPitch;
+ ); /* MGA_HAL */
+#endif
+
+ /*
+ * Set the CRTC parameters for all of the modes based on the type
+ * of mode, and the chipset's interlace requirements.
+ *
+ * Calling this is required if the mode->Crtc* values are used by the
+ * driver and if the driver doesn't provide code to set them. They
+ * are not pre-initialised at all.
+ */
+#ifdef USEMGAHAL
+ MGA_HAL(xf86SetCrtcForModes(pScrn, 0));
+#endif
+ MGA_NOT_HAL(xf86SetCrtcForModes(pScrn, INTERLACE_HALVE_V));
+
+ /* Set the current mode to the first in the list */
+ pScrn->currentMode = pScrn->modes;
+
+ /* Print the list of modes being used */
+ xf86PrintModes(pScrn);
+
+ /* Set display resolution */
+ xf86SetDpi(pScrn, 0, 0);
+
+ /*
+ * Compute the byte offset into the linear frame buffer where the
+ * frame buffer data should actually begin. According to DDK misc.c
+ * line 1023, if more than 4MB is to be displayed, YDSTORG must be set
+ * appropriately to align memory bank switching, and this requires a
+ * corresponding offset on linear frame buffer access.
+ * This is only needed for WRAM.
+ */
+
+ pMga->YDstOrg = pMga1->YDstOrg;
+ xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "CRTC2: YDstOrg is set to %d\n",
+ pMga->YDstOrg);
+ pMga->FbUsableSize = pMga1->FbUsableSize;
+ pMga->FbCursorOffset = pMga1->FbCursorOffset;
+
+ pMga->CurrentLayout.bitsPerPixel = pScrn->bitsPerPixel;
+ pMga->CurrentLayout.depth = pScrn->depth;
+ pMga->CurrentLayout.displayWidth = pScrn->displayWidth;
+ pMga->CurrentLayout.weight.red = pScrn->weight.red;
+ pMga->CurrentLayout.weight.green = pScrn->weight.green;
+ pMga->CurrentLayout.weight.blue = pScrn->weight.blue;
+ pMga->CurrentLayout.Overlay8Plus24 = pMga->Overlay8Plus24;
+ pMga->CurrentLayout.mode = pScrn->currentMode;
+
+
+ Monitor2Pos = mgaRightOf;
+ if ((s = xf86GetOptValString(pMga1->Options, OPTION_MONITOR2POS))) {
+ switch(s[0]) {
+ case 'L': case 'l': case 'G': case 'g':
+ Monitor2Pos = mgaLeftOf;
+ break;
+ case 'R': case 'r': case 'D': case 'd':
+ Monitor2Pos = mgaRightOf;
+ break;
+
+ case 'A': case 'a': case 'H': case 'h':
+ Monitor2Pos = mgaAbove;
+ break;
+
+ case 'B': case 'b':
+ Monitor2Pos = mgaBelow;
+ break;
+
+ case 'C': case 'c':
+ Monitor2Pos = mgaClone;
+ break;
+ default:
+ Monitor2Pos = mgaRightOf;
+ break;
+ }
+ }
+
+ /* Fool xf86 into thinking we have huge modes */
+ /* Keep the original values somewhere */
+ pMga1->M1modes = pScrn1->modes;
+ pMga1->M1currentMode = pScrn1->currentMode;
+ /* make a copy of the mode list, so we can modify it. */
+ if ((s = xf86GetOptValString(pMga1->Options, OPTION_METAMODES))) {
+ pScrn1->modes = GenerateModeList(pScrn,s,pMga1->M1modes,pScrn->modes,Monitor2Pos); /*FIXME: free this list*/
+ if(!pScrn1->modes) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Parse Error reading MetaModes, or No modes left.\n");
+ return FALSE;
+ }
+
+ pScrn1->modes = pScrn1->modes->next;
+ pScrn1->currentMode = pScrn1->modes;
+ } else {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "MetaModes option missing.\n");
+ return FALSE;
+ }
+ xf86DrvMsg(pScrn1->scrnIndex, X_INFO, "==== End of second screen initialization ====\n");
+ return TRUE;
+}
+
+void
+MGADisplayPowerManagementSetMerged(ScrnInfoPtr pScrn, int PowerManagementMode,
+ int flags)
+{
+ MGADisplayPowerManagementSet(pScrn,PowerManagementMode,flags);
+ MGADisplayPowerManagementSetCrtc2(pScrn,PowerManagementMode,flags);
+}
+
+typedef struct _region {
+ int x0,x1,y0,y1;
+ } region;
+
+static Bool
+InRegion(int x, int y, region r) {
+ return (r.x0 <= x) && (x < r.x1) && (r.y0 <= y) && (y < r.y1);
+}
+
+
+#define BOUND(test,low,hi) { \
+ if(test < low) test = low; \
+ if(test > hi) test = hi; }
+#define REBOUND(low,hi,test) { \
+ if(test < low) { \
+ hi += test-low; \
+ low = test; } \
+ if(test > hi) { \
+ low += test-hi; \
+ hi = test; } }
+ void
+MGAMergePointerMoved(int scrnIndex, int x, int y)
+{
+ ScrnInfoPtr pScr = xf86Screens[scrnIndex];
+ MGAPtr pMga = MGAPTR(pScr);
+ ScrnInfoPtr pScr2 = pMga->pScrn2;
+
+ region out,in1,in2,f2,f1;
+
+ int deltax,deltay;
+
+ /* for ease. */
+ f1.x0 = pMga->M1frameX0;
+ f1.x1 = pMga->M1frameX1+1;
+ f1.y0 = pMga->M1frameY0;
+ f1.y1 = pMga->M1frameY1+1;
+ f2.x0 = pScr2->frameX0;
+ f2.x1 = pScr2->frameX1+1;
+ f2.y0 = pScr2->frameY0;
+ f2.y1 = pScr2->frameY1+1;
+
+
+ /*specify outer clipping region. crossing this causes all frames to move*/
+ out.x0 = pScr->frameX0;
+ out.x1 = pScr->frameX1+1;
+ out.y0 = pScr->frameY0;
+ out.y1 = pScr->frameY1+1;
+
+ /*
+ * specify inner sliding window. beeing outsize both frames, and inside
+ * the outer cliping window, causes corresponding frame to slide
+ */
+ in1 = out;
+ in2 = out;
+ switch(((MergedDisplayModePtr)pScr->currentMode->Private)->Monitor2Pos) {
+ case mgaLeftOf :
+ in1.x0 = f1.x0;
+ in2.x1 = f2.x1;
+ break;
+ case mgaRightOf :
+ in1.x1 = f1.x1;
+ in2.x0 = f2.x0;
+ break;
+ case mgaBelow :
+ in1.y1 = f1.y1;
+ in2.y0 = f2.y0;
+ break;
+ case mgaAbove :
+ in1.y0 = f1.y0;
+ in2.y1 = f2.y1;
+ break;
+ case mgaClone :
+ break;
+ }
+
+
+ deltay = 0;
+ deltax = 0;
+
+ if(InRegion(x,y,out)) {
+ if( InRegion(x,y, in1) && !InRegion(x,y, f1) ) {
+ REBOUND(f1.x0,f1.x1,x);
+ REBOUND(f1.y0,f1.y1,y);
+ deltax = 1; /*force frame update */
+ }
+ if( InRegion(x,y, in2) && !InRegion(x,y, f2) ) {
+ REBOUND(f2.x0,f2.x1,x);
+ REBOUND(f2.y0,f2.y1,y);
+ deltax = 1; /*force frame update */
+ }
+ }
+ else { /*outside outer clipping region*/
+ if ( out.x0 > x) {
+ deltax = x - out.x0;
+ }
+ if ( out.x1 < x) {
+ deltax = x - out.x1;
+ }
+ f1.x0 += deltax;
+ f1.x1 += deltax;
+ f2.x0 += deltax;
+ f2.x1 += deltax;
+ pScr->frameX0 += deltax;
+ pScr->frameX1 += deltax;
+
+
+ if ( out.y0 > y) {
+ deltay = y - out.y0;
+ }
+ if ( out.y1 < y) {
+ deltay = y - out.y1;
+ }
+ f1.y0 += deltay;
+ f1.y1 += deltay;
+ f2.y0 += deltay;
+ f2.y1 += deltay;
+ pScr->frameY0 += deltay;
+ pScr->frameY1 += deltay;
+ }
+
+
+ if (deltax != 0 || deltay != 0) {
+ /* back to reality. */
+ pMga->M1frameX0 = f1.x0;
+ pMga->M1frameY0 = f1.y0;
+ pScr2->frameX0 = f2.x0;
+ pScr2->frameY0 = f2.y0;
+
+ /*Adjust Granularity */
+ MGAAdjustGranularity(pScr,&pMga->M1frameX0,&pMga->M1frameY0);
+ MGAAdjustGranularity(pScr,&pScr2->frameX0,&pScr2->frameY0);
+ MGAAdjustGranularity(pScr,&pScr->frameX0,&pScr->frameY0);
+
+ pMga->M1frameX1 = pMga->M1frameX0 + MDMPTR(pScr)->Monitor1->HDisplay -1;
+ pMga->M1frameY1 = pMga->M1frameY0 + MDMPTR(pScr)->Monitor1->VDisplay -1;
+ pScr2->frameX1 = pScr2->frameX0 + MDMPTR(pScr)->Monitor2->HDisplay -1;
+ pScr2->frameY1 = pScr2->frameY0 + MDMPTR(pScr)->Monitor2->VDisplay -1;
+ pScr->frameX1 = pScr->frameX0 + pScr->currentMode->HDisplay -1;
+ pScr->frameY1 = pScr->frameY0 + pScr->currentMode->VDisplay -1;
+
+ MGAAdjustFrame(pScr->scrnIndex, pMga->M1frameX0, pMga->M1frameY0, 0);
+ MGAAdjustFrameCrtc2(pScr->scrnIndex, pScr2->frameX0, pScr2->frameY0, 0);
+ }
+
+/* if(pMga->PointerMoved)
+ (*pMga->PointerMoved)(scrnIndex, x, y); FIXME: do I need to call old func?*/
+
+}
+
+
+void
+MGAAdjustMergeFrames(int scrnIndex, int x, int y, int flags) {
+ ScrnInfoPtr pScrn1 = xf86Screens[scrnIndex];
+ MGAPtr pMga = MGAPTR(pScrn1);
+ ScrnInfoPtr pScrn2 = pMga->pScrn2;
+ int VTotal = pScrn1->currentMode->VDisplay;
+ int HTotal = pScrn1->currentMode->HDisplay;
+ int VMax = VTotal;
+ int HMax = HTotal;
+
+ BOUND(x,0,pScrn1->virtualX-HTotal);
+ BOUND(y,0,pScrn1->virtualY-VTotal);
+ switch(MDMPTR(pScrn1)->Monitor2Pos) {
+ case mgaLeftOf:
+ pScrn2->frameX0 = x;
+ BOUND(pScrn2->frameY0,y,y + VMax - MDMPTR(pScrn1)->Monitor2->VDisplay);
+ pMga->M1frameX0 = x+MDMPTR(pScrn1)->Monitor2->HDisplay;
+ BOUND(pMga->M1frameY0,y,y + VMax - MDMPTR(pScrn1)->Monitor1->VDisplay);
+ break;
+ case mgaRightOf:
+ pMga->M1frameX0 = x;
+ BOUND(pMga->M1frameY0,y,y + VMax - MDMPTR(pScrn1)->Monitor1->VDisplay);
+ pScrn2->frameX0 = x+MDMPTR(pScrn1)->Monitor1->HDisplay;
+ BOUND(pScrn2->frameY0,y,y + VMax - MDMPTR(pScrn1)->Monitor2->VDisplay);
+ break;
+ case mgaAbove:
+ BOUND(pScrn2->frameX0,x,x + HMax - MDMPTR(pScrn1)->Monitor2->HDisplay);
+ pScrn2->frameY0 = y;
+ BOUND(pMga->M1frameX0,x,x + HMax - MDMPTR(pScrn1)->Monitor1->HDisplay);
+ pMga->M1frameY0 = y+MDMPTR(pScrn1)->Monitor2->VDisplay;
+ break;
+ case mgaBelow:
+ BOUND(pMga->M1frameX0,x,x + HMax - MDMPTR(pScrn1)->Monitor1->HDisplay);
+ pMga->M1frameY0 = y;
+ BOUND(pScrn2->frameX0,x,x + HMax - MDMPTR(pScrn1)->Monitor2->HDisplay);
+ pScrn2->frameY0 = y+MDMPTR(pScrn1)->Monitor1->VDisplay;
+ break;
+ case mgaClone:
+ BOUND(pMga->M1frameX0,x,x + HMax - MDMPTR(pScrn1)->Monitor1->HDisplay);
+ BOUND(pMga->M1frameY0,y,y + VMax - MDMPTR(pScrn1)->Monitor1->VDisplay);
+ BOUND(pScrn2->frameX0,x,x + HMax - MDMPTR(pScrn1)->Monitor2->HDisplay);
+ BOUND(pScrn2->frameY0,y,y + VMax - MDMPTR(pScrn1)->Monitor2->VDisplay);
+ break;
+ }
+ /* sanity checks. Make shure were not out of bounds */
+ BOUND(pMga->M1frameX0,0,pScrn1->virtualX -MDMPTR(pScrn1)->Monitor1->HDisplay);
+ BOUND(pMga->M1frameY0,0,pScrn1->virtualY -MDMPTR(pScrn1)->Monitor1->VDisplay);
+ BOUND(pScrn2->frameX0,0,pScrn2->virtualX -MDMPTR(pScrn1)->Monitor2->HDisplay);
+ BOUND(pScrn2->frameY0,0,pScrn2->virtualY -MDMPTR(pScrn1)->Monitor2->VDisplay);
+
+ pScrn1->frameX0 = x;
+ pScrn1->frameY0 = y;
+
+ /* check granularity */
+ MGAAdjustGranularity(pScrn1,&pMga->M1frameX0,&pMga->M1frameY0);
+ MGAAdjustGranularity(pScrn1,&pScrn2->frameX0,&pScrn2->frameY0);
+ MGAAdjustGranularity(pScrn1,&pScrn1->frameX0,&pScrn1->frameY0);
+
+ /* complete shitty redundant info */
+ pMga->M1frameX1 = pMga->M1frameX0 + MDMPTR(pScrn1)->Monitor1->HDisplay -1;
+ pMga->M1frameY1 = pMga->M1frameY0 + MDMPTR(pScrn1)->Monitor1->VDisplay -1;
+ pScrn2->frameX1 = pScrn2->frameX0 + MDMPTR(pScrn1)->Monitor2->HDisplay -1;
+ pScrn2->frameY1 = pScrn2->frameY0 + MDMPTR(pScrn1)->Monitor2->VDisplay -1;
+ pScrn1->frameX1 = pScrn1->frameX0 + pScrn1->currentMode->HDisplay -1;
+ pScrn1->frameY1 = pScrn1->frameY0 + pScrn1->currentMode->VDisplay -1;
+
+ MGAAdjustFrame(scrnIndex, pMga->M1frameX0, pMga->M1frameY0, flags);
+ MGAAdjustFrameCrtc2(scrnIndex, pScrn2->frameX0, pScrn2->frameY0, flags);
+ return;
+}
+
+Bool
+MGACloseScreenMerged(int scrnIndex, ScreenPtr pScreen) {
+ ScrnInfoPtr pScrn1 = xf86Screens[scrnIndex];
+ MGAPtr pMga = MGAPTR(pScrn1);
+ ScrnInfoPtr pScrn2 = pMga->pScrn2;
+
+ if(pScrn2) {
+ xfree(pScrn2->monitor);
+ pScrn2->monitor = NULL;
+
+ xfree(pScrn2);
+ pMga->pScrn2 = NULL;
+ }
+
+ if(pScrn1->modes) {
+ pScrn1->currentMode = pScrn1->modes;
+ do {
+ DisplayModePtr p = pScrn1->currentMode->next;
+ if(pScrn1->currentMode->Private)
+ xfree(pScrn1->currentMode->Private);
+ xfree(pScrn1->currentMode);
+ pScrn1->currentMode = p;
+ }while( pScrn1->currentMode != pScrn1->modes);
+ }
+
+ pScrn1->currentMode = pMga->M1currentMode;
+ pScrn1->modes = pMga->M1modes;
+
+ return TRUE;
+}
+
+Bool
+MGASaveScreenMerged(ScreenPtr pScreen, int mode)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ BOOL on = xf86IsUnblank(mode);
+ CARD8 reg;
+
+ if (on) {
+/* SetTimdeSinceLastInputEvent();*/
+
+ /* power on Dac1 */
+ reg = inMGAdac(0x1E);
+ outMGAdac(0x1E, reg | 1);
+ /* power on Dac2 */
+ reg = inMGAdac(0xA0);
+ outMGAdac(0xA0, reg | 1);
+
+ } else {
+ /* power off Dac1 */
+ reg = inMGAdac(0x1E);
+ outMGAdac(0x1E, reg & ~1);
+ /* power off Dac2 */
+ reg = inMGAdac(0xA0);
+ outMGAdac(0xA0, reg & ~1);
+
+ }
+ return TRUE;
+}
+
+
diff --git a/src/mga_merge.h b/src/mga_merge.h
new file mode 100644
index 0000000..f823b23
--- /dev/null
+++ b/src/mga_merge.h
@@ -0,0 +1,19 @@
+/* Merged mode stuff */
+/* include file for mga_driver.c DO NOT try to generate a .o with this file.*/
+
+void MGADisplayPowerManagementSetMerged(ScrnInfoPtr pScrn,
+ int PowerManagementMode,
+ int flags);
+void MGAMergePointerMoved(int scrnIndex, int x, int y);
+void MGAAdjustMergeFrames(int scrnIndex, int x, int y, int flags);
+Bool MGAPreInitMergedFB(ScrnInfoPtr pScrn1, int flags);
+Bool MGACloseScreenMerged(int scrnIndex, ScreenPtr pScreen);
+Bool MGASaveScreenMerged(ScreenPtr pScreen, int mode);
+
+typedef struct _MergedDisplayModeRec {
+ DisplayModePtr Monitor1;
+ DisplayModePtr Monitor2;
+ MgaScrn2Rel Monitor2Pos;
+} MergedDisplayModeRec, *MergedDisplayModePtr;
+
+#define MDMPTR(x) ((MergedDisplayModePtr)(x->currentMode->Private))
diff --git a/src/mga_reg.h b/src/mga_reg.h
new file mode 100644
index 0000000..0d6a20b
--- /dev/null
+++ b/src/mga_reg.h
@@ -0,0 +1,482 @@
+/* $XConsortium: mgareg.h /main/2 1996/10/25 10:33:21 kaleb $ */
+
+
+
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_reg.h,v 1.18 2001/09/26 12:59:18 alanh Exp $ */
+
+
+
+/*
+ * MGA Millennium (MGA2064W) functions
+ * MGA Mystique (MGA1064SG) functions
+ *
+ * Copyright 1996 The XFree86 Project, Inc.
+ *
+ * Authors
+ * Dirk Hohndel
+ * hohndel@XFree86.Org
+ * David Dawes
+ * dawes@XFree86.Org
+ * Contributors:
+ * Guy DESBIEF, Aix-en-provence, France
+ * g.desbief@aix.pacwan.net
+ * MGA1064SG Mystique register file
+ */
+
+
+#ifndef _MGA_REG_H_
+#define _MGA_REG_H_
+
+#define MGAREG_DWGCTL 0x1c00
+#define MGAREG_MACCESS 0x1c04
+/* the following is a mystique only register */
+#define MGAREG_MCTLWTST 0x1c08
+#define MGAREG_ZORG 0x1c0c
+
+#define MGAREG_PAT0 0x1c10
+#define MGAREG_PAT1 0x1c14
+#define MGAREG_PLNWT 0x1c1c
+
+#define MGAREG_BCOL 0x1c20
+#define MGAREG_FCOL 0x1c24
+
+#define MGAREG_SRC0 0x1c30
+#define MGAREG_SRC1 0x1c34
+#define MGAREG_SRC2 0x1c38
+#define MGAREG_SRC3 0x1c3c
+
+#define MGAREG_XYSTRT 0x1c40
+#define MGAREG_XYEND 0x1c44
+
+#define MGAREG_SHIFT 0x1c50
+/* the following is a mystique only register */
+#define MGAREG_DMAPAD 0x1c54
+#define MGAREG_SGN 0x1c58
+#define MGAREG_LEN 0x1c5c
+
+#define MGAREG_AR0 0x1c60
+#define MGAREG_AR1 0x1c64
+#define MGAREG_AR2 0x1c68
+#define MGAREG_AR3 0x1c6c
+#define MGAREG_AR4 0x1c70
+#define MGAREG_AR5 0x1c74
+#define MGAREG_AR6 0x1c78
+
+#define MGAREG_CXBNDRY 0x1c80
+#define MGAREG_FXBNDRY 0x1c84
+#define MGAREG_YDSTLEN 0x1c88
+#define MGAREG_PITCH 0x1c8c
+
+#define MGAREG_YDST 0x1c90
+#define MGAREG_YDSTORG 0x1c94
+#define MGAREG_YTOP 0x1c98
+#define MGAREG_YBOT 0x1c9c
+
+#define MGAREG_CXLEFT 0x1ca0
+#define MGAREG_CXRIGHT 0x1ca4
+#define MGAREG_FXLEFT 0x1ca8
+#define MGAREG_FXRIGHT 0x1cac
+
+#define MGAREG_XDST 0x1cb0
+
+#define MGAREG_DR0 0x1cc0
+#define MGAREG_DR1 0x1cc4
+#define MGAREG_DR2 0x1cc8
+#define MGAREG_DR3 0x1ccc
+
+#define MGAREG_DR4 0x1cd0
+#define MGAREG_DR5 0x1cd4
+#define MGAREG_DR6 0x1cd8
+#define MGAREG_DR7 0x1cdc
+
+#define MGAREG_DR8 0x1ce0
+#define MGAREG_DR9 0x1ce4
+#define MGAREG_DR10 0x1ce8
+#define MGAREG_DR11 0x1cec
+
+#define MGAREG_DR12 0x1cf0
+#define MGAREG_DR13 0x1cf4
+#define MGAREG_DR14 0x1cf8
+#define MGAREG_DR15 0x1cfc
+
+#define MGAREG_SRCORG 0x2cb4
+#define MGAREG_DSTORG 0x2cb8
+
+/* add or or this to one of the previous "power registers" to start
+ the drawing engine */
+
+#define MGAREG_EXEC 0x0100
+
+#define MGAREG_FIFOSTATUS 0x1e10
+#define MGAREG_Status 0x1e14
+#define MGAREG_ICLEAR 0x1e18
+#define MGAREG_IEN 0x1e1c
+
+#define MGAREG_VCOUNT 0x1e20
+
+#define MGAREG_Reset 0x1e40
+
+#define MGAREG_OPMODE 0x1e54
+
+/* Warp Registers */
+#define MGAREG_WIADDR 0x1dc0
+#define MGAREG_WIADDR2 0x1dd8
+#define MGAREG_WGETMSB 0x1dc8
+#define MGAREG_WVRTXSZ 0x1dcc
+#define MGAREG_WACCEPTSEQ 0x1dd4
+#define MGAREG_WMISC 0x1e70
+
+/* OPMODE register additives */
+
+#define MGAOPM_DMA_GENERAL (0x00 << 2)
+#define MGAOPM_DMA_BLIT (0x01 << 2)
+#define MGAOPM_DMA_VECTOR (0x10 << 2)
+
+/* DWGCTL register additives */
+
+/* Lines */
+
+#define MGADWG_LINE_OPEN 0x00
+#define MGADWG_AUTOLINE_OPEN 0x01
+#define MGADWG_LINE_CLOSE 0x02
+#define MGADWG_AUTOLINE_CLOSE 0x03
+
+/* Trapezoids */
+#define MGADWG_TRAP 0x04
+#define MGADWG_TEXTURE_TRAP 0x05
+
+/* BitBlts */
+
+#define MGADWG_BITBLT 0x08
+#define MGADWG_FBITBLT 0x0c
+#define MGADWG_ILOAD 0x09
+#define MGADWG_ILOAD_SCALE 0x0d
+#define MGADWG_ILOAD_FILTER 0x0f
+#define MGADWG_ILOAD_HIQH 0x07
+#define MGADWG_ILOAD_HIQHV 0x0e
+#define MGADWG_IDUMP 0x0a
+
+/* atype access to WRAM */
+
+#define MGADWG_RPL ( 0x00 << 4 )
+#define MGADWG_RSTR ( 0x01 << 4 )
+#define MGADWG_ZI ( 0x03 << 4 )
+#define MGADWG_BLK ( 0x04 << 4 )
+#define MGADWG_I ( 0x07 << 4 )
+
+/* specifies whether bit blits are linear or xy */
+#define MGADWG_LINEAR ( 0x01 << 7 )
+
+/* z drawing mode. use MGADWG_NOZCMP for always */
+
+#define MGADWG_NOZCMP ( 0x00 << 8 )
+#define MGADWG_ZE ( 0x02 << 8 )
+#define MGADWG_ZNE ( 0x03 << 8 )
+#define MGADWG_ZLT ( 0x04 << 8 )
+#define MGADWG_ZLTE ( 0x05 << 8 )
+#define MGADWG_GT ( 0x06 << 8 )
+#define MGADWG_GTE ( 0x07 << 8 )
+
+/* use this to force colour expansion circuitry to do its stuff */
+
+#define MGADWG_SOLID ( 0x01 << 11 )
+
+/* ar register at zero */
+
+#define MGADWG_ARZERO ( 0x01 << 12 )
+
+#define MGADWG_SGNZERO ( 0x01 << 13 )
+
+#define MGADWG_SHIFTZERO ( 0x01 << 14 )
+
+/* See table on 4-43 for bop ALU operations */
+
+/* See table on 4-44 for translucidity masks */
+
+#define MGADWG_BMONOLEF ( 0x00 << 25 )
+#define MGADWG_BMONOWF ( 0x04 << 25 )
+#define MGADWG_BPLAN ( 0x01 << 25 )
+
+/* note that if bfcol is specified and you're doing a bitblt, it causes
+ a fbitblt to be performed, so check that you obey the fbitblt rules */
+
+#define MGADWG_BFCOL ( 0x02 << 25 )
+#define MGADWG_BUYUV ( 0x0e << 25 )
+#define MGADWG_BU32BGR ( 0x03 << 25 )
+#define MGADWG_BU32RGB ( 0x07 << 25 )
+#define MGADWG_BU24BGR ( 0x0b << 25 )
+#define MGADWG_BU24RGB ( 0x0f << 25 )
+
+#define MGADWG_PATTERN ( 0x01 << 29 )
+#define MGADWG_TRANSC ( 0x01 << 30 )
+#define MGAREG_MISC_WRITE 0x3c2
+#define MGAREG_MISC_READ 0x3cc
+#define MGAREG_MISC_IOADSEL (0x1 << 0)
+#define MGAREG_MISC_RAMMAPEN (0x1 << 1)
+#define MGAREG_MISC_CLK_SEL_VGA25 (0x0 << 2)
+#define MGAREG_MISC_CLK_SEL_VGA28 (0x1 << 2)
+#define MGAREG_MISC_CLK_SEL_MGA_PIX (0x2 << 2)
+#define MGAREG_MISC_CLK_SEL_MGA_MSK (0x3 << 2)
+#define MGAREG_MISC_VIDEO_DIS (0x1 << 4)
+#define MGAREG_MISC_HIGH_PG_SEL (0x1 << 5)
+
+/* MMIO VGA registers */
+#define MGAREG_SEQ_INDEX 0x1fc4
+#define MGAREG_SEQ_DATA 0x1fc5
+#define MGAREG_CRTC_INDEX 0x1fd4
+#define MGAREG_CRTC_DATA 0x1fd5
+#define MGAREG_CRTCEXT_INDEX 0x1fde
+#define MGAREG_CRTCEXT_DATA 0x1fdf
+
+
+
+/* MGA bits for registers PCI_OPTION_REG */
+#define MGA1064_OPT_SYS_CLK_PCI ( 0x00 << 0 )
+#define MGA1064_OPT_SYS_CLK_PLL ( 0x01 << 0 )
+#define MGA1064_OPT_SYS_CLK_EXT ( 0x02 << 0 )
+#define MGA1064_OPT_SYS_CLK_MSK ( 0x03 << 0 )
+
+#define MGA1064_OPT_SYS_CLK_DIS ( 0x01 << 2 )
+#define MGA1064_OPT_G_CLK_DIV_1 ( 0x01 << 3 )
+#define MGA1064_OPT_M_CLK_DIV_1 ( 0x01 << 4 )
+
+#define MGA1064_OPT_SYS_PLL_PDN ( 0x01 << 5 )
+#define MGA1064_OPT_VGA_ION ( 0x01 << 8 )
+
+/* MGA registers in PCI config space */
+#define PCI_MGA_INDEX 0x44
+#define PCI_MGA_DATA 0x48
+#define PCI_MGA_OPTION2 0x50
+#define PCI_MGA_OPTION3 0x54
+
+#define RAMDAC_OFFSET 0x3c00
+
+/* TVP3026 direct registers */
+
+#define TVP3026_INDEX 0x00
+#define TVP3026_WADR_PAL 0x00
+#define TVP3026_COL_PAL 0x01
+#define TVP3026_PIX_RD_MSK 0x02
+#define TVP3026_RADR_PAL 0x03
+#define TVP3026_CUR_COL_ADDR 0x04
+#define TVP3026_CUR_COL_DATA 0x05
+#define TVP3026_DATA 0x0a
+#define TVP3026_CUR_RAM 0x0b
+#define TVP3026_CUR_XLOW 0x0c
+#define TVP3026_CUR_XHI 0x0d
+#define TVP3026_CUR_YLOW 0x0e
+#define TVP3026_CUR_YHI 0x0f
+
+/* TVP3026 indirect registers */
+
+#define TVP3026_SILICON_REV 0x01
+#define TVP3026_CURSOR_CTL 0x06
+#define TVP3026_LATCH_CTL 0x0f
+#define TVP3026_TRUE_COLOR_CTL 0x18
+#define TVP3026_MUX_CTL 0x19
+#define TVP3026_CLK_SEL 0x1a
+#define TVP3026_PAL_PAGE 0x1c
+#define TVP3026_GEN_CTL 0x1d
+#define TVP3026_MISC_CTL 0x1e
+#define TVP3026_GEN_IO_CTL 0x2a
+#define TVP3026_GEN_IO_DATA 0x2b
+#define TVP3026_PLL_ADDR 0x2c
+#define TVP3026_PIX_CLK_DATA 0x2d
+#define TVP3026_MEM_CLK_DATA 0x2e
+#define TVP3026_LOAD_CLK_DATA 0x2f
+#define TVP3026_KEY_RED_LOW 0x32
+#define TVP3026_KEY_RED_HI 0x33
+#define TVP3026_KEY_GREEN_LOW 0x34
+#define TVP3026_KEY_GREEN_HI 0x35
+#define TVP3026_KEY_BLUE_LOW 0x36
+#define TVP3026_KEY_BLUE_HI 0x37
+#define TVP3026_KEY_CTL 0x38
+#define TVP3026_MCLK_CTL 0x39
+#define TVP3026_SENSE_TEST 0x3a
+#define TVP3026_TEST_DATA 0x3b
+#define TVP3026_CRC_LSB 0x3c
+#define TVP3026_CRC_MSB 0x3d
+#define TVP3026_CRC_CTL 0x3e
+#define TVP3026_ID 0x3f
+#define TVP3026_RESET 0xff
+
+
+/* MGA1064 DAC Register file */
+/* MGA1064 direct registers */
+
+#define MGA1064_INDEX 0x00
+#define MGA1064_WADR_PAL 0x00
+#define MGA1064_COL_PAL 0x01
+#define MGA1064_PIX_RD_MSK 0x02
+#define MGA1064_RADR_PAL 0x03
+#define MGA1064_DATA 0x0a
+
+#define MGA1064_CUR_XLOW 0x0c
+#define MGA1064_CUR_XHI 0x0d
+#define MGA1064_CUR_YLOW 0x0e
+#define MGA1064_CUR_YHI 0x0f
+
+/* MGA1064 indirect registers */
+#define MGA1064_DVI_PIPE_CTL 0x03
+#define MGA1064_CURSOR_BASE_ADR_LOW 0x04
+#define MGA1064_CURSOR_BASE_ADR_HI 0x05
+#define MGA1064_CURSOR_CTL 0x06
+#define MGA1064_CURSOR_COL0_RED 0x08
+#define MGA1064_CURSOR_COL0_GREEN 0x09
+#define MGA1064_CURSOR_COL0_BLUE 0x0a
+
+#define MGA1064_CURSOR_COL1_RED 0x0c
+#define MGA1064_CURSOR_COL1_GREEN 0x0d
+#define MGA1064_CURSOR_COL1_BLUE 0x0e
+
+#define MGA1064_CURSOR_COL2_RED 0x010
+#define MGA1064_CURSOR_COL2_GREEN 0x011
+#define MGA1064_CURSOR_COL2_BLUE 0x012
+
+#define MGA1064_VREF_CTL 0x018
+
+#define MGA1064_MUL_CTL 0x19
+#define MGA1064_MUL_CTL_8bits 0x0
+#define MGA1064_MUL_CTL_15bits 0x01
+#define MGA1064_MUL_CTL_16bits 0x02
+#define MGA1064_MUL_CTL_24bits 0x03
+#define MGA1064_MUL_CTL_32bits 0x04
+#define MGA1064_MUL_CTL_2G8V16bits 0x05
+#define MGA1064_MUL_CTL_G16V16bits 0x06
+#define MGA1064_MUL_CTL_32_24bits 0x07
+
+#define MGAGDAC_XVREFCTRL 0x18
+#define MGA1064_PIX_CLK_CTL 0x1a
+#define MGA1064_PIX_CLK_CTL_CLK_DIS ( 0x01 << 2 )
+#define MGA1064_PIX_CLK_CTL_CLK_POW_DOWN ( 0x01 << 3 )
+#define MGA1064_PIX_CLK_CTL_SEL_PCI ( 0x00 << 0 )
+#define MGA1064_PIX_CLK_CTL_SEL_PLL ( 0x01 << 0 )
+#define MGA1064_PIX_CLK_CTL_SEL_EXT ( 0x02 << 0 )
+#define MGA1064_PIX_CLK_CTL_SEL_MSK ( 0x03 << 0 )
+
+#define MGA1064_GEN_CTL 0x1d
+#define MGA1064_MISC_CTL 0x1e
+#define MGA1064_MISC_CTL_DAC_POW_DN ( 0x01 << 0 )
+#define MGA1064_MISC_CTL_VGA ( 0x01 << 1 )
+#define MGA1064_MISC_CTL_DIS_CON ( 0x03 << 1 )
+#define MGA1064_MISC_CTL_MAFC ( 0x02 << 1 )
+#define MGA1064_MISC_CTL_VGA8 ( 0x01 << 3 )
+#define MGA1064_MISC_CTL_DAC_RAM_CS ( 0x01 << 4 )
+
+#define MGA1064_GEN_IO_CTL 0x2a
+#define MGA1064_GEN_IO_DATA 0x2b
+#define MGA1064_SYS_PLL_M 0x2c
+#define MGA1064_SYS_PLL_N 0x2d
+#define MGA1064_SYS_PLL_P 0x2e
+#define MGA1064_SYS_PLL_STAT 0x2f
+#define MGA1064_ZOOM_CTL 0x38
+#define MGA1064_SENSE_TST 0x3a
+
+#define MGA1064_CRC_LSB 0x3c
+#define MGA1064_CRC_MSB 0x3d
+#define MGA1064_CRC_CTL 0x3e
+#define MGA1064_COL_KEY_MSK_LSB 0x40
+#define MGA1064_COL_KEY_MSK_MSB 0x41
+#define MGA1064_COL_KEY_LSB 0x42
+#define MGA1064_COL_KEY_MSB 0x43
+#define MGA1064_PIX_PLLA_M 0x44
+#define MGA1064_PIX_PLLA_N 0x45
+#define MGA1064_PIX_PLLA_P 0x46
+#define MGA1064_PIX_PLLB_M 0x48
+#define MGA1064_PIX_PLLB_N 0x49
+#define MGA1064_PIX_PLLB_P 0x4a
+#define MGA1064_PIX_PLLC_M 0x4c
+#define MGA1064_PIX_PLLC_N 0x4d
+#define MGA1064_PIX_PLLC_P 0x4e
+
+#define MGA1064_PIX_PLL_STAT 0x4f
+
+/*Added for G450 dual head*/
+/* Supported PLL*/
+#define __PIXEL_PLL 1
+#define __SYSTEM_PLL 2
+#define __VIDEO_PLL 3
+
+#define MGA1064_VID_PLL_P 0x8D
+#define MGA1064_VID_PLL_M 0x8E
+#define MGA1064_VID_PLL_N 0x8F
+
+#define MGA1064_DISP_CTL 0x8a
+#define MGA1064_SYNC_CTL 0x8b
+#define MGA1064_PWR_CTL 0xa0
+#define MGA1064_PAN_CTL 0xa2
+
+/* Using crtc2 */
+#define MGAREG2_C2CTL 0x10
+#define MGAREG2_C2HPARAM 0x14
+#define MGAREG2_C2HSYNC 0x18
+#define MGAREG2_C2VPARAM 0x1c
+#define MGAREG2_C2VSYNC 0x20
+#define MGAREG2_C2STARTADD0 0x28
+
+#define MGAREG2_C2OFFSET 0x40
+#define MGAREG2_C2DATACTL 0x4c
+
+#define MGAREG_C2CTL 0x3c10
+#define MGAREG_C2HPARAM 0x3c14
+#define MGAREG_C2HSYNC 0x3c18
+#define MGAREG_C2VPARAM 0x3c1c
+#define MGAREG_C2VSYNC 0x3c20
+#define MGAREG_C2STARTADD0 0x3c28
+
+#define MGAREG_C2OFFSET 0x3c40
+#define MGAREG_C2DATACTL 0x3c4c
+
+#define MGA1064_DISP_CTL 0x8a
+#define MGA1064_SYNC_CTL 0x8b
+#define MGA1064_PWR_CTL 0xa0
+
+/* video register */
+
+#define MGAREG_BESA1C3ORG 0x3d60
+#define MGAREG_BESA1CORG 0x3d10
+#define MGAREG_BESA1ORG 0x3d00
+#define MGAREG_BESCTL 0x3d20
+#define MGAREG_BESGLOBCTL 0x3dc0
+#define MGAREG_BESHCOORD 0x3d28
+#define MGAREG_BESHISCAL 0x3d30
+#define MGAREG_BESHSRCEND 0x3d3c
+#define MGAREG_BESHSRCLST 0x3d50
+#define MGAREG_BESHSRCST 0x3d38
+#define MGAREG_BESLUMACTL 0x3d40
+#define MGAREG_BESPITCH 0x3d24
+#define MGAREG_BESV1SRCLST 0x3d54
+#define MGAREG_BESV1WGHT 0x3d48
+#define MGAREG_BESVCOORD 0x3d2c
+#define MGAREG_BESVISCAL 0x3d34
+
+/* texture engine registers */
+
+#define MGAREG_TMR0 0x2c00
+#define MGAREG_TMR1 0x2c04
+#define MGAREG_TMR2 0x2c08
+#define MGAREG_TMR3 0x2c0c
+#define MGAREG_TMR4 0x2c10
+#define MGAREG_TMR5 0x2c14
+#define MGAREG_TMR6 0x2c18
+#define MGAREG_TMR7 0x2c1c
+#define MGAREG_TMR8 0x2c20
+#define MGAREG_TEXORG 0x2c24
+#define MGAREG_TEXWIDTH 0x2c28
+#define MGAREG_TEXHEIGHT 0x2c2c
+#define MGAREG_TEXCTL 0x2c30
+#define MGAREG_TEXCTL2 0x2c3c
+#define MGAREG_TEXTRANS 0x2c34
+#define MGAREG_TEXTRANSHIGH 0x2c38
+#define MGAREG_TEXFILTER 0x2c58
+#define MGAREG_ALPHASTART 0x2c70
+#define MGAREG_ALPHAXINC 0x2c74
+#define MGAREG_ALPHAYINC 0x2c78
+#define MGAREG_ALPHACTRL 0x2c7c
+#define MGAREG_DWGSYNC 0x2c4c
+
+#define MGAREG_AGP_PLL 0x1e4c
+#define MGA_AGP2XPLL_ENABLE 0x1
+#define MGA_AGP2XPLL_DISABLE 0x0
+
+#endif
diff --git a/src/mga_sarea.h b/src/mga_sarea.h
new file mode 100644
index 0000000..616dee5
--- /dev/null
+++ b/src/mga_sarea.h
@@ -0,0 +1,222 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_sarea.h,v 1.1 2001/03/21 17:11:47 dawes Exp $ */
+
+/*
+ * Copyright 2000 Gareth Hughes
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GARETH HUGHES BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ * Gareth Hughes <gareth@valinux.com>
+ */
+
+#ifndef __MGA_SAREA_H__
+#define __MGA_SAREA_H__
+
+/* WARNING: If you change any of these defines, make sure to change
+ * the kernel include file as well (mga_drm.h)
+ */
+#ifndef __MGA_SAREA_DEFINES__
+#define __MGA_SAREA_DEFINES__
+
+/* WARP pipe flags
+ */
+#define MGA_F 0x1 /* fog */
+#define MGA_A 0x2 /* alpha */
+#define MGA_S 0x4 /* specular */
+#define MGA_T2 0x8 /* multitexture */
+
+#define MGA_WARP_TGZ 0
+#define MGA_WARP_TGZF (MGA_F)
+#define MGA_WARP_TGZA (MGA_A)
+#define MGA_WARP_TGZAF (MGA_F|MGA_A)
+#define MGA_WARP_TGZS (MGA_S)
+#define MGA_WARP_TGZSF (MGA_S|MGA_F)
+#define MGA_WARP_TGZSA (MGA_S|MGA_A)
+#define MGA_WARP_TGZSAF (MGA_S|MGA_F|MGA_A)
+#define MGA_WARP_T2GZ (MGA_T2)
+#define MGA_WARP_T2GZF (MGA_T2|MGA_F)
+#define MGA_WARP_T2GZA (MGA_T2|MGA_A)
+#define MGA_WARP_T2GZAF (MGA_T2|MGA_A|MGA_F)
+#define MGA_WARP_T2GZS (MGA_T2|MGA_S)
+#define MGA_WARP_T2GZSF (MGA_T2|MGA_S|MGA_F)
+#define MGA_WARP_T2GZSA (MGA_T2|MGA_S|MGA_A)
+#define MGA_WARP_T2GZSAF (MGA_T2|MGA_S|MGA_F|MGA_A)
+
+#define MGA_MAX_G200_PIPES 8 /* no multitex */
+#define MGA_MAX_G400_PIPES 16
+#define MGA_MAX_WARP_PIPES MGA_MAX_G400_PIPES
+#define MGA_WARP_UCODE_SIZE 32768 /* in bytes */
+
+#define MGA_CARD_TYPE_G200 1
+#define MGA_CARD_TYPE_G400 2
+
+
+#define MGA_FRONT 0x1
+#define MGA_BACK 0x2
+#define MGA_DEPTH 0x4
+
+/* What needs to be changed for the current vertex dma buffer?
+ */
+#define MGA_UPLOAD_CONTEXT 0x1
+#define MGA_UPLOAD_TEX0 0x2
+#define MGA_UPLOAD_TEX1 0x4
+#define MGA_UPLOAD_PIPE 0x8
+#define MGA_UPLOAD_TEX0IMAGE 0x10
+#define MGA_UPLOAD_TEX1IMAGE 0x20
+#define MGA_UPLOAD_2D 0x40
+#define MGA_WAIT_AGE 0x80 /* handled client-side */
+#define MGA_UPLOAD_CLIPRECTS 0x100 /* handled client-side */
+#if 0
+#define MGA_DMA_FLUSH 0x200 /* set when someone gets the lock
+ quiescent */
+#endif
+
+/* 32 buffers of 64k each, total 1 meg.
+ */
+#define MGA_BUFFER_SIZE (1 << 16)
+#define MGA_NUM_BUFFERS 128
+
+/* Keep these small for testing.
+ */
+#define MGA_NR_SAREA_CLIPRECTS 8
+
+/* 2 heaps (1 for card, 1 for agp), each divided into upto 128
+ * regions, subject to a minimum region size of (1<<16) == 64k.
+ *
+ * Clients may subdivide regions internally, but when sharing between
+ * clients, the region size is the minimum granularity.
+ */
+
+#define MGA_CARD_HEAP 0
+#define MGA_AGP_HEAP 1
+#define MGA_NR_TEX_HEAPS 2
+#define MGA_NR_TEX_REGIONS 16
+#define MGA_LOG_MIN_TEX_REGION_SIZE 16
+
+#endif /* __MGA_SAREA_DEFINES__ */
+
+
+/* Setup registers for 3D context
+ */
+typedef struct {
+ unsigned int dstorg;
+ unsigned int maccess;
+ unsigned int plnwt;
+ unsigned int dwgctl;
+ unsigned int alphactrl;
+ unsigned int fogcolor;
+ unsigned int wflag;
+ unsigned int tdualstage0;
+ unsigned int tdualstage1;
+ unsigned int fcol;
+ unsigned int stencil;
+ unsigned int stencilctl;
+} mga_context_regs_t;
+
+/* Setup registers for 2D, X server
+ */
+typedef struct {
+ unsigned int pitch;
+} mga_server_regs_t;
+
+/* Setup registers for each texture unit
+ */
+typedef struct {
+ unsigned int texctl;
+ unsigned int texctl2;
+ unsigned int texfilter;
+ unsigned int texbordercol;
+ unsigned int texorg;
+ unsigned int texwidth;
+ unsigned int texheight;
+ unsigned int texorg1;
+ unsigned int texorg2;
+ unsigned int texorg3;
+ unsigned int texorg4;
+} mga_texture_regs_t;
+
+/* General ageing mechanism
+ */
+typedef struct {
+ unsigned int head; /* Position of head pointer */
+ unsigned int wrap; /* Primary DMA wrap count */
+} mga_age_t;
+
+
+/* WARNING: Do not change the SAREA structure without changing the kernel
+ * as well.
+ */
+typedef struct {
+ /* The channel for communication of state information to the kernel
+ * on firing a vertex dma buffer.
+ */
+ mga_context_regs_t ContextState;
+ mga_server_regs_t ServerState;
+ mga_texture_regs_t TexState[2];
+ unsigned int WarpPipe;
+ unsigned int dirty;
+ unsigned int vertsize;
+
+ /* The current cliprects, or a subset thereof.
+ */
+ XF86DRIClipRectRec boxes[MGA_NR_SAREA_CLIPRECTS];
+ unsigned int nbox;
+
+ /* Information about the most recently used 3d drawable. The
+ * client fills in the req_* fields, the server fills in the
+ * exported_ fields and puts the cliprects into boxes, above.
+ *
+ * The client clears the exported_drawable field before
+ * clobbering the boxes data.
+ */
+ unsigned int req_drawable; /* the X drawable id */
+ unsigned int req_draw_buffer; /* MGA_FRONT or MGA_BACK */
+
+ unsigned int exported_drawable;
+ unsigned int exported_index;
+ unsigned int exported_stamp;
+ unsigned int exported_buffers;
+ unsigned int exported_nfront; /* FIXME: verify signedness... */
+ unsigned int exported_nback;
+ int exported_back_x, exported_front_x, exported_w;
+ int exported_back_y, exported_front_y, exported_h;
+ XF86DRIClipRectRec exported_boxes[MGA_NR_SAREA_CLIPRECTS];
+
+ /* Counters for aging textures and for client-side throttling.
+ */
+ unsigned int status[4];
+ unsigned int last_wrap;
+
+ mga_age_t last_frame;
+ unsigned int last_enqueue; /* last time a buffer was enqueued */
+ unsigned int last_dispatch; /* age of the most recently dispatched buffer */
+ unsigned int last_quiescent; /* */
+
+ /* LRU lists for texture memory in agp space and on the card.
+ */
+ drmTextureRegion texList[MGA_NR_TEX_HEAPS][MGA_NR_TEX_REGIONS+1];
+ unsigned int texAge[MGA_NR_TEX_HEAPS];
+
+ /* Last context that uploaded statel
+ */
+ int ctxOwner;
+} MGASAREAPrivRec, *MGASAREAPrivPtr;
+
+#endif
diff --git a/src/mga_shadow.c b/src/mga_shadow.c
new file mode 100644
index 0000000..b1c228b
--- /dev/null
+++ b/src/mga_shadow.c
@@ -0,0 +1,254 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_shadow.c,v 1.3 2000/02/08 13:13:18 eich Exp $ */
+
+/*
+ Copyright (c) 1999, The XFree86 Project Inc.
+ Written by Mark Vojkovich <markv@valinux.com>
+*/
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86_ansic.h"
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+#include "mga_bios.h"
+#include "mga_reg.h"
+#include "mga.h"
+#include "shadowfb.h"
+#include "servermd.h"
+
+
+
+void
+MGARefreshArea(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int width, height, Bpp, FBPitch;
+ unsigned char *src, *dst;
+
+ Bpp = pScrn->bitsPerPixel >> 3;
+ FBPitch = BitmapBytePad(pScrn->displayWidth * pScrn->bitsPerPixel);
+
+ while(num--) {
+ width = (pbox->x2 - pbox->x1) * Bpp;
+ height = pbox->y2 - pbox->y1;
+ src = pMga->ShadowPtr + (pbox->y1 * pMga->ShadowPitch) +
+ (pbox->x1 * Bpp);
+ dst = pMga->FbStart + (pbox->y1 * FBPitch) + (pbox->x1 * Bpp);
+
+ while(height--) {
+ memcpy(dst, src, width);
+ dst += FBPitch;
+ src += pMga->ShadowPitch;
+ }
+
+ pbox++;
+ }
+}
+
+void
+MGAPointerMoved(int index, int x, int y)
+{
+ ScrnInfoPtr pScrn = xf86Screens[index];
+ MGAPtr pMga = MGAPTR(pScrn);
+ int newX, newY;
+
+ if(pMga->Rotate == 1) {
+ newX = pScrn->pScreen->height - y - 1;
+ newY = x;
+ } else {
+ newX = y;
+ newY = pScrn->pScreen->width - x - 1;
+ }
+
+ (*pMga->PointerMoved)(index, newX, newY);
+}
+
+void
+MGARefreshArea8(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int count, width, height, y1, y2, dstPitch, srcPitch;
+ CARD8 *dstPtr, *srcPtr, *src;
+ CARD32 *dst;
+
+ dstPitch = pScrn->displayWidth;
+ srcPitch = -pMga->Rotate * pMga->ShadowPitch;
+
+ while(num--) {
+ width = pbox->x2 - pbox->x1;
+ y1 = pbox->y1 & ~3;
+ y2 = (pbox->y2 + 3) & ~3;
+ height = (y2 - y1) >> 2; /* in dwords */
+
+ if(pMga->Rotate == 1) {
+ dstPtr = pMga->FbStart +
+ (pbox->x1 * dstPitch) + pScrn->virtualX - y2;
+ srcPtr = pMga->ShadowPtr + ((1 - y2) * srcPitch) + pbox->x1;
+ } else {
+ dstPtr = pMga->FbStart +
+ ((pScrn->virtualY - pbox->x2) * dstPitch) + y1;
+ srcPtr = pMga->ShadowPtr + (y1 * srcPitch) + pbox->x2 - 1;
+ }
+
+ while(width--) {
+ src = srcPtr;
+ dst = (CARD32*)dstPtr;
+ count = height;
+ while(count--) {
+ *(dst++) = src[0] | (src[srcPitch] << 8) |
+ (src[srcPitch * 2] << 16) |
+ (src[srcPitch * 3] << 24);
+ src += srcPitch * 4;
+ }
+ srcPtr += pMga->Rotate;
+ dstPtr += dstPitch;
+ }
+
+ pbox++;
+ }
+}
+
+
+void
+MGARefreshArea16(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int count, width, height, y1, y2, dstPitch, srcPitch;
+ CARD16 *dstPtr, *srcPtr, *src;
+ CARD32 *dst;
+
+ dstPitch = pScrn->displayWidth;
+ srcPitch = -pMga->Rotate * pMga->ShadowPitch >> 1;
+
+ while(num--) {
+ width = pbox->x2 - pbox->x1;
+ y1 = pbox->y1 & ~1;
+ y2 = (pbox->y2 + 1) & ~1;
+ height = (y2 - y1) >> 1; /* in dwords */
+
+ if(pMga->Rotate == 1) {
+ dstPtr = (CARD16*)pMga->FbStart +
+ (pbox->x1 * dstPitch) + pScrn->virtualX - y2;
+ srcPtr = (CARD16*)pMga->ShadowPtr +
+ ((1 - y2) * srcPitch) + pbox->x1;
+ } else {
+ dstPtr = (CARD16*)pMga->FbStart +
+ ((pScrn->virtualY - pbox->x2) * dstPitch) + y1;
+ srcPtr = (CARD16*)pMga->ShadowPtr +
+ (y1 * srcPitch) + pbox->x2 - 1;
+ }
+
+ while(width--) {
+ src = srcPtr;
+ dst = (CARD32*)dstPtr;
+ count = height;
+ while(count--) {
+ *(dst++) = src[0] | (src[srcPitch] << 16);
+ src += srcPitch * 2;
+ }
+ srcPtr += pMga->Rotate;
+ dstPtr += dstPitch;
+ }
+
+ pbox++;
+ }
+}
+
+
+/* this one could be faster */
+void
+MGARefreshArea24(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int count, width, height, y1, y2, dstPitch, srcPitch;
+ CARD8 *dstPtr, *srcPtr, *src;
+ CARD32 *dst;
+
+ dstPitch = BitmapBytePad(pScrn->displayWidth * 24);
+ srcPitch = -pMga->Rotate * pMga->ShadowPitch;
+
+ while(num--) {
+ width = pbox->x2 - pbox->x1;
+ y1 = pbox->y1 & ~3;
+ y2 = (pbox->y2 + 3) & ~3;
+ height = (y2 - y1) >> 2; /* blocks of 3 dwords */
+
+ if(pMga->Rotate == 1) {
+ dstPtr = pMga->FbStart +
+ (pbox->x1 * dstPitch) + ((pScrn->virtualX - y2) * 3);
+ srcPtr = pMga->ShadowPtr + ((1 - y2) * srcPitch) + (pbox->x1 * 3);
+ } else {
+ dstPtr = pMga->FbStart +
+ ((pScrn->virtualY - pbox->x2) * dstPitch) + (y1 * 3);
+ srcPtr = pMga->ShadowPtr + (y1 * srcPitch) + (pbox->x2 * 3) - 3;
+ }
+
+ while(width--) {
+ src = srcPtr;
+ dst = (CARD32*)dstPtr;
+ count = height;
+ while(count--) {
+ dst[0] = src[0] | (src[1] << 8) | (src[2] << 16) |
+ (src[srcPitch] << 24);
+ dst[1] = src[srcPitch + 1] | (src[srcPitch + 2] << 8) |
+ (src[srcPitch * 2] << 16) |
+ (src[(srcPitch * 2) + 1] << 24);
+ dst[2] = src[(srcPitch * 2) + 2] | (src[srcPitch * 3] << 8) |
+ (src[(srcPitch * 3) + 1] << 16) |
+ (src[(srcPitch * 3) + 2] << 24);
+ dst += 3;
+ src += srcPitch * 4;
+ }
+ srcPtr += pMga->Rotate * 3;
+ dstPtr += dstPitch;
+ }
+
+ pbox++;
+ }
+}
+
+void
+MGARefreshArea32(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int count, width, height, dstPitch, srcPitch;
+ CARD32 *dstPtr, *srcPtr, *src, *dst;
+
+ dstPitch = pScrn->displayWidth;
+ srcPitch = -pMga->Rotate * pMga->ShadowPitch >> 2;
+
+ while(num--) {
+ width = pbox->x2 - pbox->x1;
+ height = pbox->y2 - pbox->y1;
+
+ if(pMga->Rotate == 1) {
+ dstPtr = (CARD32*)pMga->FbStart +
+ (pbox->x1 * dstPitch) + pScrn->virtualX - pbox->y2;
+ srcPtr = (CARD32*)pMga->ShadowPtr +
+ ((1 - pbox->y2) * srcPitch) + pbox->x1;
+ } else {
+ dstPtr = (CARD32*)pMga->FbStart +
+ ((pScrn->virtualY - pbox->x2) * dstPitch) + pbox->y1;
+ srcPtr = (CARD32*)pMga->ShadowPtr +
+ (pbox->y1 * srcPitch) + pbox->x2 - 1;
+ }
+
+ while(width--) {
+ src = srcPtr;
+ dst = dstPtr;
+ count = height;
+ while(count--) {
+ *(dst++) = *src;
+ src += srcPitch;
+ }
+ srcPtr += pMga->Rotate;
+ dstPtr += dstPitch;
+ }
+
+ pbox++;
+ }
+}
+
+
+
diff --git a/src/mga_storm.c b/src/mga_storm.c
new file mode 100644
index 0000000..ff083ac
--- /dev/null
+++ b/src/mga_storm.c
@@ -0,0 +1,2703 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_storm.c,v 1.98 2003/01/16 16:09:10 eich Exp $ */
+
+
+/* All drivers should typically include these */
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+
+/* For correct __inline__ usage */
+#include "compiler.h"
+
+/* Drivers that need to access the PCI config space directly need this */
+#include "xf86Pci.h"
+
+/* Drivers for PCI hardware need this */
+#include "xf86PciInfo.h"
+
+/* Drivers that use XAA need this */
+#include "xaa.h"
+#include "xaalocal.h"
+#include "xf86fbman.h"
+#include "miline.h"
+#include "servermd.h"
+
+#ifdef XF86DRI
+#include "cfb.h"
+#include "GL/glxtokens.h"
+#endif
+
+#include "mga_bios.h"
+#include "mga.h"
+#include "mga_reg.h"
+#include "mga_map.h"
+#include "mga_macros.h"
+
+#ifdef XF86DRI
+#include "mga_dri.h"
+#endif
+
+#define MGAMoveDWORDS(d,s,c) \
+do { \
+ write_mem_barrier(); \
+ XAAMoveDWORDS((d),(s),(c)); \
+} while (0)
+
+static void MGANAME(SubsequentScreenToScreenCopy)(ScrnInfoPtr pScrn,
+ int srcX, int srcY, int dstX, int dstY,
+ int w, int h);
+static void MGANAME(SubsequentScreenToScreenCopy_FastBlit)(ScrnInfoPtr pScrn,
+ int srcX, int srcY, int dstX, int dstY,
+ int w, int h);
+static void MGANAME(SetupForScanlineCPUToScreenColorExpandFill)(
+ ScrnInfoPtr pScrn, int fg,
+ int bg, int rop, unsigned int planemask);
+static void MGANAME(SubsequentScanlineCPUToScreenColorExpandFill)(
+ ScrnInfoPtr pScrn,
+ int x, int y, int w, int h, int skipleft);
+static void MGANAME(SubsequentColorExpandScanline)(ScrnInfoPtr pScrn,
+ int bufno);
+static void MGANAME(SubsequentColorExpandScanlineIndirect)(ScrnInfoPtr pScrn,
+ int bufno);
+static void MGANAME(SubsequentSolidFillRect)(ScrnInfoPtr pScrn,
+ int x, int y, int w, int h);
+static void MGANAME(SubsequentSolidFillTrap)(ScrnInfoPtr pScrn, int y, int h,
+ int left, int dxL, int dyL, int eL,
+ int right, int dxR, int dyR, int eR);
+static void MGANAME(SubsequentSolidHorVertLine) (ScrnInfoPtr pScrn,
+ int x, int y, int len, int dir);
+static void MGANAME(SubsequentSolidTwoPointLine)(ScrnInfoPtr pScrn,
+ int x1, int y1, int x2, int y2, int flags);
+static void MGANAME(SetupForMono8x8PatternFill)(ScrnInfoPtr pScrn,
+ int patx, int paty, int fg, int bg,
+ int rop, unsigned int planemask);
+static void MGANAME(SubsequentMono8x8PatternFillRect)(ScrnInfoPtr pScrn,
+ int patx, int paty,
+ int x, int y, int w, int h );
+static void MGANAME(SubsequentMono8x8PatternFillRect_Additional)(
+ ScrnInfoPtr pScrn, int patx, int paty,
+ int x, int y, int w, int h );
+static void MGANAME(SubsequentMono8x8PatternFillTrap)( ScrnInfoPtr pScrn,
+ int patx, int paty, int y, int h,
+ int left, int dxL, int dyL, int eL,
+ int right, int dxR, int dyR, int eR);
+static void MGANAME(SetupForScanlineImageWrite)(ScrnInfoPtr pScrn, int rop,
+ unsigned int planemask,
+ int transparency_color, int bpp, int depth);
+static void MGANAME(SubsequentScanlineImageWriteRect)(ScrnInfoPtr pScrn,
+ int x, int y, int w, int h, int skipleft);
+static void MGANAME(SubsequentImageWriteScanline)(ScrnInfoPtr pScrn, int num);
+#if PSZ != 24
+static void MGANAME(SetupForPlanarScreenToScreenColorExpandFill)(
+ ScrnInfoPtr pScrn, int fg, int bg, int rop,
+ unsigned int planemask);
+static void MGANAME(SubsequentPlanarScreenToScreenColorExpandFill)(
+ ScrnInfoPtr pScrn,
+ int x, int y, int w, int h,
+ int srcx, int srcy, int skipleft);
+#endif
+static void MGANAME(SetupForScreenToScreenColorExpandFill)(ScrnInfoPtr pScrn,
+ int fg, int bg, int rop,
+ unsigned int planemask);
+static void MGANAME(SubsequentScreenToScreenColorExpandFill)(ScrnInfoPtr pScrn,
+ int x, int y, int w, int h,
+ int srcx, int srcy, int skipleft);
+#if X_BYTE_ORDER == X_LITTLE_ENDIAN
+static void MGANAME(SetupForDashedLine)(ScrnInfoPtr pScrn, int fg, int bg,
+ int rop, unsigned int planemask, int length,
+ unsigned char *pattern);
+static void MGANAME(SubsequentDashedTwoPointLine)(ScrnInfoPtr pScrn,
+ int x1, int y1, int x2, int y2,
+ int flags, int phase);
+#endif
+void MGANAME(RestoreAccelState)(ScrnInfoPtr pScrn);
+#if PSZ == 8
+void Mga16RestoreAccelState(ScrnInfoPtr pScrn);
+void Mga24RestoreAccelState(ScrnInfoPtr pScrn);
+void Mga32RestoreAccelState(ScrnInfoPtr pScrn);
+#endif
+
+#ifdef XF86DRI
+void MGANAME(DRIInitBuffers)(WindowPtr pWin,
+ RegionPtr prgn, CARD32 index);
+void MGANAME(DRIMoveBuffers)(WindowPtr pParent, DDXPointRec ptOldOrg,
+ RegionPtr prgnSrc, CARD32 index);
+
+#endif
+
+extern void MGASetClippingRectangle(ScrnInfoPtr pScrn, int x1, int y1,
+ int x2, int y2);
+extern void MGADisableClipping(ScrnInfoPtr pScrn);
+extern void MGAFillSolidRectsDMA(ScrnInfoPtr pScrn, int fg, int rop,
+ unsigned int planemask, int nBox, BoxPtr pBox);
+extern void MGAFillSolidSpansDMA(ScrnInfoPtr pScrn, int fg, int rop,
+ unsigned int planemask, int n, DDXPointPtr ppt,
+ int *pwidth, int fSorted);
+extern void MGAFillMono8x8PatternRectsTwoPass(ScrnInfoPtr pScrn, int fg, int bg,
+ int rop, unsigned int planemask, int nBox,
+ BoxPtr pBox, int pattern0, int pattern1,
+ int xorigin, int yorigin);
+extern void MGAValidatePolyArc(GCPtr, unsigned long, DrawablePtr);
+extern void MGAValidatePolyPoint(GCPtr, unsigned long, DrawablePtr);
+extern void MGAFillCacheBltRects(ScrnInfoPtr, int, unsigned int, int, BoxPtr,
+ int, int, XAACacheInfoPtr);
+
+#ifdef RENDER
+
+extern Bool
+MGASetupForCPUToScreenAlphaTexture (
+ ScrnInfoPtr pScrn,
+ int op,
+ CARD16 red,
+ CARD16 green,
+ CARD16 blue,
+ CARD16 alpha,
+ int alphaType,
+ CARD8 *alphaPtr,
+ int alphaPitch,
+ int width,
+ int height,
+ int flags
+);
+
+extern Bool
+MGASetupForCPUToScreenAlphaTextureFaked (
+ ScrnInfoPtr pScrn,
+ int op,
+ CARD16 red,
+ CARD16 green,
+ CARD16 blue,
+ CARD16 alpha,
+ int alphaType,
+ CARD8 *alphaPtr,
+ int alphaPitch,
+ int width,
+ int height,
+ int flags
+);
+
+
+extern Bool
+MGASetupForCPUToScreenTexture (
+ ScrnInfoPtr pScrn,
+ int op,
+ int texType,
+ CARD8 *texPtr,
+ int texPitch,
+ int width,
+ int height,
+ int flags
+);
+
+extern void
+MGASubsequentCPUToScreenTexture (
+ ScrnInfoPtr pScrn,
+ int dstx,
+ int dsty,
+ int srcx,
+ int srcy,
+ int width,
+ int height
+);
+
+extern CARD32 MGAAlphaTextureFormats[2];
+extern CARD32 MGATextureFormats[2];
+
+#if PSZ == 8
+#include "mipict.h"
+#include "dixstruct.h"
+
+CARD32 MGAAlphaTextureFormats[2] = {PICT_a8, 0};
+CARD32 MGATextureFormats[2] = {PICT_a8r8g8b8, 0};
+
+static void
+RemoveLinear (FBLinearPtr linear)
+{
+ MGAPtr pMga = (MGAPtr)(linear->devPrivate.ptr);
+
+ pMga->LinearScratch = NULL; /* just lost our scratch */
+}
+
+static void
+RenderCallback (ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if((currentTime.milliseconds > pMga->RenderTime) && pMga->LinearScratch) {
+ xf86FreeOffscreenLinear(pMga->LinearScratch);
+ pMga->LinearScratch = NULL;
+ }
+
+ if(!pMga->LinearScratch)
+ pMga->RenderCallback = NULL;
+}
+
+#define RENDER_DELAY 15000
+
+static Bool
+AllocateLinear (
+ ScrnInfoPtr pScrn,
+ int sizeNeeded
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ pMga->RenderTime = currentTime.milliseconds + RENDER_DELAY;
+ pMga->RenderCallback = RenderCallback;
+
+ if(pMga->LinearScratch) {
+ if(pMga->LinearScratch->size >= sizeNeeded)
+ return TRUE;
+ else {
+ if(xf86ResizeOffscreenLinear(pMga->LinearScratch, sizeNeeded))
+ return TRUE;
+
+ xf86FreeOffscreenLinear(pMga->LinearScratch);
+ pMga->LinearScratch = NULL;
+ }
+ }
+
+ pMga->LinearScratch = xf86AllocateOffscreenLinear(
+ pScrn->pScreen, sizeNeeded, 32,
+ NULL, RemoveLinear, pMga);
+
+ return (pMga->LinearScratch != NULL);
+}
+
+static int
+GetPowerOfTwo(int w)
+{
+ int Pof2 = 0;
+ int i = 12;
+
+ while(--i) {
+ if(w & (1 << i)) {
+ Pof2 = i;
+ if(w & ((1 << i) - 1))
+ Pof2++;
+ break;
+ }
+ }
+ return Pof2;
+}
+
+
+static int tex_padw, tex_padh;
+
+Bool
+MGASetupForCPUToScreenAlphaTextureFaked (
+ ScrnInfoPtr pScrn,
+ int op,
+ CARD16 red,
+ CARD16 green,
+ CARD16 blue,
+ CARD16 alpha,
+ int alphaType,
+ CARD8 *alphaPtr,
+ int alphaPitch,
+ int width,
+ int height,
+ int flags
+){
+ int log2w, log2h, i, pitch, sizeNeeded, offset;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if(op != PictOpOver) /* only one tested */
+ return FALSE;
+
+ if((width > 2048) || (height > 2048))
+ return FALSE;
+
+ log2w = GetPowerOfTwo(width);
+ log2h = GetPowerOfTwo(height);
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ if(pMga->Overlay8Plus24) {
+ i = 0x00ffffff;
+ WAITFIFO(1);
+ SET_PLANEMASK(i);
+ }
+
+ pitch = (width + 15) & ~15;
+ sizeNeeded = pitch * height;
+ if(pScrn->bitsPerPixel == 16)
+ sizeNeeded <<= 1;
+
+ if(!AllocateLinear(pScrn, sizeNeeded))
+ return FALSE;
+
+ offset = pMga->LinearScratch->offset << 1;
+ if(pScrn->bitsPerPixel == 32)
+ offset <<= 1;
+
+ if(pMga->AccelInfoRec->NeedToSync)
+ MGAStormSync(pScrn);
+
+ XAA_888_plus_PICT_a8_to_8888(
+ (blue >> 8) | (green & 0xff00) | ((red & 0xff00) << 8),
+ alphaPtr, alphaPitch, (CARD32*)(pMga->FbStart + offset),
+ pitch, width, height);
+
+ tex_padw = 1 << log2w;
+ tex_padh = 1 << log2h;
+
+ WAITFIFO(15);
+ OUTREG(MGAREG_TMR0, (1 << 20) / tex_padw); /* sx inc */
+ OUTREG(MGAREG_TMR1, 0); /* sy inc */
+ OUTREG(MGAREG_TMR2, 0); /* tx inc */
+ OUTREG(MGAREG_TMR3, (1 << 20) / tex_padh); /* ty inc */
+ OUTREG(MGAREG_TMR4, 0x00000000);
+ OUTREG(MGAREG_TMR5, 0x00000000);
+ OUTREG(MGAREG_TMR8, 0x00010000);
+ OUTREG(MGAREG_TEXORG, offset);
+ OUTREG(MGAREG_TEXWIDTH, log2w | (((8 - log2w) & 63) << 9) |
+ ((width - 1) << 18));
+ OUTREG(MGAREG_TEXHEIGHT, log2h | (((8 - log2h) & 63) << 9) |
+ ((height - 1) << 18));
+ OUTREG(MGAREG_TEXCTL, 0x1A000106 | ((pitch & 0x07FF) << 9));
+ OUTREG(MGAREG_TEXCTL2, 0x00000014);
+ OUTREG(MGAREG_DWGCTL, 0x000c7076);
+ OUTREG(MGAREG_TEXFILTER, 0x01e00020);
+ OUTREG(MGAREG_ALPHACTRL, 0x00000154);
+
+ return TRUE;
+}
+
+Bool
+MGASetupForCPUToScreenAlphaTexture (
+ ScrnInfoPtr pScrn,
+ int op,
+ CARD16 red,
+ CARD16 green,
+ CARD16 blue,
+ CARD16 alpha,
+ int alphaType,
+ CARD8 *alphaPtr,
+ int alphaPitch,
+ int width,
+ int height,
+ int flags
+){
+ int log2w, log2h, i, pitch, sizeNeeded, offset;
+ CARD8 *dst;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if(op != PictOpOver) /* only one tested */
+ return FALSE;
+
+ if((width > 2048) || (height > 2048))
+ return FALSE;
+
+ log2w = GetPowerOfTwo(width);
+ log2h = GetPowerOfTwo(height);
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ if(pMga->Overlay8Plus24) {
+ i = 0x00ffffff;
+ WAITFIFO(1);
+ SET_PLANEMASK(i);
+ }
+
+ pitch = (width + 15) & ~15;
+ sizeNeeded = (pitch * height) >> 1;
+ if(pScrn->bitsPerPixel == 32)
+ sizeNeeded >>= 1;
+
+ if(!AllocateLinear(pScrn, sizeNeeded))
+ return FALSE;
+
+ offset = pMga->LinearScratch->offset << 1;
+ if(pScrn->bitsPerPixel == 32)
+ offset <<= 1;
+
+ if(pMga->AccelInfoRec->NeedToSync)
+ MGAStormSync(pScrn);
+
+ i = height;
+ dst = pMga->FbStart + offset;
+ while(i--) {
+ memcpy(dst, alphaPtr, width);
+ dst += pitch;
+ alphaPtr += alphaPitch;
+ }
+
+ tex_padw = 1 << log2w;
+ tex_padh = 1 << log2h;
+
+
+ WAITFIFO(12);
+ OUTREG(MGAREG_DR4, red << 7); /* red start */
+ OUTREG(MGAREG_DR6, 0);
+ OUTREG(MGAREG_DR7, 0);
+ OUTREG(MGAREG_DR8, green << 7); /* green start */
+ OUTREG(MGAREG_DR10, 0);
+ OUTREG(MGAREG_DR11, 0);
+ OUTREG(MGAREG_DR12, blue << 7); /* blue start */
+ OUTREG(MGAREG_DR14, 0);
+ OUTREG(MGAREG_DR15, 0);
+ OUTREG(MGAREG_ALPHASTART, alpha << 7); /* alpha start */
+ OUTREG(MGAREG_ALPHAXINC, 0);
+ OUTREG(MGAREG_ALPHAYINC, 0);
+
+ WAITFIFO(15);
+ OUTREG(MGAREG_TMR0, (1 << 20) / tex_padw); /* sx inc */
+ OUTREG(MGAREG_TMR1, 0); /* sy inc */
+ OUTREG(MGAREG_TMR2, 0); /* tx inc */
+ OUTREG(MGAREG_TMR3, (1 << 20) / tex_padh); /* ty inc */
+ OUTREG(MGAREG_TMR4, 0x00000000);
+ OUTREG(MGAREG_TMR5, 0x00000000);
+ OUTREG(MGAREG_TMR8, 0x00010000);
+ OUTREG(MGAREG_TEXORG, offset);
+ OUTREG(MGAREG_TEXWIDTH, log2w | (((8 - log2w) & 63) << 9) |
+ ((width - 1) << 18));
+ OUTREG(MGAREG_TEXHEIGHT, log2h | (((8 - log2h) & 63) << 9) |
+ ((height - 1) << 18));
+ OUTREG(MGAREG_TEXCTL, 0x3A000107 | ((pitch & 0x07FF) << 9));
+ OUTREG(MGAREG_TEXCTL2, 0x00000014);
+ OUTREG(MGAREG_DWGCTL, 0x000c7076);
+ OUTREG(MGAREG_TEXFILTER, 0x01e00020);
+ OUTREG(MGAREG_ALPHACTRL, 0x02000151);
+
+ return TRUE;
+}
+
+
+Bool
+MGASetupForCPUToScreenTexture (
+ ScrnInfoPtr pScrn,
+ int op,
+ int texType,
+ CARD8 *texPtr,
+ int texPitch,
+ int width,
+ int height,
+ int flags
+){
+ int log2w, log2h, i, pitch, sizeNeeded, offset;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if(op != PictOpOver) /* only one tested */
+ return FALSE;
+
+ if((width > 2048) || (height > 2048))
+ return FALSE;
+
+ log2w = GetPowerOfTwo(width);
+ log2h = GetPowerOfTwo(height);
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ if(pMga->Overlay8Plus24) {
+ i = 0x00ffffff;
+ WAITFIFO(1);
+ SET_PLANEMASK(i);
+ }
+
+ pitch = (width + 15) & ~15;
+ sizeNeeded = pitch * height;
+ if(pScrn->bitsPerPixel == 16)
+ sizeNeeded <<= 1;
+
+ if(!AllocateLinear(pScrn, sizeNeeded))
+ return FALSE;
+
+ offset = pMga->LinearScratch->offset << 1;
+ if(pScrn->bitsPerPixel == 32)
+ offset <<= 1;
+
+ if(pMga->AccelInfoRec->NeedToSync)
+ MGAStormSync(pScrn);
+
+ {
+ CARD8 *dst = (CARD8*)(pMga->FbStart + offset);
+ i = height;
+ while(i--) {
+ memcpy(dst, texPtr, width << 2);
+ texPtr += texPitch;
+ dst += pitch << 2;
+ }
+ }
+
+ tex_padw = 1 << log2w;
+ tex_padh = 1 << log2h;
+
+ WAITFIFO(15);
+ OUTREG(MGAREG_TMR0, (1 << 20) / tex_padw); /* sx inc */
+ OUTREG(MGAREG_TMR1, 0); /* sy inc */
+ OUTREG(MGAREG_TMR2, 0); /* tx inc */
+ OUTREG(MGAREG_TMR3, (1 << 20) / tex_padh); /* ty inc */
+ OUTREG(MGAREG_TMR4, 0x00000000);
+ OUTREG(MGAREG_TMR5, 0x00000000);
+ OUTREG(MGAREG_TMR8, 0x00010000);
+ OUTREG(MGAREG_TEXORG, offset);
+ OUTREG(MGAREG_TEXWIDTH, log2w | (((8 - log2w) & 63) << 9) |
+ ((width - 1) << 18));
+ OUTREG(MGAREG_TEXHEIGHT, log2h | (((8 - log2h) & 63) << 9) |
+ ((height - 1) << 18));
+ OUTREG(MGAREG_TEXCTL, 0x1A000106 | ((pitch & 0x07FF) << 9));
+ OUTREG(MGAREG_TEXCTL2, 0x00000014);
+ OUTREG(MGAREG_DWGCTL, 0x000c7076);
+ OUTREG(MGAREG_TEXFILTER, 0x01e00020);
+ OUTREG(MGAREG_ALPHACTRL, 0x00000151);
+
+ return TRUE;
+}
+void
+MGASubsequentCPUToScreenTexture (
+ ScrnInfoPtr pScrn,
+ int dstx,
+ int dsty,
+ int srcx,
+ int srcy,
+ int width,
+ int height
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ WAITFIFO(4);
+ OUTREG(MGAREG_TMR6, (srcx << 20) / tex_padw);
+ OUTREG(MGAREG_TMR7, (srcy << 20) / tex_padh);
+ OUTREG(MGAREG_FXBNDRY, ((dstx + width) << 16) | (dstx & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (dsty << 16) | height);
+
+ pMga->AccelInfoRec->NeedToSync = TRUE;
+}
+
+
+#endif
+#endif
+
+Bool
+MGANAME(AccelInit)(ScreenPtr pScreen)
+{
+ XAAInfoRecPtr infoPtr;
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ int maxFastBlitMem, maxlines;
+ Bool doRender = FALSE;
+ BoxRec AvailFBArea;
+
+ pMga->ScratchBuffer = xalloc(((pScrn->displayWidth * PSZ) + 127) >> 3);
+ if(!pMga->ScratchBuffer) return FALSE;
+
+ pMga->AccelInfoRec = infoPtr = XAACreateInfoRec();
+ if(!infoPtr) return FALSE;
+
+ pMga->RenderTime = 0;
+ pMga->LinearScratch = 0;
+
+ pMga->MaxFastBlitY = 0;
+ pMga->MaxBlitDWORDS = 0x40000 >> 5;
+
+ switch (pMga->Chipset) {
+ case PCI_CHIP_MGA2064:
+ pMga->AccelFlags = BLK_OPAQUE_EXPANSION | FASTBLT_BUG;
+ break;
+ case PCI_CHIP_MGA2164:
+ case PCI_CHIP_MGA2164_AGP:
+ pMga->AccelFlags = BLK_OPAQUE_EXPANSION |
+ TRANSC_SOLID_FILL |
+ USE_RECTS_FOR_LINES;
+ break;
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG550:
+ if(pMga->SecondCrtc == TRUE) {
+ pMga->HasFBitBlt = FALSE;
+ }
+ pMga->MaxBlitDWORDS = 0x400000 >> 5;
+ /* fallthrough */
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ doRender = FALSE;
+ pMga->AccelFlags = TRANSC_SOLID_FILL |
+ TWO_PASS_COLOR_EXPAND;
+
+#if 1
+ if((pMga->FbMapSize > 8*1024*1024) && (pScrn->depth == 8))
+ pMga->AccelFlags |= LARGE_ADDRESSES;
+#endif
+ break;
+ case PCI_CHIP_MGA1064:
+ pMga->AccelFlags = 0;
+ break;
+ case PCI_CHIP_MGAG100:
+ case PCI_CHIP_MGAG100_PCI:
+ default:
+ pMga->AccelFlags = MGA_NO_PLANEMASK;
+ break;
+ }
+
+ /* all should be able to use this now with the bug fixes */
+ pMga->AccelFlags |= USE_LINEAR_EXPANSION;
+
+#if PSZ == 24
+ pMga->AccelFlags |= MGA_NO_PLANEMASK;
+#endif
+
+ if(pMga->HasSDRAM) {
+ pMga->Atype = pMga->AtypeNoBLK = MGAAtypeNoBLK;
+ pMga->AccelFlags &= ~TWO_PASS_COLOR_EXPAND;
+ } else {
+ pMga->Atype = MGAAtype;
+ pMga->AtypeNoBLK = MGAAtypeNoBLK;
+ }
+
+ /* fill out infoPtr here */
+ infoPtr->Flags = PIXMAP_CACHE |
+ OFFSCREEN_PIXMAPS |
+ LINEAR_FRAMEBUFFER |
+ MICROSOFT_ZERO_LINE_BIAS;
+
+ /* sync */
+ infoPtr->Sync = MGAStormSync;
+
+ /* screen to screen copy */
+ infoPtr->ScreenToScreenCopyFlags = NO_TRANSPARENCY;
+ infoPtr->SetupForScreenToScreenCopy =
+ MGANAME(SetupForScreenToScreenCopy);
+ infoPtr->SubsequentScreenToScreenCopy =
+ MGANAME(SubsequentScreenToScreenCopy);
+
+ if(pMga->HasFBitBlt) {
+ infoPtr->FillCacheBltRects = MGAFillCacheBltRects;
+ infoPtr->FillCacheBltRectsFlags = NO_TRANSPARENCY;
+ }
+ /* solid fills */
+ infoPtr->SetupForSolidFill = MGANAME(SetupForSolidFill);
+ infoPtr->SubsequentSolidFillRect = MGANAME(SubsequentSolidFillRect);
+ infoPtr->SubsequentSolidFillTrap = MGANAME(SubsequentSolidFillTrap);
+
+ /* solid lines */
+ infoPtr->SetupForSolidLine = infoPtr->SetupForSolidFill;
+ infoPtr->SubsequentSolidHorVertLine =
+ MGANAME(SubsequentSolidHorVertLine);
+ infoPtr->SubsequentSolidTwoPointLine =
+ MGANAME(SubsequentSolidTwoPointLine);
+
+ /* clipping */
+ infoPtr->SetClippingRectangle = MGASetClippingRectangle;
+ infoPtr->DisableClipping = MGADisableClipping;
+ infoPtr->ClippingFlags = HARDWARE_CLIP_SOLID_LINE |
+ HARDWARE_CLIP_DASHED_LINE |
+ HARDWARE_CLIP_SOLID_FILL |
+ HARDWARE_CLIP_MONO_8x8_FILL;
+
+#if X_BYTE_ORDER == X_LITTLE_ENDIAN
+ /* dashed lines */
+ infoPtr->DashedLineFlags = LINE_PATTERN_MSBFIRST_LSBJUSTIFIED;
+ infoPtr->SetupForDashedLine = MGANAME(SetupForDashedLine);
+ infoPtr->SubsequentDashedTwoPointLine =
+ MGANAME(SubsequentDashedTwoPointLine);
+ infoPtr->DashPatternMaxLength = 128;
+#endif
+
+ /* 8x8 mono patterns */
+ infoPtr->Mono8x8PatternFillFlags = HARDWARE_PATTERN_PROGRAMMED_BITS |
+ HARDWARE_PATTERN_PROGRAMMED_ORIGIN |
+ HARDWARE_PATTERN_SCREEN_ORIGIN |
+ BIT_ORDER_IN_BYTE_MSBFIRST;
+ infoPtr->SetupForMono8x8PatternFill = MGANAME(SetupForMono8x8PatternFill);
+ infoPtr->SubsequentMono8x8PatternFillRect =
+ MGANAME(SubsequentMono8x8PatternFillRect);
+ infoPtr->SubsequentMono8x8PatternFillTrap =
+ MGANAME(SubsequentMono8x8PatternFillTrap);
+
+ /* cpu to screen color expansion */
+ infoPtr->ScanlineCPUToScreenColorExpandFillFlags =
+ CPU_TRANSFER_PAD_DWORD |
+ SCANLINE_PAD_DWORD |
+#if X_BYTE_ORDER == X_BIG_ENDIAN
+ BIT_ORDER_IN_BYTE_MSBFIRST |
+#else
+ BIT_ORDER_IN_BYTE_LSBFIRST |
+#endif
+ LEFT_EDGE_CLIPPING |
+ LEFT_EDGE_CLIPPING_NEGATIVE_X;
+
+ if(pMga->ILOADBase) {
+ pMga->ColorExpandBase = pMga->ILOADBase;
+ } else {
+ pMga->ColorExpandBase = pMga->IOBase;
+ }
+ infoPtr->SetupForScanlineCPUToScreenColorExpandFill =
+ MGANAME(SetupForScanlineCPUToScreenColorExpandFill);
+ infoPtr->SubsequentScanlineCPUToScreenColorExpandFill =
+ MGANAME(SubsequentScanlineCPUToScreenColorExpandFill);
+ infoPtr->SubsequentColorExpandScanline =
+ MGANAME(SubsequentColorExpandScanline);
+ infoPtr->NumScanlineColorExpandBuffers = 1;
+ infoPtr->ScanlineColorExpandBuffers = &(pMga->ColorExpandBase);
+
+ /* screen to screen color expansion */
+ if(pMga->AccelFlags & USE_LINEAR_EXPANSION) {
+ infoPtr->ScreenToScreenColorExpandFillFlags =
+ BIT_ORDER_IN_BYTE_LSBFIRST;
+ infoPtr->SetupForScreenToScreenColorExpandFill =
+ MGANAME(SetupForScreenToScreenColorExpandFill);
+ infoPtr->SubsequentScreenToScreenColorExpandFill =
+ MGANAME(SubsequentScreenToScreenColorExpandFill);
+ } else {
+#if PSZ != 24
+ /* Alternate (but slower) planar expansions */
+ infoPtr->SetupForScreenToScreenColorExpandFill =
+ MGANAME(SetupForPlanarScreenToScreenColorExpandFill);
+ infoPtr->SubsequentScreenToScreenColorExpandFill =
+ MGANAME(SubsequentPlanarScreenToScreenColorExpandFill);
+ infoPtr->CacheColorExpandDensity = PSZ;
+ infoPtr->CacheMonoStipple = XAACachePlanarMonoStipple;
+ /* It's faster to blit the stipples if you have fastbilt */
+ if(pMga->HasFBitBlt)
+ infoPtr->ScreenToScreenColorExpandFillFlags = TRANSPARENCY_ONLY;
+#endif
+ }
+
+ /* image writes */
+ infoPtr->ScanlineImageWriteFlags = CPU_TRANSFER_PAD_DWORD |
+ SCANLINE_PAD_DWORD |
+ LEFT_EDGE_CLIPPING |
+ LEFT_EDGE_CLIPPING_NEGATIVE_X |
+ NO_TRANSPARENCY |
+ NO_GXCOPY;
+
+ infoPtr->SetupForScanlineImageWrite =
+ MGANAME(SetupForScanlineImageWrite);
+ infoPtr->SubsequentScanlineImageWriteRect =
+ MGANAME(SubsequentScanlineImageWriteRect);
+ infoPtr->SubsequentImageWriteScanline =
+ MGANAME(SubsequentImageWriteScanline);
+ infoPtr->NumScanlineImageWriteBuffers = 1;
+ infoPtr->ScanlineImageWriteBuffers = &(pMga->ScratchBuffer);
+
+
+ /* midrange replacements */
+
+ if(pMga->ILOADBase && pMga->UsePCIRetry && infoPtr->SetupForSolidFill) {
+ infoPtr->FillSolidRects = MGAFillSolidRectsDMA;
+ infoPtr->FillSolidSpans = MGAFillSolidSpansDMA;
+ }
+
+ if(pMga->AccelFlags & TWO_PASS_COLOR_EXPAND) {
+ if(infoPtr->SetupForMono8x8PatternFill)
+ infoPtr->FillMono8x8PatternRects =
+ MGAFillMono8x8PatternRectsTwoPass;
+ }
+
+ if(infoPtr->SetupForSolidFill) {
+ infoPtr->ValidatePolyArc = MGAValidatePolyArc;
+ infoPtr->PolyArcMask = GCFunction | GCLineWidth | GCPlaneMask |
+ GCLineStyle | GCFillStyle;
+ infoPtr->ValidatePolyPoint = MGAValidatePolyPoint;
+ infoPtr->PolyPointMask = GCFunction | GCPlaneMask;
+ }
+ if(pMga->AccelFlags & MGA_NO_PLANEMASK) {
+ infoPtr->ScanlineImageWriteFlags |= NO_PLANEMASK;
+ infoPtr->ScreenToScreenCopyFlags |= NO_PLANEMASK;
+ infoPtr->ScanlineCPUToScreenColorExpandFillFlags |= NO_PLANEMASK;
+ infoPtr->SolidFillFlags |= NO_PLANEMASK;
+ infoPtr->SolidLineFlags |= NO_PLANEMASK;
+#if X_BYTE_ORDER == X_LITTLE_ENDIAN
+ infoPtr->DashedLineFlags |= NO_PLANEMASK;
+#endif
+ infoPtr->Mono8x8PatternFillFlags |= NO_PLANEMASK;
+ infoPtr->ScreenToScreenColorExpandFillFlags |= NO_PLANEMASK;
+ infoPtr->FillSolidRectsFlags |= NO_PLANEMASK;
+ infoPtr->FillSolidSpansFlags |= NO_PLANEMASK;
+ infoPtr->FillMono8x8PatternRectsFlags |= NO_PLANEMASK;
+ infoPtr->FillCacheBltRectsFlags |= NO_PLANEMASK;
+ }
+
+
+ maxFastBlitMem = (pMga->Interleave ? 4096 : 2048) * 1024;
+
+ if(pMga->FbMapSize > maxFastBlitMem) {
+ pMga->MaxFastBlitY = maxFastBlitMem / (pScrn->displayWidth * PSZ / 8);
+ }
+
+ maxlines = (min(pMga->FbUsableSize, 16*1024*1024)) /
+ (pScrn->displayWidth * PSZ / 8);
+
+#ifdef XF86DRI
+ if ( pMga->directRenderingEnabled ) {
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+ BoxRec MemBox;
+ int cpp = pScrn->bitsPerPixel / 8;
+ int widthBytes = pScrn->displayWidth * cpp;
+ int bufferSize = ((pScrn->virtualY * widthBytes + MGA_BUFFER_ALIGN)
+ & ~MGA_BUFFER_ALIGN);
+ int scanlines;
+
+ pMGADRIServer->frontOffset = 0;
+ pMGADRIServer->frontPitch = widthBytes;
+
+ /* Try for front, back, depth, and two framebuffers worth of
+ * pixmap cache. Should be enough for a fullscreen background
+ * image plus some leftovers.
+ */
+ pMGADRIServer->textureSize = pMga->FbMapSize - 5 * bufferSize;
+
+ /* If that gives us less than half the available memory, let's
+ * be greedy and grab some more. Sorry, I care more about 3D
+ * performance than playing nicely, and you'll get around a full
+ * framebuffer's worth of pixmap cache anyway.
+ */
+ if ( pMGADRIServer->textureSize < (int)pMga->FbMapSize / 2 ) {
+ pMGADRIServer->textureSize = pMga->FbMapSize - 4 * bufferSize;
+ }
+
+ /* Check to see if there is more room available after the maximum
+ * scanline for textures.
+ */
+ if ( (int)pMga->FbMapSize - maxlines * widthBytes - bufferSize * 2
+ > pMGADRIServer->textureSize ) {
+ pMGADRIServer->textureSize = (pMga->FbMapSize -
+ maxlines * widthBytes -
+ bufferSize * 2);
+ }
+
+ /* Set a minimum usable local texture heap size. This will fit
+ * two 256x256x32bpp textures.
+ */
+ if ( pMGADRIServer->textureSize < 512 * 1024 ) {
+ pMGADRIServer->textureOffset = 0;
+ pMGADRIServer->textureSize = 0;
+ }
+
+ /* Reserve space for textures */
+ pMGADRIServer->textureOffset = (pMga->FbMapSize -
+ pMGADRIServer->textureSize +
+ MGA_BUFFER_ALIGN) & ~MGA_BUFFER_ALIGN;
+
+ /* Reserve space for the shared depth buffer */
+ pMGADRIServer->depthOffset = (pMGADRIServer->textureOffset -
+ bufferSize +
+ MGA_BUFFER_ALIGN) & ~MGA_BUFFER_ALIGN;
+ pMGADRIServer->depthPitch = widthBytes;
+
+ /* Reserve space for the shared back buffer */
+ pMGADRIServer->backOffset = (pMGADRIServer->depthOffset - bufferSize +
+ MGA_BUFFER_ALIGN) & ~MGA_BUFFER_ALIGN;
+ pMGADRIServer->backPitch = widthBytes;
+
+ scanlines = pMGADRIServer->backOffset / widthBytes - 1;
+ if ( scanlines > maxlines ) scanlines = maxlines;
+
+ MemBox.x1 = 0;
+ MemBox.y1 = 0;
+ MemBox.x2 = pScrn->displayWidth;
+ MemBox.y2 = scanlines;
+
+ if ( !xf86InitFBManager( pScreen, &MemBox ) ) {
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "Memory manager initialization to (%d,%d) (%d,%d) failed\n",
+ MemBox.x1, MemBox.y1, MemBox.x2, MemBox.y2 );
+ return FALSE;
+ } else {
+ int width, height;
+
+ xf86DrvMsg( pScrn->scrnIndex, X_INFO,
+ "Memory manager initialized to (%d,%d) (%d,%d)\n",
+ MemBox.x1, MemBox.y1, MemBox.x2, MemBox.y2 );
+
+ if ( xf86QueryLargestOffscreenArea( pScreen, &width,
+ &height, 0, 0, 0 ) ) {
+ xf86DrvMsg( pScrn->scrnIndex, X_INFO,
+ "Largest offscreen area available: %d x %d\n",
+ width, height );
+ }
+ }
+
+ xf86DrvMsg( pScrn->scrnIndex, X_INFO,
+ "Reserved back buffer at offset 0x%x\n",
+ pMGADRIServer->backOffset );
+ xf86DrvMsg( pScrn->scrnIndex, X_INFO,
+ "Reserved depth buffer at offset 0x%x\n",
+ pMGADRIServer->depthOffset );
+ xf86DrvMsg( pScrn->scrnIndex, X_INFO,
+ "Reserved %d kb for textures at offset 0x%x\n",
+ pMGADRIServer->textureSize/1024,
+ pMGADRIServer->textureOffset );
+ }
+ else
+#endif
+ {
+ AvailFBArea.x1 = 0;
+ AvailFBArea.x2 = pScrn->displayWidth;
+ AvailFBArea.y1 = 0;
+ AvailFBArea.y2 = maxlines;
+
+ /*
+ * Need to keep a strip of memory to the right of screen to workaround
+ * a display problem with the second CRTC.
+ */
+ if (pMga->SecondCrtc)
+ AvailFBArea.x2 = pScrn->virtualX;
+
+ xf86InitFBManager(pScreen, &AvailFBArea);
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Using %d lines for offscreen "
+ "memory.\n",
+ maxlines - pScrn->virtualY);
+
+ }
+
+ {
+ Bool shared_accel = FALSE;
+ int i;
+
+ for(i = 0; i < pScrn->numEntities; i++) {
+ if(xf86IsEntityShared(pScrn->entityList[i]))
+ shared_accel = TRUE;
+ }
+ if(shared_accel == TRUE)
+ infoPtr->RestoreAccelState = MGANAME(RestoreAccelState);
+ }
+
+#ifdef RENDER
+ if(doRender && ((pScrn->bitsPerPixel == 32) || (pScrn->bitsPerPixel == 16)))
+ {
+ if(pMga->Chipset == PCI_CHIP_MGAG400 || pMga->Chipset == PCI_CHIP_MGAG550) {
+ infoPtr->CPUToScreenAlphaTextureFlags = XAA_RENDER_NO_TILE;
+ infoPtr->SetupForCPUToScreenAlphaTexture =
+ MGASetupForCPUToScreenAlphaTexture;
+ } else {
+ infoPtr->CPUToScreenAlphaTextureFlags = XAA_RENDER_NO_TILE |
+ XAA_RENDER_NO_SRC_ALPHA;
+ infoPtr->SetupForCPUToScreenAlphaTexture =
+ MGASetupForCPUToScreenAlphaTextureFaked;
+ }
+ infoPtr->SubsequentCPUToScreenAlphaTexture =
+ MGASubsequentCPUToScreenTexture;
+ infoPtr->CPUToScreenAlphaTextureFormats = MGAAlphaTextureFormats;
+
+ infoPtr->SetupForCPUToScreenTexture = MGASetupForCPUToScreenTexture;
+ infoPtr->SubsequentCPUToScreenTexture = MGASubsequentCPUToScreenTexture;
+ infoPtr->CPUToScreenTextureFlags = XAA_RENDER_NO_TILE;
+ infoPtr->CPUToScreenTextureFormats = MGATextureFormats;
+ }
+#endif
+
+ return(XAAInit(pScreen, infoPtr));
+}
+
+void
+MGANAME(InitSolidFillRectFuncs)(MGAPtr pMga)
+{
+ pMga->SetupForSolidFill = MGANAME(SetupForSolidFill);
+ pMga->SubsequentSolidFillRect = MGANAME(SubsequentSolidFillRect);
+}
+
+/* Support for multiscreen */
+void
+MGANAME(RestoreAccelState)(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAFBLayout *pLayout = &pMga->CurrentLayout;
+ CARD32 tmp;
+
+ MGAStormSync(pScrn);
+ WAITFIFO(12);
+ pMga->SrcOrg = 0;
+ OUTREG(MGAREG_MACCESS, pMga->MAccess);
+ OUTREG(MGAREG_PITCH, pLayout->displayWidth);
+ OUTREG(MGAREG_YDSTORG, pMga->YDstOrg);
+ tmp = pMga->PlaneMask;
+ pMga->PlaneMask = ~tmp;
+ SET_PLANEMASK(tmp);
+ tmp = pMga->BgColor;
+ pMga->BgColor = ~tmp;
+ SET_BACKGROUND(tmp);
+ tmp = pMga->FgColor;
+ pMga->FgColor = ~tmp;
+ SET_FOREGROUND(tmp);
+ OUTREG(MGAREG_SRCORG, pMga->realSrcOrg);
+ OUTREG(MGAREG_DSTORG, pMga->DstOrg);
+#if X_BYTE_ORDER == X_LITTLE_ENDIAN
+ OUTREG(MGAREG_OPMODE, MGAOPM_DMA_BLIT );
+#else
+ OUTREG(MGAREG_OPMODE, MGAOPM_DMA_BLIT | 0x10000);
+#endif
+ OUTREG(MGAREG_CXBNDRY, 0xFFFF0000); /* (maxX << 16) | minX */
+ OUTREG(MGAREG_YTOP, 0x00000000); /* minPixelPointer */
+ OUTREG(MGAREG_YBOT, 0x007FFFFF); /* maxPixelPointer */
+ pMga->AccelFlags &= ~CLIPPER_ON;
+}
+
+#if PSZ == 8
+
+CARD32 MGAAtype[16] = {
+ MGADWG_RPL | 0x00000000, MGADWG_RSTR | 0x00080000,
+ MGADWG_RSTR | 0x00040000, MGADWG_BLK | 0x000c0000,
+ MGADWG_RSTR | 0x00020000, MGADWG_RSTR | 0x000a0000,
+ MGADWG_RSTR | 0x00060000, MGADWG_RSTR | 0x000e0000,
+ MGADWG_RSTR | 0x00010000, MGADWG_RSTR | 0x00090000,
+ MGADWG_RSTR | 0x00050000, MGADWG_RSTR | 0x000d0000,
+ MGADWG_RPL | 0x00030000, MGADWG_RSTR | 0x000b0000,
+ MGADWG_RSTR | 0x00070000, MGADWG_RPL | 0x000f0000
+};
+
+
+CARD32 MGAAtypeNoBLK[16] = {
+ MGADWG_RPL | 0x00000000, MGADWG_RSTR | 0x00080000,
+ MGADWG_RSTR | 0x00040000, MGADWG_RPL | 0x000c0000,
+ MGADWG_RSTR | 0x00020000, MGADWG_RSTR | 0x000a0000,
+ MGADWG_RSTR | 0x00060000, MGADWG_RSTR | 0x000e0000,
+ MGADWG_RSTR | 0x00010000, MGADWG_RSTR | 0x00090000,
+ MGADWG_RSTR | 0x00050000, MGADWG_RSTR | 0x000d0000,
+ MGADWG_RPL | 0x00030000, MGADWG_RSTR | 0x000b0000,
+ MGADWG_RSTR | 0x00070000, MGADWG_RPL | 0x000f0000
+};
+
+
+Bool
+MGAStormAccelInit(ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+
+ switch( pScrn->bitsPerPixel )
+ {
+ case 8:
+ return Mga8AccelInit(pScreen);
+ case 16:
+ return Mga16AccelInit(pScreen);
+ case 24:
+ return Mga24AccelInit(pScreen);
+ case 32:
+ return Mga32AccelInit(pScreen);
+ }
+ return FALSE;
+}
+
+
+
+void
+MGAStormSync(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ while(MGAISBUSY());
+ /* flush cache before a read (mga-1064g 5.1.6) */
+ OUTREG8(MGAREG_CRTC_INDEX, 0);
+ if(pMga->AccelFlags & CLIPPER_ON) {
+ pMga->AccelFlags &= ~CLIPPER_ON;
+ OUTREG(MGAREG_CXBNDRY, 0xFFFF0000);
+ }
+}
+
+void
+MGAStormEngineInit(ScrnInfoPtr pScrn)
+{
+ long maccess = 0;
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAFBLayout *pLayout = &pMga->CurrentLayout;
+ CARD32 opmode;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ if ((pMga->Chipset == PCI_CHIP_MGAG100)
+ || (pMga->Chipset == PCI_CHIP_MGAG100_PCI))
+ maccess = 1 << 14;
+
+ opmode = INREG(MGAREG_OPMODE);
+
+ switch( pLayout->bitsPerPixel )
+ {
+ case 8:
+ pMga->RestoreAccelState = Mga8RestoreAccelState;
+ break;
+ case 16:
+ maccess |= 1;
+ if(pLayout->depth == 15)
+ maccess |= (1 << 31);
+ Mga16InitSolidFillRectFuncs(pMga);
+ pMga->RestoreAccelState = Mga16RestoreAccelState;
+ opmode |= 0x10000;
+ break;
+ case 24:
+ maccess |= 3;
+ Mga24InitSolidFillRectFuncs(pMga);
+ pMga->RestoreAccelState = Mga24RestoreAccelState;
+ opmode |= 0x20000;
+ break;
+ case 32:
+ maccess |= 2;
+ Mga32InitSolidFillRectFuncs(pMga);
+ pMga->RestoreAccelState = Mga32RestoreAccelState;
+ opmode |= 0x20000;
+ break;
+ }
+#if X_BYTE_ORDER == X_LITTLE_ENDIAN
+ opmode &= ~0x30000;
+#endif
+
+ pMga->fifoCount = 0;
+
+ while(MGAISBUSY());
+
+ if(!pMga->FifoSize) {
+ pMga->FifoSize = INREG8(MGAREG_FIFOSTATUS);
+ xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "%i DWORD fifo\n",
+ pMga->FifoSize);
+ }
+
+ OUTREG(MGAREG_PITCH, pLayout->displayWidth);
+ OUTREG(MGAREG_YDSTORG, pMga->YDstOrg);
+ OUTREG(MGAREG_MACCESS, maccess);
+ pMga->MAccess = maccess;
+ pMga->PlaneMask = ~0;
+ /* looks like this doesn't apply to mga g100 pci */
+
+ if ((pMga->Chipset != PCI_CHIP_MGAG100)
+ && (pMga->Chipset != PCI_CHIP_MGAG100_PCI))
+ OUTREG(MGAREG_PLNWT, pMga->PlaneMask);
+
+ pMga->FgColor = 0;
+ OUTREG(MGAREG_FCOL, pMga->FgColor);
+ pMga->BgColor = 0;
+ OUTREG(MGAREG_BCOL, pMga->BgColor);
+ OUTREG(MGAREG_OPMODE, MGAOPM_DMA_BLIT | opmode);
+
+ /* put clipping in a known state */
+ OUTREG(MGAREG_CXBNDRY, 0xFFFF0000); /* (maxX << 16) | minX */
+ OUTREG(MGAREG_YTOP, 0x00000000); /* minPixelPointer */
+ OUTREG(MGAREG_YBOT, 0x007FFFFF); /* maxPixelPointer */
+ pMga->AccelFlags &= ~CLIPPER_ON;
+
+ switch(pMga->Chipset) {
+ case PCI_CHIP_MGAG550:
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ pMga->SrcOrg = 0;
+ OUTREG(MGAREG_SRCORG, pMga->realSrcOrg);
+ OUTREG(MGAREG_DSTORG, pMga->DstOrg);
+ break;
+ default:
+ break;
+ }
+ xf86SetLastScrnFlag(pScrn->entityList[0], pScrn->scrnIndex);
+
+}
+
+void MGASetClippingRectangle(
+ ScrnInfoPtr pScrn,
+ int x1, int y1, int x2, int y2
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ WAITFIFO(3);
+ OUTREG(MGAREG_CXBNDRY,(x2 << 16) | x1);
+ OUTREG(MGAREG_YTOP, (y1 * pScrn->displayWidth) + pMga->YDstOrg);
+ OUTREG(MGAREG_YBOT, (y2 * pScrn->displayWidth) + pMga->YDstOrg);
+ pMga->AccelFlags |= CLIPPER_ON;
+}
+
+void MGADisableClipping(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ WAITFIFO(3);
+ OUTREG(MGAREG_CXBNDRY, 0xFFFF0000); /* (maxX << 16) | minX */
+ OUTREG(MGAREG_YTOP, 0x00000000); /* minPixelPointer */
+ OUTREG(MGAREG_YBOT, 0x007FFFFF); /* maxPixelPointer */
+ pMga->AccelFlags &= ~CLIPPER_ON;
+}
+
+#endif
+
+
+ /*********************************************\
+ | Screen-to-Screen Copy |
+ \*********************************************/
+
+#define BLIT_LEFT 1
+#define BLIT_UP 4
+
+void
+MGANAME(SetupForScreenToScreenCopy)(
+ ScrnInfoPtr pScrn,
+ int xdir, int ydir,
+ int rop,
+ unsigned int planemask,
+ int trans
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ CARD32 dwgctl = pMga->AtypeNoBLK[rop] | MGADWG_SHIFTZERO |
+ MGADWG_BITBLT | MGADWG_BFCOL;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ pMga->AccelInfoRec->SubsequentScreenToScreenCopy =
+ MGANAME(SubsequentScreenToScreenCopy);
+
+ pMga->BltScanDirection = 0;
+ if(ydir == -1) pMga->BltScanDirection |= BLIT_UP;
+ if(xdir == -1)
+ pMga->BltScanDirection |= BLIT_LEFT;
+ else if(pMga->HasFBitBlt && (rop == GXcopy) && !pMga->DrawTransparent)
+ pMga->AccelInfoRec->SubsequentScreenToScreenCopy =
+ MGANAME(SubsequentScreenToScreenCopy_FastBlit);
+
+ if(pMga->DrawTransparent) {
+ dwgctl |= MGADWG_TRANSC;
+ WAITFIFO(2);
+ SET_FOREGROUND(trans);
+ trans = ~0;
+ SET_BACKGROUND(trans);
+ }
+
+ WAITFIFO(4);
+ OUTREG(MGAREG_DWGCTL, dwgctl);
+ OUTREG(MGAREG_SGN, pMga->BltScanDirection);
+ SET_PLANEMASK(planemask);
+ OUTREG(MGAREG_AR5, ydir * pMga->CurrentLayout.displayWidth);
+}
+
+
+static void
+MGANAME(SubsequentScreenToScreenCopy)(
+ ScrnInfoPtr pScrn,
+ int srcX, int srcY, int dstX, int dstY, int w, int h
+){
+ int start, end, SrcOrg = 0, DstOrg = 0;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if (pMga->AccelFlags & LARGE_ADDRESSES) {
+ SrcOrg = ((srcY & ~1023) * pMga->CurrentLayout.displayWidth * PSZ) >> 9;
+ DstOrg = ((dstY & ~1023) * pMga->CurrentLayout.displayWidth * PSZ) >> 9;
+ dstY &= 1023;
+ }
+
+ if(pMga->BltScanDirection & BLIT_UP) {
+ srcY += h - 1;
+ dstY += h - 1;
+ }
+
+ w--;
+ start = end = XYADDRESS(srcX, srcY);
+
+ if(pMga->BltScanDirection & BLIT_LEFT) start += w;
+ else end += w;
+
+ if (pMga->AccelFlags & LARGE_ADDRESSES) {
+ WAITFIFO(7);
+ if(DstOrg)
+ OUTREG(MGAREG_DSTORG, (DstOrg << 6) + pMga->DstOrg);
+ if(SrcOrg != pMga->SrcOrg) {
+ pMga->SrcOrg = SrcOrg;
+ OUTREG(MGAREG_SRCORG, (SrcOrg << 6) + pMga->realSrcOrg);
+ }
+ if(SrcOrg) {
+ SrcOrg = (SrcOrg << 9) / PSZ;
+ end -= SrcOrg;
+ start -= SrcOrg;
+ }
+ OUTREG(MGAREG_AR0, end);
+ OUTREG(MGAREG_AR3, start);
+ OUTREG(MGAREG_FXBNDRY, ((dstX + w) << 16) | (dstX & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (dstY << 16) | h);
+ if(DstOrg)
+ OUTREG(MGAREG_DSTORG, pMga->DstOrg);
+ } else {
+ WAITFIFO(4);
+ OUTREG(MGAREG_AR0, end);
+ OUTREG(MGAREG_AR3, start);
+ OUTREG(MGAREG_FXBNDRY, ((dstX + w) << 16) | (dstX & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (dstY << 16) | h);
+ }
+}
+
+
+static void
+MGANAME(SubsequentScreenToScreenCopy_FastBlit)(
+ ScrnInfoPtr pScrn,
+ int srcX, int srcY, int dstX, int dstY, int w, int h
+)
+{
+ int start, end;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if(pMga->BltScanDirection & BLIT_UP) {
+ srcY += h - 1;
+ dstY += h - 1;
+ }
+
+ w--;
+ start = XYADDRESS(srcX, srcY);
+ end = start + w;
+
+ /* we assume the driver asserts screen pitches such that
+ we can always use fastblit for scrolling */
+ if(
+#if PSZ == 32
+ !((srcX ^ dstX) & 31)
+#elif PSZ == 16
+ !((srcX ^ dstX) & 63)
+#else
+ !((srcX ^ dstX) & 127)
+#endif
+ ) {
+ if(pMga->MaxFastBlitY) {
+ if(pMga->BltScanDirection & BLIT_UP) {
+ if((srcY >= pMga->MaxFastBlitY) ||
+ (dstY >= pMga->MaxFastBlitY))
+ goto FASTBLIT_BAILOUT;
+ } else {
+ if(((srcY + h) > pMga->MaxFastBlitY) ||
+ ((dstY + h) > pMga->MaxFastBlitY))
+ goto FASTBLIT_BAILOUT;
+ }
+ }
+
+ /* Millennium 1 fastblit bug fix */
+ if(pMga->AccelFlags & FASTBLT_BUG) {
+ int fxright = dstX + w;
+#if PSZ == 8
+ if((dstX & (1 << 6)) && (((fxright >> 6) - (dstX >> 6)) & 7) == 7) {
+ fxright |= 1 << 6;
+#elif PSZ == 16
+ if((dstX & (1 << 5)) && (((fxright >> 5) - (dstX >> 5)) & 7) == 7) {
+ fxright |= 1 << 5;
+#elif PSZ == 24
+ if(((dstX * 3) & (1 << 6)) &&
+ ((((fxright * 3 + 2) >> 6) - ((dstX * 3) >> 6)) & 7) == 7) {
+ fxright = ((fxright * 3 + 2) | (1 << 6)) / 3;
+#elif PSZ == 32
+ if((dstX & (1 << 4)) && (((fxright >> 4) - (dstX >> 4)) & 7) == 7) {
+ fxright |= 1 << 4;
+#endif
+ WAITFIFO(8);
+ OUTREG(MGAREG_CXRIGHT, dstX + w);
+ OUTREG(MGAREG_DWGCTL, 0x040A400C);
+ OUTREG(MGAREG_AR0, end);
+ OUTREG(MGAREG_AR3, start);
+ OUTREG(MGAREG_FXBNDRY, (fxright << 16) | (dstX & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (dstY << 16) | h);
+ OUTREG(MGAREG_DWGCTL, pMga->AtypeNoBLK[GXcopy] |
+ MGADWG_SHIFTZERO | MGADWG_BITBLT | MGADWG_BFCOL);
+ OUTREG(MGAREG_CXRIGHT, 0xFFFF);
+ return;
+ } /* } } } (preserve pairs for pair matching) */
+ }
+
+ WAITFIFO(6);
+ OUTREG(MGAREG_DWGCTL, 0x040A400C);
+ OUTREG(MGAREG_AR0, end);
+ OUTREG(MGAREG_AR3, start);
+ OUTREG(MGAREG_FXBNDRY, ((dstX + w) << 16) | (dstX & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (dstY << 16) | h);
+ OUTREG(MGAREG_DWGCTL, pMga->AtypeNoBLK[GXcopy] | MGADWG_SHIFTZERO |
+ MGADWG_BITBLT | MGADWG_BFCOL);
+ return;
+ }
+
+FASTBLIT_BAILOUT:
+
+ WAITFIFO(4);
+ OUTREG(MGAREG_AR0, end);
+ OUTREG(MGAREG_AR3, start);
+ OUTREG(MGAREG_FXBNDRY, ((dstX + w) << 16) | (dstX & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (dstY << 16) | h);
+}
+
+
+ /******************\
+ | Solid Fills |
+ \******************/
+
+void
+MGANAME(SetupForSolidFill)(
+ ScrnInfoPtr pScrn,
+ int color,
+ int rop,
+ unsigned int planemask )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+#if PSZ == 24
+ if(!RGBEQUAL(color))
+ pMga->FilledRectCMD = MGADWG_TRAP | MGADWG_SOLID | MGADWG_ARZERO |
+ MGADWG_SGNZERO | MGADWG_SHIFTZERO |
+ MGADWG_BMONOLEF | pMga->AtypeNoBLK[rop];
+ else
+#endif
+ pMga->FilledRectCMD = MGADWG_TRAP | MGADWG_SOLID | MGADWG_ARZERO |
+ MGADWG_SGNZERO | MGADWG_SHIFTZERO |
+ MGADWG_BMONOLEF | pMga->Atype[rop];
+
+ pMga->SolidLineCMD = MGADWG_SOLID | MGADWG_SHIFTZERO | MGADWG_BFCOL |
+ pMga->AtypeNoBLK[rop];
+
+ if(pMga->AccelFlags & TRANSC_SOLID_FILL)
+ pMga->FilledRectCMD |= MGADWG_TRANSC;
+
+ WAITFIFO(3);
+ SET_FOREGROUND(color);
+ SET_PLANEMASK(planemask);
+ OUTREG(MGAREG_DWGCTL, pMga->FilledRectCMD);
+}
+
+static void
+MGANAME(SubsequentSolidFillRect)(
+ ScrnInfoPtr pScrn,
+ int x, int y, int w, int h )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ WAITFIFO(2);
+ OUTREG(MGAREG_FXBNDRY, ((x + w) << 16) | (x & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | h);
+}
+
+static void
+MGANAME(SubsequentSolidFillTrap)(ScrnInfoPtr pScrn, int y, int h,
+ int left, int dxL, int dyL, int eL,
+ int right, int dxR, int dyR, int eR )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ int sdxl = (dxL < 0);
+ int ar2 = sdxl? dxL : -dxL;
+ int sdxr = (dxR < 0);
+ int ar5 = sdxr? dxR : -dxR;
+
+ WAITFIFO(11);
+ OUTREG(MGAREG_DWGCTL,
+ pMga->FilledRectCMD & ~(MGADWG_ARZERO | MGADWG_SGNZERO));
+ OUTREG(MGAREG_AR0, dyL);
+ OUTREG(MGAREG_AR1, ar2 - eL);
+ OUTREG(MGAREG_AR2, ar2);
+ OUTREG(MGAREG_AR4, ar5 - eR);
+ OUTREG(MGAREG_AR5, ar5);
+ OUTREG(MGAREG_AR6, dyR);
+ OUTREG(MGAREG_SGN, (sdxl << 1) | (sdxr << 5));
+ OUTREG(MGAREG_FXBNDRY, ((right + 1) << 16) | (left & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | h);
+ OUTREG(MGAREG_DWGCTL, pMga->FilledRectCMD);
+}
+
+ /***************\
+ | Solid Lines |
+ \***************/
+
+
+static void
+MGANAME(SubsequentSolidHorVertLine) (
+ ScrnInfoPtr pScrn,
+ int x, int y,
+ int len, int dir
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if(dir == DEGREES_0) {
+ WAITFIFO(2);
+ OUTREG(MGAREG_FXBNDRY, ((x + len) << 16) | (x & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | 1);
+ } else if(pMga->AccelFlags & USE_RECTS_FOR_LINES) {
+ WAITFIFO(2);
+ OUTREG(MGAREG_FXBNDRY, ((x + 1) << 16) | (x & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | len);
+ } else {
+ WAITFIFO(4);
+ OUTREG(MGAREG_DWGCTL, pMga->SolidLineCMD | MGADWG_AUTOLINE_OPEN);
+ OUTREG(MGAREG_XYSTRT, (y << 16) | (x & 0xffff));
+ OUTREG(MGAREG_XYEND + MGAREG_EXEC, ((y + len) << 16) | (x & 0xffff));
+ OUTREG(MGAREG_DWGCTL, pMga->FilledRectCMD);
+ }
+}
+
+
+static void
+MGANAME(SubsequentSolidTwoPointLine)(
+ ScrnInfoPtr pScrn,
+ int x1, int y1, int x2, int y2, int flags
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ WAITFIFO(4);
+ OUTREG(MGAREG_DWGCTL, pMga->SolidLineCMD |
+ ((flags & OMIT_LAST) ? MGADWG_AUTOLINE_OPEN : MGADWG_AUTOLINE_CLOSE));
+ OUTREG(MGAREG_XYSTRT, (y1 << 16) | (x1 & 0xFFFF));
+ OUTREG(MGAREG_XYEND + MGAREG_EXEC, (y2 << 16) | (x2 & 0xFFFF));
+ OUTREG(MGAREG_DWGCTL, pMga->FilledRectCMD);
+}
+
+
+
+ /***************************\
+ | 8x8 Mono Pattern Fills |
+ \***************************/
+
+
+static void
+MGANAME(SetupForMono8x8PatternFill)(
+ ScrnInfoPtr pScrn,
+ int patx, int paty,
+ int fg, int bg,
+ int rop,
+ unsigned int planemask )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ XAAInfoRecPtr infoRec = pMga->AccelInfoRec;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ pMga->PatternRectCMD = MGADWG_TRAP | MGADWG_ARZERO | MGADWG_SGNZERO |
+ MGADWG_BMONOLEF;
+
+ infoRec->SubsequentMono8x8PatternFillRect =
+ MGANAME(SubsequentMono8x8PatternFillRect);
+
+ if(bg == -1) {
+#if PSZ == 24
+ if(!RGBEQUAL(fg))
+ pMga->PatternRectCMD |= MGADWG_TRANSC | pMga->AtypeNoBLK[rop];
+ else
+#endif
+ pMga->PatternRectCMD |= MGADWG_TRANSC | pMga->Atype[rop];
+
+ WAITFIFO(5);
+ } else {
+#if PSZ == 24
+ if((pMga->AccelFlags & BLK_OPAQUE_EXPANSION) && RGBEQUAL(fg) && RGBEQUAL(bg))
+#else
+ if(pMga->AccelFlags & BLK_OPAQUE_EXPANSION)
+#endif
+ pMga->PatternRectCMD |= pMga->Atype[rop];
+ else
+ pMga->PatternRectCMD |= pMga->AtypeNoBLK[rop];
+ WAITFIFO(6);
+ SET_BACKGROUND(bg);
+ }
+
+ SET_FOREGROUND(fg);
+ SET_PLANEMASK(planemask);
+ OUTREG(MGAREG_DWGCTL, pMga->PatternRectCMD);
+ OUTREG(MGAREG_PAT0, patx);
+ OUTREG(MGAREG_PAT1, paty);
+}
+
+
+
+static void
+MGANAME(SubsequentMono8x8PatternFillRect)(
+ ScrnInfoPtr pScrn,
+ int patx, int paty,
+ int x, int y, int w, int h )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ WAITFIFO(3);
+ OUTREG(MGAREG_SHIFT, (paty << 4) | patx);
+ OUTREG(MGAREG_FXBNDRY, ((x + w) << 16) | (x & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | h);
+ pMga->AccelInfoRec->SubsequentMono8x8PatternFillRect =
+ MGANAME(SubsequentMono8x8PatternFillRect_Additional);
+}
+
+static void
+MGANAME(SubsequentMono8x8PatternFillRect_Additional)(
+ ScrnInfoPtr pScrn,
+ int patx, int paty,
+ int x, int y, int w, int h )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ WAITFIFO(2);
+ OUTREG(MGAREG_FXBNDRY, ((x + w) << 16) | (x & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | h);
+}
+
+
+static void
+MGANAME(SubsequentMono8x8PatternFillTrap)(
+ ScrnInfoPtr pScrn,
+ int patx, int paty,
+ int y, int h,
+ int left, int dxL, int dyL, int eL,
+ int right, int dxR, int dyR, int eR
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ int sdxl = (dxL < 0) ? (1<<1) : 0;
+ int ar2 = sdxl? dxL : -dxL;
+ int sdxr = (dxR < 0) ? (1<<5) : 0;
+ int ar5 = sdxr? dxR : -dxR;
+
+ WAITFIFO(12);
+ OUTREG(MGAREG_SHIFT, (paty << 4) | patx);
+ OUTREG(MGAREG_DWGCTL,
+ pMga->PatternRectCMD & ~(MGADWG_ARZERO | MGADWG_SGNZERO));
+ OUTREG(MGAREG_AR0, dyL);
+ OUTREG(MGAREG_AR1, ar2 - eL);
+ OUTREG(MGAREG_AR2, ar2);
+ OUTREG(MGAREG_AR4, ar5 - eR);
+ OUTREG(MGAREG_AR5, ar5);
+ OUTREG(MGAREG_AR6, dyR);
+ OUTREG(MGAREG_SGN, sdxl | sdxr);
+ OUTREG(MGAREG_FXBNDRY, ((right + 1) << 16) | (left & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | h);
+ OUTREG(MGAREG_DWGCTL, pMga->PatternRectCMD);
+}
+
+ /***********************\
+ | Color Expand Rect |
+ \***********************/
+
+
+static void
+MGANAME(SetupForScanlineCPUToScreenColorExpandFill)(
+ ScrnInfoPtr pScrn,
+ int fg, int bg,
+ int rop,
+ unsigned int planemask )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ CARD32 mgaCMD = MGADWG_ILOAD | MGADWG_LINEAR | MGADWG_SGNZERO |
+ MGADWG_SHIFTZERO | MGADWG_BMONOLEF;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ if(bg == -1) {
+#if PSZ == 24
+ if(!RGBEQUAL(fg))
+ mgaCMD |= MGADWG_TRANSC | pMga->AtypeNoBLK[rop];
+ else
+#endif
+ mgaCMD |= MGADWG_TRANSC | pMga->Atype[rop];
+
+ WAITFIFO(3);
+ } else {
+#if PSZ == 24
+ if((pMga->AccelFlags & BLK_OPAQUE_EXPANSION) &&
+ RGBEQUAL(fg) && RGBEQUAL(bg))
+#else
+ if(pMga->AccelFlags & BLK_OPAQUE_EXPANSION)
+#endif
+ mgaCMD |= pMga->Atype[rop];
+ else
+ mgaCMD |= pMga->AtypeNoBLK[rop];
+ WAITFIFO(4);
+ SET_BACKGROUND(bg);
+ }
+
+ SET_FOREGROUND(fg);
+ SET_PLANEMASK(planemask);
+ OUTREG(MGAREG_DWGCTL, mgaCMD);
+}
+
+static void
+MGANAME(SubsequentScanlineCPUToScreenColorExpandFill)(
+ ScrnInfoPtr pScrn,
+ int x, int y, int w, int h,
+ int skipleft
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ pMga->AccelFlags |= CLIPPER_ON;
+ pMga->expandDWORDs = (w + 31) >> 5;
+ if((pMga->expandDWORDs * h) > pMga->MaxBlitDWORDS) {
+ pMga->expandHeight = pMga->MaxBlitDWORDS / pMga->expandDWORDs;
+ pMga->expandRemaining = h / pMga->expandHeight;
+ if(!(h = h % pMga->expandHeight)) {
+ pMga->expandRemaining--;
+ h = pMga->expandHeight;
+ }
+ pMga->expandY = y + h;
+ } else
+ pMga->expandRemaining = 0;
+ pMga->expandRows = h;
+
+ WAITFIFO(5);
+ OUTREG(MGAREG_CXBNDRY, ((x + w - 1) << 16) | ((x + skipleft) & 0xFFFF));
+ w = pMga->expandDWORDs << 5; /* source is dword padded */
+ OUTREG(MGAREG_AR0, (w * h) - 1);
+ OUTREG(MGAREG_AR3, 0); /* crashes occasionally without this */
+ OUTREG(MGAREG_FXBNDRY, ((x + w - 1) << 16) | (x & 0xFFFF));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | h);
+
+#if defined(__alpha__)
+ if(1) /* force indirect always on Alpha */
+#else
+ if(pMga->expandDWORDs > pMga->FifoSize)
+#endif
+ {
+ pMga->AccelInfoRec->SubsequentColorExpandScanline =
+ MGANAME(SubsequentColorExpandScanlineIndirect);
+ pMga->AccelInfoRec->ScanlineColorExpandBuffers =
+ (unsigned char**)(&pMga->ScratchBuffer);
+ } else {
+ pMga->AccelInfoRec->SubsequentColorExpandScanline =
+ MGANAME(SubsequentColorExpandScanline);
+ pMga->AccelInfoRec->ScanlineColorExpandBuffers =
+ (unsigned char**)(&pMga->ColorExpandBase);
+ WAITFIFO(pMga->expandDWORDs);
+ }
+}
+
+static void
+MGANAME(SubsequentColorExpandScanlineIndirect)(
+ ScrnInfoPtr pScrn,
+ int bufno
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ int dwords = pMga->expandDWORDs;
+ CARD32 *src = (CARD32*)(pMga->ScratchBuffer);
+
+ while(dwords > pMga->FifoSize) {
+ WAITFIFO(pMga->FifoSize);
+ MGAMoveDWORDS((CARD32*)(pMga->ColorExpandBase), src, pMga->FifoSize);
+ src += pMga->FifoSize;
+ dwords -= pMga->FifoSize;
+ }
+
+ WAITFIFO(dwords);
+ MGAMoveDWORDS((CARD32*)(pMga->ColorExpandBase), src, dwords);
+
+ if(!(--pMga->expandRows)) {
+ if(pMga->expandRemaining) {
+ WAITFIFO(3);
+ OUTREG(MGAREG_AR0,((pMga->expandDWORDs<< 5)*pMga->expandHeight)-1);
+ OUTREG(MGAREG_AR3, 0); /* crashes occasionally without this */
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (pMga->expandY << 16) |
+ pMga->expandHeight);
+ pMga->expandY += pMga->expandHeight;
+ pMga->expandRows = pMga->expandHeight;
+ pMga->expandRemaining--;
+ } else {
+ DISABLE_CLIP();
+ }
+ }
+}
+
+static void
+MGANAME(SubsequentColorExpandScanline)(
+ ScrnInfoPtr pScrn,
+ int bufno
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ if(--pMga->expandRows) {
+ WAITFIFO(pMga->expandDWORDs);
+ } else if(pMga->expandRemaining) {
+ WAITFIFO(3);
+ OUTREG(MGAREG_AR0,((pMga->expandDWORDs<<5)*pMga->expandHeight)-1);
+ OUTREG(MGAREG_AR3, 0); /* crashes occasionally without this */
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (pMga->expandY << 16) |
+ pMga->expandHeight);
+ pMga->expandY += pMga->expandHeight;
+ pMga->expandRows = pMga->expandHeight;
+ pMga->expandRemaining--;
+ WAITFIFO(pMga->expandDWORDs);
+ } else {
+ DISABLE_CLIP();
+ }
+}
+
+
+ /*******************\
+ | Image Writes |
+ \*******************/
+
+
+static void MGANAME(SetupForScanlineImageWrite)(
+ ScrnInfoPtr pScrn,
+ int rop,
+ unsigned int planemask,
+ int transparency_color,
+ int bpp, int depth
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ WAITFIFO(3);
+ OUTREG(MGAREG_AR5, 0);
+ SET_PLANEMASK(planemask);
+ OUTREG(MGAREG_DWGCTL, MGADWG_ILOAD | MGADWG_BFCOL | MGADWG_SHIFTZERO |
+ MGADWG_SGNZERO | pMga->AtypeNoBLK[rop]);
+}
+
+
+static void MGANAME(SubsequentScanlineImageWriteRect)(
+ ScrnInfoPtr pScrn,
+ int x, int y, int w, int h,
+ int skipleft
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ pMga->AccelFlags |= CLIPPER_ON;
+ pMga->expandRows = h;
+ pMga->expandDWORDs = ((w * PSZ) + 31) >> 5;
+
+ WAITFIFO(5);
+ OUTREG(MGAREG_CXBNDRY, 0xFFFF0000 | ((x + skipleft) & 0xFFFF));
+ OUTREG(MGAREG_AR0, w - 1);
+ OUTREG(MGAREG_AR3, 0);
+ OUTREG(MGAREG_FXBNDRY, ((x + w - 1) << 16) | (x & 0xFFFF));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | h);
+}
+
+static void MGANAME(SubsequentImageWriteScanline)(
+ ScrnInfoPtr pScrn,
+ int bufno
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ int dwords = pMga->expandDWORDs;
+ CARD32 *src = (CARD32*)(pMga->ScratchBuffer);
+
+ while(dwords > pMga->FifoSize) {
+ WAITFIFO(pMga->FifoSize);
+ MGAMoveDWORDS((CARD32*)(pMga->ColorExpandBase), src, pMga->FifoSize);
+ src += pMga->FifoSize;
+ dwords -= pMga->FifoSize;
+ }
+
+ WAITFIFO(dwords);
+ MGAMoveDWORDS((CARD32*)(pMga->ColorExpandBase), src, dwords);
+
+ if(!(--pMga->expandRows)) {
+ DISABLE_CLIP();
+ }
+}
+
+#if X_BYTE_ORDER == X_LITTLE_ENDIAN
+
+ /***************************\
+ | Dashed Lines |
+ \***************************/
+
+
+void
+MGANAME(SetupForDashedLine)(
+ ScrnInfoPtr pScrn,
+ int fg, int bg, int rop,
+ unsigned int planemask,
+ int length,
+ unsigned char *pattern
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ CARD32 *DashPattern = (CARD32*)pattern;
+ CARD32 NiceDashPattern = DashPattern[0];
+ int dwords = (length + 31) >> 5;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ pMga->DashCMD = MGADWG_BFCOL | pMga->AtypeNoBLK[rop];
+ pMga->StyleLen = length - 1;
+
+ if(bg == -1) {
+ pMga->DashCMD |= MGADWG_TRANSC;
+ WAITFIFO(dwords + 2);
+ } else {
+ WAITFIFO(dwords + 3);
+ SET_BACKGROUND(bg);
+ }
+ SET_PLANEMASK(planemask);
+ SET_FOREGROUND(fg);
+
+ /* We see if we can draw horizontal lines as 8x8 pattern fills.
+ This is worthwhile since the pattern fills can use block mode
+ and the default X pattern is 8 pixels long. The forward pattern
+ is the top scanline, the backwards pattern is the next one. */
+ switch(length) {
+ case 2: NiceDashPattern |= NiceDashPattern << 2;
+ case 4: NiceDashPattern |= NiceDashPattern << 4;
+ case 8: NiceDashPattern |= byte_reversed[NiceDashPattern] << 16;
+ NiceDashPattern |= NiceDashPattern << 8;
+ pMga->NiceDashCMD = MGADWG_TRAP | MGADWG_ARZERO |
+ MGADWG_SGNZERO | MGADWG_BMONOLEF;
+ pMga->AccelFlags |= NICE_DASH_PATTERN;
+ if(bg == -1) {
+#if PSZ == 24
+ if(!RGBEQUAL(fg))
+ pMga->NiceDashCMD |= MGADWG_TRANSC | pMga->AtypeNoBLK[rop];
+ else
+#endif
+ pMga->NiceDashCMD |= MGADWG_TRANSC | pMga->Atype[rop];
+ } else {
+#if PSZ == 24
+ if((pMga->AccelFlags & BLK_OPAQUE_EXPANSION) &&
+ RGBEQUAL(fg) && RGBEQUAL(bg))
+#else
+ if(pMga->AccelFlags & BLK_OPAQUE_EXPANSION)
+#endif
+ pMga->NiceDashCMD |= pMga->Atype[rop];
+ else
+ pMga->NiceDashCMD |= pMga->AtypeNoBLK[rop];
+ }
+ OUTREG(MGAREG_SRC0, NiceDashPattern);
+ break;
+ default: pMga->AccelFlags &= ~NICE_DASH_PATTERN;
+ switch (dwords) {
+ case 4: OUTREG(MGAREG_SRC3, DashPattern[3]);
+ case 3: OUTREG(MGAREG_SRC2, DashPattern[2]);
+ case 2: OUTREG(MGAREG_SRC1, DashPattern[1]);
+ default: OUTREG(MGAREG_SRC0, DashPattern[0]);
+ }
+ }
+}
+
+
+void
+MGANAME(SubsequentDashedTwoPointLine)(
+ ScrnInfoPtr pScrn,
+ int x1, int y1, int x2, int y2,
+ int flags, int phase
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ WAITFIFO(4);
+ if((pMga->AccelFlags & NICE_DASH_PATTERN) && (y1 == y2)) {
+ OUTREG(MGAREG_DWGCTL, pMga->NiceDashCMD);
+ if(x2 < x1) {
+ if(flags & OMIT_LAST) x2++;
+ OUTREG(MGAREG_SHIFT, ((-y1 & 0x07) << 4) |
+ ((7 - phase - x1) & 0x07));
+ OUTREG(MGAREG_FXBNDRY, ((x1 + 1) << 16) | (x2 & 0xffff));
+ } else {
+ if(!flags) x2++;
+ OUTREG(MGAREG_SHIFT, (((1 - y1) & 0x07) << 4) |
+ ((phase - x1) & 0x07));
+ OUTREG(MGAREG_FXBNDRY, (x2 << 16) | (x1 & 0xffff));
+ }
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y1 << 16) | 1);
+ } else {
+ OUTREG(MGAREG_SHIFT, (pMga->StyleLen << 16 ) |
+ (pMga->StyleLen - phase));
+ OUTREG(MGAREG_DWGCTL, pMga->DashCMD | ((flags & OMIT_LAST) ?
+ MGADWG_AUTOLINE_OPEN : MGADWG_AUTOLINE_CLOSE));
+ OUTREG(MGAREG_XYSTRT, (y1 << 16) | (x1 & 0xFFFF));
+ OUTREG(MGAREG_XYEND + MGAREG_EXEC, (y2 << 16) | (x2 & 0xFFFF));
+ }
+}
+
+#endif /* X_BYTE_ORDER == X_LITTLE_ENDIAN */
+
+#if PSZ != 24
+
+ /******************************************\
+ | Planar Screen to Screen Color Expansion |
+ \******************************************/
+
+static void
+MGANAME(SetupForPlanarScreenToScreenColorExpandFill)(
+ ScrnInfoPtr pScrn,
+ int fg, int bg,
+ int rop,
+ unsigned int planemask
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ CARD32 mgaCMD = pMga->AtypeNoBLK[rop] | MGADWG_BITBLT |
+ MGADWG_SGNZERO | MGADWG_BPLAN;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ if(bg == -1) {
+ mgaCMD |= MGADWG_TRANSC;
+ WAITFIFO(4);
+ } else {
+ WAITFIFO(5);
+ SET_BACKGROUND(bg);
+ }
+
+ SET_FOREGROUND(fg);
+ SET_PLANEMASK(planemask);
+ OUTREG(MGAREG_AR5, pScrn->displayWidth);
+ OUTREG(MGAREG_DWGCTL, mgaCMD);
+}
+
+static void
+MGANAME(SubsequentPlanarScreenToScreenColorExpandFill)(
+ ScrnInfoPtr pScrn,
+ int x, int y, int w, int h,
+ int srcx, int srcy,
+ int skipleft
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ int start, end;
+
+ w--;
+ start = XYADDRESS(srcx, srcy) + skipleft;
+ end = start + w;
+
+ WAITFIFO(4);
+ OUTREG(MGAREG_AR3, start);
+ OUTREG(MGAREG_AR0, end);
+ OUTREG(MGAREG_FXBNDRY, ((x + w) << 16) | (x & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | h);
+}
+
+#endif
+
+ /***********************************\
+ | Screen to Screen Color Expansion |
+ \***********************************/
+
+static void
+MGANAME(SetupForScreenToScreenColorExpandFill)(
+ ScrnInfoPtr pScrn,
+ int fg, int bg,
+ int rop,
+ unsigned int planemask
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ CARD32 mgaCMD = MGADWG_BITBLT | MGADWG_SGNZERO | MGADWG_SHIFTZERO;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ if(bg == -1) {
+#if PSZ == 24
+ if(!RGBEQUAL(fg))
+ mgaCMD |= MGADWG_TRANSC | pMga->AtypeNoBLK[rop];
+ else
+#endif
+ mgaCMD |= MGADWG_TRANSC | pMga->Atype[rop];
+
+ WAITFIFO(4);
+ } else {
+#if PSZ == 24
+ if((pMga->AccelFlags & BLK_OPAQUE_EXPANSION) &&
+ RGBEQUAL(fg) && RGBEQUAL(bg))
+#else
+ if((pMga->AccelFlags & BLK_OPAQUE_EXPANSION))
+#endif
+ mgaCMD |= pMga->Atype[rop];
+ else
+ mgaCMD |= pMga->AtypeNoBLK[rop];
+ WAITFIFO(5);
+ SET_BACKGROUND(bg);
+ }
+
+ SET_FOREGROUND(fg);
+ SET_PLANEMASK(planemask);
+ OUTREG(MGAREG_AR5, pScrn->displayWidth * PSZ);
+ OUTREG(MGAREG_DWGCTL, mgaCMD);
+
+}
+
+static void
+MGANAME(SubsequentScreenToScreenColorExpandFill)(
+ ScrnInfoPtr pScrn,
+ int x, int y, int w, int h,
+ int srcx, int srcy,
+ int skipleft
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ int pitch = pScrn->displayWidth * PSZ;
+ int start, end, next, num;
+ Bool resetDstOrg = FALSE;
+
+ if (pMga->AccelFlags & LARGE_ADDRESSES) {
+ int DstOrg = ((y & ~1023) * pScrn->displayWidth * PSZ) >> 9;
+ int SrcOrg = ((srcy & ~1023) * pScrn->displayWidth * PSZ) >> 9;
+
+ y &= 1023;
+ srcy &= 1023;
+
+ WAITFIFO(2);
+ if(DstOrg) {
+ OUTREG(MGAREG_DSTORG, (DstOrg << 6) + pMga->DstOrg);
+ resetDstOrg = TRUE;
+ }
+ if(SrcOrg != pMga->SrcOrg) {
+ pMga->SrcOrg = SrcOrg;
+ OUTREG(MGAREG_SRCORG, (SrcOrg << 6) + pMga->realSrcOrg);
+ }
+ }
+
+ w--;
+ start = (XYADDRESS(srcx, srcy) * PSZ) + skipleft;
+ end = start + w + (pitch * (h - 1));
+
+ /* src cannot split a 2 Meg boundary from SrcOrg */
+ if(!((start ^ end) & 0xff000000)) {
+ WAITFIFO(4);
+ OUTREG(MGAREG_AR3, start);
+ OUTREG(MGAREG_AR0, start + w);
+ OUTREG(MGAREG_FXBNDRY, ((x + w) << 16) | (x & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | h);
+ } else {
+ while(h) {
+ next = (start + 0x00ffffff) & 0xff000000;
+ if(next <= (start + w)) {
+ num = next - start - 1;
+
+ WAITFIFO(7);
+ OUTREG(MGAREG_AR3, start);
+ OUTREG(MGAREG_AR0, start + num);
+ OUTREG(MGAREG_FXBNDRY, ((x + num) << 16) | (x & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | 1);
+
+ OUTREG(MGAREG_AR3, next);
+ OUTREG(MGAREG_AR0, start + w );
+ OUTREG(MGAREG_FXBNDRY + MGAREG_EXEC, ((x + w) << 16) |
+ ((x + num + 1) & 0xffff));
+ start += pitch;
+ h--; y++;
+ } else {
+ num = ((next - start - w)/pitch) + 1;
+ if(num > h) num = h;
+
+ WAITFIFO(4);
+ OUTREG(MGAREG_AR3, start);
+ OUTREG(MGAREG_AR0, start + w);
+ OUTREG(MGAREG_FXBNDRY, ((x + w) << 16) | (x & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (y << 16) | num);
+
+ start += num * pitch;
+ h -= num; y += num;
+ }
+ }
+ }
+
+ if(resetDstOrg) {
+ WAITFIFO(1);
+ OUTREG(MGAREG_DSTORG, pMga->DstOrg);
+ }
+}
+
+
+
+#if PSZ == 8
+
+void
+MGAFillSolidRectsDMA(
+ ScrnInfoPtr pScrn,
+ int fg, int rop,
+ unsigned int planemask,
+ int nBox, /* number of rectangles to fill */
+ BoxPtr pBox /* Pointer to first rectangle to fill */
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ XAAInfoRecPtr infoRec = pMga->AccelInfoRec;
+ CARD32 *base = (CARD32*)pMga->ILOADBase;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ SET_SYNC_FLAG(infoRec);
+ (*infoRec->SetupForSolidFill)(pScrn, fg, rop, planemask);
+
+ if(nBox & 1) {
+ OUTREG(MGAREG_FXBNDRY, ((pBox->x2) << 16) | (pBox->x1 & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC,
+ (pBox->y1 << 16) | (pBox->y2 - pBox->y1));
+ nBox--; pBox++;
+ }
+
+ if(!nBox) return;
+
+ OUTREG(MGAREG_OPMODE, MGAOPM_DMA_GENERAL);
+ while(nBox) {
+ base[0] = DMAINDICES(MGAREG_FXBNDRY, MGAREG_YDSTLEN + MGAREG_EXEC,
+ MGAREG_FXBNDRY, MGAREG_YDSTLEN + MGAREG_EXEC);
+ base[1] = ((pBox->x2) << 16) | (pBox->x1 & 0xffff);
+ base[2] = (pBox->y1 << 16) | (pBox->y2 - pBox->y1);
+ pBox++;
+ base[3] = ((pBox->x2) << 16) | (pBox->x1 & 0xffff);
+ base[4] = (pBox->y1 << 16) | (pBox->y2 - pBox->y1);
+ pBox++;
+ base += 5; nBox -= 2;
+ }
+ OUTREG(MGAREG_OPMODE, MGAOPM_DMA_BLIT);
+}
+
+void
+MGAFillSolidSpansDMA(
+ ScrnInfoPtr pScrn,
+ int fg, int rop,
+ unsigned int planemask,
+ int n,
+ DDXPointPtr ppt,
+ int *pwidth, int fSorted
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ XAAInfoRecPtr infoRec = pMga->AccelInfoRec;
+ CARD32 *base = (CARD32*)pMga->ILOADBase;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+ SET_SYNC_FLAG(infoRec);
+
+ if(infoRec->ClipBox) {
+ OUTREG(MGAREG_CXBNDRY,
+ ((infoRec->ClipBox->x2 - 1) << 16) | infoRec->ClipBox->x1);
+ OUTREG(MGAREG_YTOP,
+ (infoRec->ClipBox->y1 * pScrn->displayWidth) + pMga->YDstOrg);
+ OUTREG(MGAREG_YBOT,
+ ((infoRec->ClipBox->y2 - 1) * pScrn->displayWidth) + pMga->YDstOrg);
+ }
+
+ (*infoRec->SetupForSolidFill)(pScrn, fg, rop, planemask);
+
+ if(n & 1) {
+ OUTREG(MGAREG_FXBNDRY, ((ppt->x + *pwidth) << 16) | (ppt->x & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (ppt->y << 16) | 1);
+ ppt++; pwidth++; n--;
+ }
+
+ if(n) {
+ if(n > 838860) n = 838860; /* maximum number we have room for */
+
+ OUTREG(MGAREG_OPMODE, MGAOPM_DMA_GENERAL);
+ while(n) {
+ base[0] = DMAINDICES(MGAREG_FXBNDRY, MGAREG_YDSTLEN + MGAREG_EXEC,
+ MGAREG_FXBNDRY, MGAREG_YDSTLEN + MGAREG_EXEC);
+ base[1] = ((ppt->x + *(pwidth++)) << 16) | (ppt->x & 0xffff);
+ base[2] = (ppt->y << 16) | 1;
+ ppt++;
+ base[3] = ((ppt->x + *(pwidth++)) << 16) | (ppt->x & 0xffff);
+ base[4] = (ppt->y << 16) | 1;
+ ppt++;
+ base += 5; n -= 2;
+ }
+ OUTREG(MGAREG_OPMODE, MGAOPM_DMA_BLIT);
+ }
+
+ if(infoRec->ClipBox) {
+ OUTREG(MGAREG_CXBNDRY, 0xFFFF0000); /* (maxX << 16) | minX */
+ OUTREG(MGAREG_YTOP, 0x00000000); /* minPixelPointer */
+ OUTREG(MGAREG_YBOT, 0x007FFFFF); /* maxPixelPointer */
+ }
+}
+
+
+void
+MGAFillMono8x8PatternRectsTwoPass(
+ ScrnInfoPtr pScrn,
+ int fg, int bg, int rop,
+ unsigned int planemask,
+ int nBoxInit,
+ BoxPtr pBoxInit,
+ int pattern0, int pattern1,
+ int xorg, int yorg
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ XAAInfoRecPtr infoRec = pMga->AccelInfoRec;
+ int nBox, SecondPassColor;
+ BoxPtr pBox;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ if((rop == GXcopy) && (bg != -1)) {
+ SecondPassColor = bg;
+ bg = -1;
+ } else SecondPassColor = -1;
+
+ WAITFIFO(1);
+ OUTREG(MGAREG_SHIFT, (((-yorg) & 0x07) << 4) | ((-xorg) & 0x07));
+
+SECOND_PASS:
+
+ nBox = nBoxInit;
+ pBox = pBoxInit;
+
+ (*infoRec->SetupForMono8x8PatternFill)(pScrn, pattern0, pattern1,
+ fg, bg, rop, planemask);
+
+ while(nBox--) {
+ WAITFIFO(2);
+ OUTREG(MGAREG_FXBNDRY, ((pBox->x2) << 16) | (pBox->x1 & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC,
+ (pBox->y1 << 16) | (pBox->y2 - pBox->y1));
+ pBox++;
+ }
+
+ if(SecondPassColor != -1) {
+ fg = SecondPassColor;
+ SecondPassColor = -1;
+ pattern0 = ~pattern0;
+ pattern1 = ~pattern1;
+ goto SECOND_PASS;
+ }
+
+ SET_SYNC_FLAG(infoRec);
+}
+
+
+void
+MGAValidatePolyArc(
+ GCPtr pGC,
+ unsigned long changes,
+ DrawablePtr pDraw
+){
+ ScrnInfoPtr pScrn = xf86Screens[pGC->pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ Bool fullPlanemask = TRUE;
+
+ if((pGC->planemask & pMga->AccelInfoRec->FullPlanemask) !=
+ pMga->AccelInfoRec->FullPlanemask)
+ {
+ if(pMga->AccelFlags & MGA_NO_PLANEMASK) return;
+ fullPlanemask = FALSE;
+ }
+
+ if(!pGC->lineWidth &&
+ (pGC->fillStyle == FillSolid) &&
+ (pGC->lineStyle == LineSolid) &&
+ ((pGC->alu != GXcopy) || !fullPlanemask))
+ {
+ pGC->ops->PolyArc = MGAPolyArcThinSolid;
+ }
+}
+
+static void
+MGAPolyPoint (
+ DrawablePtr pDraw,
+ GCPtr pGC,
+ int mode,
+ int npt,
+ xPoint *ppt
+){
+ int numRects = REGION_NUM_RECTS(pGC->pCompositeClip);
+ XAAInfoRecPtr infoRec;
+ BoxPtr pbox;
+ MGAPtr pMga;
+ int xorg, yorg;
+
+ if(!numRects) return;
+
+ if(numRects != 1) {
+ XAAFallbackOps.PolyPoint(pDraw, pGC, mode, npt, ppt);
+ return;
+ }
+
+ infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+ pMga = MGAPTR(infoRec->pScrn);
+ xorg = pDraw->x;
+ yorg = pDraw->y;
+
+ pbox = REGION_RECTS(pGC->pCompositeClip);
+
+ (*infoRec->SetClippingRectangle)(infoRec->pScrn,
+ pbox->x1, pbox->y1, pbox->x2 - 1, pbox->y2 - 1);
+ (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,
+ pGC->planemask);
+
+ if(mode == CoordModePrevious) {
+ while(npt--) {
+ xorg += ppt->x;
+ yorg += ppt->y;
+ WAITFIFO(2);
+ OUTREG(MGAREG_FXBNDRY, ((xorg + 1) << 16) | (xorg & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, (yorg << 16) | 1);
+ ppt++;
+ }
+ } else {
+ int x;
+ while(npt--) {
+ x = ppt->x + xorg;
+ WAITFIFO(2);
+ OUTREG(MGAREG_FXBNDRY, ((x + 1) << 16) | (x & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC, ((ppt->y + yorg) << 16) | 1);
+ ppt++;
+ }
+ }
+
+ (*infoRec->DisableClipping)(infoRec->pScrn);
+
+ SET_SYNC_FLAG(infoRec);
+}
+
+
+void
+MGAValidatePolyPoint(
+ GCPtr pGC,
+ unsigned long changes,
+ DrawablePtr pDraw
+){
+ ScrnInfoPtr pScrn = xf86Screens[pGC->pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ Bool fullPlanemask = TRUE;
+
+ pGC->ops->PolyPoint = XAAFallbackOps.PolyPoint;
+
+ if((pGC->planemask & pMga->AccelInfoRec->FullPlanemask) !=
+ pMga->AccelInfoRec->FullPlanemask)
+ {
+ if(pMga->AccelFlags & MGA_NO_PLANEMASK) return;
+ fullPlanemask = FALSE;
+ }
+
+ if((pGC->alu != GXcopy) || !fullPlanemask)
+ pGC->ops->PolyPoint = MGAPolyPoint;
+}
+
+
+void
+MGAFillCacheBltRects(
+ ScrnInfoPtr pScrn,
+ int rop,
+ unsigned int planemask,
+ int nBox,
+ BoxPtr pBox,
+ int xorg, int yorg,
+ XAACacheInfoPtr pCache
+){
+ XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+ int x, y, phaseY, phaseX, skipleft, height, width, w, blit_w, blit_h, start;
+
+ CHECK_DMA_QUIESCENT(MGAPTR(pScrn), pScrn);
+
+ (*infoRec->SetupForScreenToScreenCopy)(pScrn, 1, 1, rop, planemask,
+ pCache->trans_color);
+
+ while(nBox--) {
+ y = pBox->y1;
+ phaseY = (y - yorg) % pCache->orig_h;
+ if(phaseY < 0) phaseY += pCache->orig_h;
+ phaseX = (pBox->x1 - xorg) % pCache->orig_w;
+ if(phaseX < 0) phaseX += pCache->orig_w;
+ height = pBox->y2 - y;
+ width = pBox->x2 - pBox->x1;
+ start = phaseY ? (pCache->orig_h - phaseY) : 0;
+
+ /* This is optimized for WRAM */
+
+ if ((rop == GXcopy) && (height >= (pCache->orig_h + start))) {
+ w = width; skipleft = phaseX; x = pBox->x1;
+ blit_h = pCache->orig_h;
+
+ while(1) {
+ blit_w = pCache->w - skipleft;
+ if(blit_w > w) blit_w = w;
+ (*infoRec->SubsequentScreenToScreenCopy)(pScrn,
+ pCache->x + skipleft, pCache->y,
+ x, y + start, blit_w, blit_h);
+ w -= blit_w;
+ if(!w) break;
+ x += blit_w;
+ skipleft = (skipleft + blit_w) % pCache->orig_w;
+ }
+ height -= blit_h;
+
+ if(start) {
+ (*infoRec->SubsequentScreenToScreenCopy)(pScrn,
+ pBox->x1, y + blit_h, pBox->x1, y, width, start);
+ height -= start;
+ y += start;
+ }
+ start = blit_h;
+
+ while(height) {
+ if(blit_h > height) blit_h = height;
+ (*infoRec->SubsequentScreenToScreenCopy)(pScrn,
+ pBox->x1, y,
+ pBox->x1, y + start, width, blit_h);
+ height -= blit_h;
+ start += blit_h;
+ blit_h <<= 1;
+ }
+ } else {
+ while(1) {
+ w = width; skipleft = phaseX; x = pBox->x1;
+ blit_h = pCache->h - phaseY;
+ if(blit_h > height) blit_h = height;
+
+ while(1) {
+ blit_w = pCache->w - skipleft;
+ if(blit_w > w) blit_w = w;
+ (*infoRec->SubsequentScreenToScreenCopy)(pScrn,
+ pCache->x + skipleft, pCache->y + phaseY,
+ x, y, blit_w, blit_h);
+ w -= blit_w;
+ if(!w) break;
+ x += blit_w;
+ skipleft = (skipleft + blit_w) % pCache->orig_w;
+ }
+ height -= blit_h;
+ if(!height) break;
+ y += blit_h;
+ phaseY = (phaseY + blit_h) % pCache->orig_h;
+ }
+ }
+ pBox++;
+ }
+
+ SET_SYNC_FLAG(infoRec);
+}
+
+#endif
+
+#ifdef XF86DRI
+void
+MGANAME(DRIInitBuffers)(WindowPtr pWin, RegionPtr prgn, CARD32 index)
+{
+ ScreenPtr pScreen = pWin->drawable.pScreen;
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ BoxPtr pbox = REGION_RECTS(prgn);
+ int nbox = REGION_NUM_RECTS(prgn);
+
+ CHECK_DMA_QUIESCENT(MGAPTR(pScrn), pScrn);
+
+ MGANAME(SetupForSolidFill)(pScrn, 0, GXcopy, -1);
+ while (nbox--) {
+ MGASelectBuffer(pScrn, MGA_BACK);
+ MGANAME(SubsequentSolidFillRect)(pScrn, pbox->x1, pbox->y1,
+ pbox->x2-pbox->x1, pbox->y2-pbox->y1);
+ MGASelectBuffer(pScrn, MGA_DEPTH);
+ MGANAME(SubsequentSolidFillRect)(pScrn, pbox->x1, pbox->y1,
+ pbox->x2-pbox->x1, pbox->y2-pbox->y1);
+ pbox++;
+ }
+ MGASelectBuffer(pScrn, MGA_FRONT);
+
+ pMga->AccelInfoRec->NeedToSync = TRUE;
+}
+
+/*
+ This routine is a modified form of XAADoBitBlt with the calls to
+ ScreenToScreenBitBlt built in. My routine has the prgnSrc as source
+ instead of destination. My origin is upside down so the ydir cases
+ are reversed.
+*/
+
+void
+MGANAME(DRIMoveBuffers)(WindowPtr pParent, DDXPointRec ptOldOrg,
+ RegionPtr prgnSrc, CARD32 index)
+{
+ ScreenPtr pScreen = pParent->drawable.pScreen;
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ int nbox;
+ BoxPtr pbox, pboxTmp, pboxNext, pboxBase, pboxNew1, pboxNew2;
+ DDXPointPtr pptTmp, pptNew1, pptNew2;
+ int xdir, ydir;
+ int dx, dy;
+ DDXPointPtr pptSrc;
+ int screenwidth = pScrn->virtualX;
+ int screenheight = pScrn->virtualY;
+
+ CHECK_DMA_QUIESCENT(MGAPTR(pScrn), pScrn);
+
+ pbox = REGION_RECTS(prgnSrc);
+ nbox = REGION_NUM_RECTS(prgnSrc);
+ pboxNew1 = 0;
+ pptNew1 = 0;
+ pboxNew2 = 0;
+ pboxNew2 = 0;
+ pptSrc = &ptOldOrg;
+
+ dx = pParent->drawable.x - ptOldOrg.x;
+ dy = pParent->drawable.y - ptOldOrg.y;
+
+ /* If the copy will overlap in Y, reverse the order */
+ if (dy>0) {
+ ydir = -1;
+
+ if (nbox>1) {
+ /* Keep ordering in each band, reverse order of bands */
+ pboxNew1 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec)*nbox);
+ if (!pboxNew1) return;
+ pptNew1 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec)*nbox);
+ if (!pptNew1) {
+ DEALLOCATE_LOCAL(pboxNew1);
+ return;
+ }
+ pboxBase = pboxNext = pbox+nbox-1;
+ while (pboxBase >= pbox) {
+ while ((pboxNext >= pbox) && (pboxBase->y1 == pboxNext->y1))
+ pboxNext--;
+ pboxTmp = pboxNext+1;
+ pptTmp = pptSrc + (pboxTmp - pbox);
+ while (pboxTmp <= pboxBase) {
+ *pboxNew1++ = *pboxTmp++;
+ *pptNew1++ = *pptTmp++;
+ }
+ pboxBase = pboxNext;
+ }
+ pboxNew1 -= nbox;
+ pbox = pboxNew1;
+ pptNew1 -= nbox;
+ pptSrc = pptNew1;
+ }
+ } else {
+ /* No changes required */
+ ydir = 1;
+ }
+
+ /* If the regions will overlap in X, reverse the order */
+ if (dx>0) {
+ xdir = -1;
+
+ if (nbox > 1) {
+ /*reverse orderof rects in each band */
+ pboxNew2 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec)*nbox);
+ pptNew2 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec)*nbox);
+ if (!pboxNew2 || !pptNew2) {
+ if (pptNew2) DEALLOCATE_LOCAL(pptNew2);
+ if (pboxNew2) DEALLOCATE_LOCAL(pboxNew2);
+ if (pboxNew1) {
+ DEALLOCATE_LOCAL(pptNew1);
+ DEALLOCATE_LOCAL(pboxNew1);
+ }
+ return;
+ }
+ pboxBase = pboxNext = pbox;
+ while (pboxBase < pbox+nbox) {
+ while ((pboxNext < pbox+nbox) &&
+ (pboxNext->y1 == pboxBase->y1))
+ pboxNext++;
+ pboxTmp = pboxNext;
+ pptTmp = pptSrc + (pboxTmp - pbox);
+ while (pboxTmp != pboxBase) {
+ *pboxNew2++ = *--pboxTmp;
+ *pptNew2++ = *--pptTmp;
+ }
+ pboxBase = pboxNext;
+ }
+ pboxNew2 -= nbox;
+ pbox = pboxNew2;
+ pptNew2 -= nbox;
+ pptSrc = pptNew2;
+ }
+ } else {
+ /* No changes are needed */
+ xdir = 1;
+ }
+
+ MGANAME(SetupForScreenToScreenCopy)(pScrn, xdir, ydir, GXcopy, -1, -1);
+ for ( ; nbox-- ; pbox++)
+ {
+ int x1 = pbox->x1;
+ int y1 = pbox->y1;
+ int destx = x1 + dx;
+ int desty = y1 + dy;
+ int w = pbox->x2 - x1 + 1;
+ int h = pbox->y2 - y1 + 1;
+
+ if ( destx < 0 ) x1 -= destx, w += destx, destx = 0;
+ if ( desty < 0 ) y1 -= desty, h += desty, desty = 0;
+ if ( destx + w > screenwidth ) w = screenwidth - destx;
+ if ( desty + h > screenheight ) h = screenheight - desty;
+ if ( w <= 0 ) continue;
+ if ( h <= 0 ) continue;
+
+ MGASelectBuffer(pScrn, MGA_BACK);
+ MGANAME(SubsequentScreenToScreenCopy)(pScrn, x1, y1,
+ destx,desty, w, h);
+ MGASelectBuffer(pScrn, MGA_DEPTH);
+ MGANAME(SubsequentScreenToScreenCopy)(pScrn, x1,y1,
+ destx,desty, w, h);
+ }
+ MGASelectBuffer(pScrn, MGA_FRONT);
+
+ if (pboxNew2) {
+ DEALLOCATE_LOCAL(pptNew2);
+ DEALLOCATE_LOCAL(pboxNew2);
+ }
+ if (pboxNew1) {
+ DEALLOCATE_LOCAL(pptNew1);
+ DEALLOCATE_LOCAL(pboxNew1);
+ }
+
+ pMga->AccelInfoRec->NeedToSync = TRUE;
+}
+
+#endif /* XF86DRI */
diff --git a/src/mga_ucode.h b/src/mga_ucode.h
new file mode 100644
index 0000000..2921ceb
--- /dev/null
+++ b/src/mga_ucode.h
@@ -0,0 +1,11610 @@
+/*
+ * GLX Hardware Device Driver for Matrox G200/G400
+ *
+ * Warp Engine Microcode
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * MATROX GRAPHICS INC., OR ANY OTHER CONTRIBUTORS 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.
+ *
+ * (c) 1999 Matrox Graphics Inc.
+ *
+ */
+
+
+unsigned char WARP_G200_tgz[] = {
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x98, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x81, 0x04,
+0x89, 0x04,
+0x01, 0x04,
+0x09, 0x04,
+
+0xC9, 0x41, 0xC0, 0xEC,
+0x11, 0x04,
+0x00, 0xE0,
+
+0x41, 0xCC, 0x41, 0xCD,
+0x49, 0xCC, 0x49, 0xCD,
+
+0xD1, 0x41, 0xC0, 0xEC,
+0x51, 0xCC, 0x51, 0xCD,
+
+0x80, 0x04,
+0x10, 0x04,
+0x08, 0x04,
+0x00, 0xE0,
+
+0x00, 0xCC, 0xC0, 0xCD,
+0xD1, 0x49, 0xC0, 0xEC,
+
+0x8A, 0x1F, 0x20, 0xE9,
+0x8B, 0x3F, 0x20, 0xE9,
+
+0x41, 0x3C, 0x41, 0xAD,
+0x49, 0x3C, 0x49, 0xAD,
+
+0x10, 0xCC, 0x10, 0xCD,
+0x08, 0xCC, 0x08, 0xCD,
+
+0xB9, 0x41, 0x49, 0xBB,
+0x1F, 0xF0, 0x41, 0xCD,
+
+0x51, 0x3C, 0x51, 0xAD,
+0x00, 0x98, 0x80, 0xE9,
+
+0x72, 0x80, 0x07, 0xEA,
+0x24, 0x1F, 0x20, 0xE9,
+
+0x15, 0x41, 0x49, 0xBD,
+0x1D, 0x41, 0x51, 0xBD,
+
+0x2E, 0x41, 0x2A, 0xB8,
+0x34, 0x53, 0xA0, 0xE8,
+
+0x15, 0x30,
+0x1D, 0x30,
+0x58, 0xE3,
+0x00, 0xE0,
+
+0xB5, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x24, 0x43, 0xA0, 0xE8,
+0x2C, 0x4B, 0xA0, 0xE8,
+
+0x15, 0x72,
+0x09, 0xE3,
+0x00, 0xE0,
+0x1D, 0x72,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0x97, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x6C, 0x64, 0xC8, 0xEC,
+0x98, 0xE1,
+0xB5, 0x05,
+
+0xBD, 0x05,
+0x2E, 0x30,
+0x32, 0xC0, 0xA0, 0xE8,
+
+0x33, 0xC0, 0xA0, 0xE8,
+0x74, 0x64, 0xC8, 0xEC,
+
+0x40, 0x3C, 0x40, 0xAD,
+0x32, 0x6A,
+0x2A, 0x30,
+
+0x20, 0x73,
+0x33, 0x6A,
+0x00, 0xE0,
+0x28, 0x73,
+
+0x1C, 0x72,
+0x83, 0xE2,
+0x60, 0x80, 0x15, 0xEA,
+
+0xB8, 0x3D, 0x28, 0xDF,
+0x30, 0x35, 0x20, 0xDF,
+
+0x40, 0x30,
+0x00, 0xE0,
+0xCC, 0xE2,
+0x64, 0x72,
+
+0x25, 0x42, 0x52, 0xBF,
+0x2D, 0x42, 0x4A, 0xBF,
+
+0x30, 0x2E, 0x30, 0xDF,
+0x38, 0x2E, 0x38, 0xDF,
+
+0x18, 0x1D, 0x45, 0xE9,
+0x1E, 0x15, 0x45, 0xE9,
+
+0x2B, 0x49, 0x51, 0xBD,
+0x00, 0xE0,
+0x1F, 0x73,
+
+0x38, 0x38, 0x40, 0xAF,
+0x30, 0x30, 0x40, 0xAF,
+
+0x24, 0x1F, 0x24, 0xDF,
+0x1D, 0x32, 0x20, 0xE9,
+
+0x2C, 0x1F, 0x2C, 0xDF,
+0x1A, 0x33, 0x20, 0xE9,
+
+0xB0, 0x10,
+0x08, 0xE3,
+0x40, 0x10,
+0xB8, 0x10,
+
+0x26, 0xF0, 0x30, 0xCD,
+0x2F, 0xF0, 0x38, 0xCD,
+
+0x2B, 0x80, 0x20, 0xE9,
+0x2A, 0x80, 0x20, 0xE9,
+
+0xA6, 0x20,
+0x88, 0xE2,
+0x00, 0xE0,
+0xAF, 0x20,
+
+0x28, 0x2A, 0x26, 0xAF,
+0x20, 0x2A, 0xC0, 0xAF,
+
+0x34, 0x1F, 0x34, 0xDF,
+0x46, 0x24, 0x46, 0xDF,
+
+0x28, 0x30, 0x80, 0xBF,
+0x20, 0x38, 0x80, 0xBF,
+
+0x47, 0x24, 0x47, 0xDF,
+0x4E, 0x2C, 0x4E, 0xDF,
+
+0x4F, 0x2C, 0x4F, 0xDF,
+0x56, 0x34, 0x56, 0xDF,
+
+0x28, 0x15, 0x28, 0xDF,
+0x20, 0x1D, 0x20, 0xDF,
+
+0x57, 0x34, 0x57, 0xDF,
+0x00, 0xE0,
+0x1D, 0x05,
+
+0x04, 0x80, 0x10, 0xEA,
+0x89, 0xE2,
+0x2B, 0x30,
+
+0x3F, 0xC1, 0x1D, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA0, 0x68,
+0xBF, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x20, 0xC0, 0x20, 0xAF,
+0x28, 0x05,
+0x97, 0x74,
+
+0x00, 0xE0,
+0x2A, 0x10,
+0x16, 0xC0, 0x20, 0xE9,
+
+0x04, 0x80, 0x10, 0xEA,
+0x8C, 0xE2,
+0x95, 0x05,
+
+0x28, 0xC1, 0x28, 0xAD,
+0x1F, 0xC1, 0x15, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA8, 0x67,
+0x9F, 0x6B,
+0x00, 0x80, 0x00, 0xE8,
+
+0x28, 0xC0, 0x28, 0xAD,
+0x1D, 0x25,
+0x20, 0x05,
+
+0x28, 0x32, 0x80, 0xAD,
+0x40, 0x2A, 0x40, 0xBD,
+
+0x1C, 0x80, 0x20, 0xE9,
+0x20, 0x33, 0x20, 0xAD,
+
+0x20, 0x73,
+0x00, 0xE0,
+0xB6, 0x49, 0x51, 0xBB,
+
+0x26, 0x2F, 0xB0, 0xE8,
+0x19, 0x20, 0x20, 0xE9,
+
+0x35, 0x20, 0x35, 0xDF,
+0x3D, 0x20, 0x3D, 0xDF,
+
+0x15, 0x20, 0x15, 0xDF,
+0x1D, 0x20, 0x1D, 0xDF,
+
+0x26, 0xD0, 0x26, 0xCD,
+0x29, 0x49, 0x2A, 0xB8,
+
+0x26, 0x40, 0x80, 0xBD,
+0x3B, 0x48, 0x50, 0xBD,
+
+0x3E, 0x54, 0x57, 0x9F,
+0x00, 0xE0,
+0x82, 0xE1,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x26, 0x30,
+0x29, 0x30,
+0x48, 0x3C, 0x48, 0xAD,
+
+0x2B, 0x72,
+0xC2, 0xE1,
+0x2C, 0xC0, 0x44, 0xC2,
+
+0x05, 0x24, 0x34, 0xBF,
+0x0D, 0x24, 0x2C, 0xBF,
+
+0x2D, 0x46, 0x4E, 0xBF,
+0x25, 0x46, 0x56, 0xBF,
+
+0x20, 0x1D, 0x6F, 0x8F,
+0x32, 0x3E, 0x5F, 0xE9,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x30,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x33, 0x1E, 0x5F, 0xE9,
+
+0x05, 0x44, 0x54, 0xB2,
+0x0D, 0x44, 0x4C, 0xB2,
+
+0x19, 0xC0, 0xB0, 0xE8,
+0x34, 0xC0, 0x44, 0xC4,
+
+0x33, 0x73,
+0x00, 0xE0,
+0x3E, 0x62, 0x57, 0x9F,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0xE0,
+0x0D, 0x20,
+
+0x84, 0x3E, 0x58, 0xE9,
+0x28, 0x1D, 0x6F, 0x8F,
+
+0x05, 0x20,
+0x00, 0xE0,
+0x85, 0x1E, 0x58, 0xE9,
+
+0x9B, 0x3B, 0x33, 0xDF,
+0x20, 0x20, 0x42, 0xAF,
+
+0x30, 0x42, 0x56, 0x9F,
+0x80, 0x3E, 0x57, 0xE9,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x30, 0x80, 0x5F, 0xE9,
+
+0x28, 0x28, 0x24, 0xAF,
+0x81, 0x1E, 0x57, 0xE9,
+
+0x05, 0x47, 0x57, 0xBF,
+0x0D, 0x47, 0x4F, 0xBF,
+
+0x88, 0x80, 0x58, 0xE9,
+0x1B, 0x29, 0x1B, 0xDF,
+
+0x30, 0x1D, 0x6F, 0x8F,
+0x3A, 0x30, 0x4F, 0xE9,
+
+0x1C, 0x30, 0x26, 0xDF,
+0x09, 0xE3,
+0x3B, 0x05,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x3B, 0x3F, 0x4F, 0xE9,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x00, 0xE0,
+0xAC, 0x20,
+
+0x2D, 0x44, 0x4C, 0xB4,
+0x2C, 0x1C, 0xC0, 0xAF,
+
+0x25, 0x44, 0x54, 0xB4,
+0x00, 0xE0,
+0xC8, 0x30,
+
+0x30, 0x46, 0x30, 0xAF,
+0x1B, 0x1B, 0x48, 0xAF,
+
+0x00, 0xE0,
+0x25, 0x20,
+0x38, 0x2C, 0x4F, 0xE9,
+
+0x86, 0x80, 0x57, 0xE9,
+0x38, 0x1D, 0x6F, 0x8F,
+
+0x28, 0x74,
+0x00, 0xE0,
+0x0D, 0x44, 0x4C, 0xB0,
+
+0x05, 0x44, 0x54, 0xB0,
+0x2D, 0x20,
+0x9B, 0x10,
+
+0x82, 0x3E, 0x57, 0xE9,
+0x32, 0xF0, 0x1B, 0xCD,
+
+0x1E, 0xBD, 0x59, 0x9F,
+0x83, 0x1E, 0x57, 0xE9,
+
+0x38, 0x47, 0x38, 0xAF,
+0x34, 0x20,
+0x2A, 0x30,
+
+0x00, 0xE0,
+0x0D, 0x20,
+0x32, 0x20,
+0x05, 0x20,
+
+0x87, 0x80, 0x57, 0xE9,
+0x1F, 0x54, 0x57, 0x9F,
+
+0x17, 0x42, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x6A,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x37, 0x1E, 0x4F, 0xE9,
+
+0x37, 0x32, 0x2A, 0xAF,
+0x00, 0xE0,
+0x32, 0x00,
+
+0x00, 0x80, 0x00, 0xE8,
+0x27, 0xC0, 0x44, 0xC0,
+
+0x36, 0x1F, 0x4F, 0xE9,
+0x1F, 0x1F, 0x26, 0xDF,
+
+0x37, 0x1B, 0x37, 0xBF,
+0x17, 0x26, 0x17, 0xDF,
+
+0x3E, 0x17, 0x4F, 0xE9,
+0x3F, 0x3F, 0x4F, 0xE9,
+
+0x34, 0x1F, 0x34, 0xAF,
+0x2B, 0x05,
+0xA7, 0x20,
+
+0x33, 0x2B, 0x37, 0xDF,
+0x27, 0x17, 0xC0, 0xAF,
+
+0x34, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x03, 0x80, 0x0A, 0xEA,
+0x17, 0xC1, 0x2B, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xB3, 0x68,
+0x97, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0xC0, 0x33, 0xAF,
+0x3C, 0x27, 0x4F, 0xE9,
+
+0x57, 0x39, 0x20, 0xE9,
+0x28, 0x19, 0x60, 0xEC,
+
+0x2B, 0x32, 0x20, 0xE9,
+0x1D, 0x3B, 0x20, 0xE9,
+
+0xB3, 0x05,
+0x00, 0xE0,
+0x16, 0x28, 0x20, 0xE9,
+
+0x23, 0x3B, 0x33, 0xAD,
+0x1E, 0x2B, 0x20, 0xE9,
+
+0x1C, 0x80, 0x20, 0xE9,
+0x57, 0x36, 0x20, 0xE9,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x90, 0xE2,
+0x00, 0xE0,
+
+0x85, 0xFF, 0x20, 0xEA,
+0x19, 0xC8, 0xC1, 0xCD,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x9F, 0x41, 0x49, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x41, 0x49, 0xBD,
+0x2D, 0x41, 0x51, 0xBD,
+
+0x0D, 0x80, 0x07, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x35, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x25, 0x30,
+0x2D, 0x30,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0xA7, 0x5B, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x84, 0xFF, 0x0A, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC9, 0x41, 0xC8, 0xEC,
+0x42, 0xE1,
+0x00, 0xE0,
+
+0x82, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC8, 0x40, 0xC0, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x7F, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+};
+unsigned char WARP_G200_tgza[] = {
+
+0x00, 0x98, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x81, 0x04,
+0x89, 0x04,
+0x01, 0x04,
+0x09, 0x04,
+
+0xC9, 0x41, 0xC0, 0xEC,
+0x11, 0x04,
+0x00, 0xE0,
+
+0x41, 0xCC, 0x41, 0xCD,
+0x49, 0xCC, 0x49, 0xCD,
+
+0xD1, 0x41, 0xC0, 0xEC,
+0x51, 0xCC, 0x51, 0xCD,
+
+0x80, 0x04,
+0x10, 0x04,
+0x08, 0x04,
+0x00, 0xE0,
+
+0x00, 0xCC, 0xC0, 0xCD,
+0xD1, 0x49, 0xC0, 0xEC,
+
+0x8A, 0x1F, 0x20, 0xE9,
+0x8B, 0x3F, 0x20, 0xE9,
+
+0x41, 0x3C, 0x41, 0xAD,
+0x49, 0x3C, 0x49, 0xAD,
+
+0x10, 0xCC, 0x10, 0xCD,
+0x08, 0xCC, 0x08, 0xCD,
+
+0xB9, 0x41, 0x49, 0xBB,
+0x1F, 0xF0, 0x41, 0xCD,
+
+0x51, 0x3C, 0x51, 0xAD,
+0x00, 0x98, 0x80, 0xE9,
+
+0x7D, 0x80, 0x07, 0xEA,
+0x24, 0x1F, 0x20, 0xE9,
+
+0x15, 0x41, 0x49, 0xBD,
+0x1D, 0x41, 0x51, 0xBD,
+
+0x2E, 0x41, 0x2A, 0xB8,
+0x34, 0x53, 0xA0, 0xE8,
+
+0x15, 0x30,
+0x1D, 0x30,
+0x58, 0xE3,
+0x00, 0xE0,
+
+0xB5, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x24, 0x43, 0xA0, 0xE8,
+0x2C, 0x4B, 0xA0, 0xE8,
+
+0x15, 0x72,
+0x09, 0xE3,
+0x00, 0xE0,
+0x1D, 0x72,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0x97, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x6C, 0x64, 0xC8, 0xEC,
+0x98, 0xE1,
+0xB5, 0x05,
+
+0xBD, 0x05,
+0x2E, 0x30,
+0x32, 0xC0, 0xA0, 0xE8,
+
+0x33, 0xC0, 0xA0, 0xE8,
+0x74, 0x64, 0xC8, 0xEC,
+
+0x40, 0x3C, 0x40, 0xAD,
+0x32, 0x6A,
+0x2A, 0x30,
+
+0x20, 0x73,
+0x33, 0x6A,
+0x00, 0xE0,
+0x28, 0x73,
+
+0x1C, 0x72,
+0x83, 0xE2,
+0x6B, 0x80, 0x15, 0xEA,
+
+0xB8, 0x3D, 0x28, 0xDF,
+0x30, 0x35, 0x20, 0xDF,
+
+0x40, 0x30,
+0x00, 0xE0,
+0xCC, 0xE2,
+0x64, 0x72,
+
+0x25, 0x42, 0x52, 0xBF,
+0x2D, 0x42, 0x4A, 0xBF,
+
+0x30, 0x2E, 0x30, 0xDF,
+0x38, 0x2E, 0x38, 0xDF,
+
+0x18, 0x1D, 0x45, 0xE9,
+0x1E, 0x15, 0x45, 0xE9,
+
+0x2B, 0x49, 0x51, 0xBD,
+0x00, 0xE0,
+0x1F, 0x73,
+
+0x38, 0x38, 0x40, 0xAF,
+0x30, 0x30, 0x40, 0xAF,
+
+0x24, 0x1F, 0x24, 0xDF,
+0x1D, 0x32, 0x20, 0xE9,
+
+0x2C, 0x1F, 0x2C, 0xDF,
+0x1A, 0x33, 0x20, 0xE9,
+
+0xB0, 0x10,
+0x08, 0xE3,
+0x40, 0x10,
+0xB8, 0x10,
+
+0x26, 0xF0, 0x30, 0xCD,
+0x2F, 0xF0, 0x38, 0xCD,
+
+0x2B, 0x80, 0x20, 0xE9,
+0x2A, 0x80, 0x20, 0xE9,
+
+0xA6, 0x20,
+0x88, 0xE2,
+0x00, 0xE0,
+0xAF, 0x20,
+
+0x28, 0x2A, 0x26, 0xAF,
+0x20, 0x2A, 0xC0, 0xAF,
+
+0x34, 0x1F, 0x34, 0xDF,
+0x46, 0x24, 0x46, 0xDF,
+
+0x28, 0x30, 0x80, 0xBF,
+0x20, 0x38, 0x80, 0xBF,
+
+0x47, 0x24, 0x47, 0xDF,
+0x4E, 0x2C, 0x4E, 0xDF,
+
+0x4F, 0x2C, 0x4F, 0xDF,
+0x56, 0x34, 0x56, 0xDF,
+
+0x28, 0x15, 0x28, 0xDF,
+0x20, 0x1D, 0x20, 0xDF,
+
+0x57, 0x34, 0x57, 0xDF,
+0x00, 0xE0,
+0x1D, 0x05,
+
+0x04, 0x80, 0x10, 0xEA,
+0x89, 0xE2,
+0x2B, 0x30,
+
+0x3F, 0xC1, 0x1D, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA0, 0x68,
+0xBF, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x20, 0xC0, 0x20, 0xAF,
+0x28, 0x05,
+0x97, 0x74,
+
+0x00, 0xE0,
+0x2A, 0x10,
+0x16, 0xC0, 0x20, 0xE9,
+
+0x04, 0x80, 0x10, 0xEA,
+0x8C, 0xE2,
+0x95, 0x05,
+
+0x28, 0xC1, 0x28, 0xAD,
+0x1F, 0xC1, 0x15, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA8, 0x67,
+0x9F, 0x6B,
+0x00, 0x80, 0x00, 0xE8,
+
+0x28, 0xC0, 0x28, 0xAD,
+0x1D, 0x25,
+0x20, 0x05,
+
+0x28, 0x32, 0x80, 0xAD,
+0x40, 0x2A, 0x40, 0xBD,
+
+0x1C, 0x80, 0x20, 0xE9,
+0x20, 0x33, 0x20, 0xAD,
+
+0x20, 0x73,
+0x00, 0xE0,
+0xB6, 0x49, 0x51, 0xBB,
+
+0x26, 0x2F, 0xB0, 0xE8,
+0x19, 0x20, 0x20, 0xE9,
+
+0x35, 0x20, 0x35, 0xDF,
+0x3D, 0x20, 0x3D, 0xDF,
+
+0x15, 0x20, 0x15, 0xDF,
+0x1D, 0x20, 0x1D, 0xDF,
+
+0x26, 0xD0, 0x26, 0xCD,
+0x29, 0x49, 0x2A, 0xB8,
+
+0x26, 0x40, 0x80, 0xBD,
+0x3B, 0x48, 0x50, 0xBD,
+
+0x3E, 0x54, 0x57, 0x9F,
+0x00, 0xE0,
+0x82, 0xE1,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x26, 0x30,
+0x29, 0x30,
+0x48, 0x3C, 0x48, 0xAD,
+
+0x2B, 0x72,
+0xC2, 0xE1,
+0x2C, 0xC0, 0x44, 0xC2,
+
+0x05, 0x24, 0x34, 0xBF,
+0x0D, 0x24, 0x2C, 0xBF,
+
+0x2D, 0x46, 0x4E, 0xBF,
+0x25, 0x46, 0x56, 0xBF,
+
+0x20, 0x1D, 0x6F, 0x8F,
+0x32, 0x3E, 0x5F, 0xE9,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x30,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x33, 0x1E, 0x5F, 0xE9,
+
+0x05, 0x44, 0x54, 0xB2,
+0x0D, 0x44, 0x4C, 0xB2,
+
+0x19, 0xC0, 0xB0, 0xE8,
+0x34, 0xC0, 0x44, 0xC4,
+
+0x33, 0x73,
+0x00, 0xE0,
+0x3E, 0x62, 0x57, 0x9F,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0xE0,
+0x0D, 0x20,
+
+0x84, 0x3E, 0x58, 0xE9,
+0x28, 0x1D, 0x6F, 0x8F,
+
+0x05, 0x20,
+0x00, 0xE0,
+0x85, 0x1E, 0x58, 0xE9,
+
+0x9B, 0x3B, 0x33, 0xDF,
+0x20, 0x20, 0x42, 0xAF,
+
+0x30, 0x42, 0x56, 0x9F,
+0x80, 0x3E, 0x57, 0xE9,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x30, 0x80, 0x5F, 0xE9,
+
+0x28, 0x28, 0x24, 0xAF,
+0x81, 0x1E, 0x57, 0xE9,
+
+0x05, 0x47, 0x57, 0xBF,
+0x0D, 0x47, 0x4F, 0xBF,
+
+0x88, 0x80, 0x58, 0xE9,
+0x1B, 0x29, 0x1B, 0xDF,
+
+0x30, 0x1D, 0x6F, 0x8F,
+0x3A, 0x30, 0x4F, 0xE9,
+
+0x1C, 0x30, 0x26, 0xDF,
+0x09, 0xE3,
+0x3B, 0x05,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x3B, 0x3F, 0x4F, 0xE9,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x00, 0xE0,
+0xAC, 0x20,
+
+0x2D, 0x44, 0x4C, 0xB4,
+0x2C, 0x1C, 0xC0, 0xAF,
+
+0x25, 0x44, 0x54, 0xB4,
+0x00, 0xE0,
+0xC8, 0x30,
+
+0x30, 0x46, 0x30, 0xAF,
+0x1B, 0x1B, 0x48, 0xAF,
+
+0x00, 0xE0,
+0x25, 0x20,
+0x38, 0x2C, 0x4F, 0xE9,
+
+0x86, 0x80, 0x57, 0xE9,
+0x38, 0x1D, 0x6F, 0x8F,
+
+0x28, 0x74,
+0x00, 0xE0,
+0x0D, 0x44, 0x4C, 0xB0,
+
+0x05, 0x44, 0x54, 0xB0,
+0x2D, 0x20,
+0x9B, 0x10,
+
+0x82, 0x3E, 0x57, 0xE9,
+0x32, 0xF0, 0x1B, 0xCD,
+
+0x1E, 0xBD, 0x59, 0x9F,
+0x83, 0x1E, 0x57, 0xE9,
+
+0x38, 0x47, 0x38, 0xAF,
+0x34, 0x20,
+0x2A, 0x30,
+
+0x00, 0xE0,
+0x0D, 0x20,
+0x32, 0x20,
+0x05, 0x20,
+
+0x87, 0x80, 0x57, 0xE9,
+0x1F, 0x54, 0x57, 0x9F,
+
+0x17, 0x42, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x6A,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x37, 0x1E, 0x4F, 0xE9,
+
+0x37, 0x32, 0x2A, 0xAF,
+0x00, 0xE0,
+0x32, 0x00,
+
+0x00, 0x80, 0x00, 0xE8,
+0x27, 0xC0, 0x44, 0xC0,
+
+0x36, 0x1F, 0x4F, 0xE9,
+0x1F, 0x1F, 0x26, 0xDF,
+
+0x37, 0x1B, 0x37, 0xBF,
+0x17, 0x26, 0x17, 0xDF,
+
+0x3E, 0x17, 0x4F, 0xE9,
+0x3F, 0x3F, 0x4F, 0xE9,
+
+0x34, 0x1F, 0x34, 0xAF,
+0x2B, 0x05,
+0xA7, 0x20,
+
+0x33, 0x2B, 0x37, 0xDF,
+0x27, 0x17, 0xC0, 0xAF,
+
+0x34, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x2D, 0x44, 0x4C, 0xB6,
+0x25, 0x44, 0x54, 0xB6,
+
+0x03, 0x80, 0x2A, 0xEA,
+0x17, 0xC1, 0x2B, 0xBD,
+
+0x2D, 0x20,
+0x25, 0x20,
+0x07, 0xC0, 0x44, 0xC6,
+
+0xB3, 0x68,
+0x97, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0xC0, 0x33, 0xAF,
+0x3C, 0x27, 0x4F, 0xE9,
+
+0x1F, 0x62, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x3F, 0x3D, 0x5D, 0x9F,
+0x00, 0xE0,
+0x07, 0x20,
+
+0x00, 0x80, 0x00, 0xE8,
+0x28, 0x19, 0x60, 0xEC,
+
+0xB3, 0x05,
+0x00, 0xE0,
+0x00, 0x80, 0x00, 0xE8,
+
+0x23, 0x3B, 0x33, 0xAD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x1F, 0x26, 0x1F, 0xDF,
+0x9D, 0x1F, 0x4F, 0xE9,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x9E, 0x3F, 0x4F, 0xE9,
+
+0x07, 0x07, 0x1F, 0xAF,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x9C, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x57, 0x39, 0x20, 0xE9,
+
+0x16, 0x28, 0x20, 0xE9,
+0x1D, 0x3B, 0x20, 0xE9,
+
+0x1E, 0x2B, 0x20, 0xE9,
+0x2B, 0x32, 0x20, 0xE9,
+
+0x1C, 0x23, 0x20, 0xE9,
+0x57, 0x36, 0x20, 0xE9,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x90, 0xE2,
+0x00, 0xE0,
+
+0x7A, 0xFF, 0x20, 0xEA,
+0x19, 0xC8, 0xC1, 0xCD,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x9F, 0x41, 0x49, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x41, 0x49, 0xBD,
+0x2D, 0x41, 0x51, 0xBD,
+
+0x0D, 0x80, 0x07, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x35, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x25, 0x30,
+0x2D, 0x30,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0xA7, 0x5B, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x79, 0xFF, 0x0A, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC9, 0x41, 0xC8, 0xEC,
+0x42, 0xE1,
+0x00, 0xE0,
+
+0x77, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC8, 0x40, 0xC0, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x74, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+};
+unsigned char WARP_G200_tgzaf[] = {
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x98, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x81, 0x04,
+0x89, 0x04,
+0x01, 0x04,
+0x09, 0x04,
+
+0xC9, 0x41, 0xC0, 0xEC,
+0x11, 0x04,
+0x00, 0xE0,
+
+0x41, 0xCC, 0x41, 0xCD,
+0x49, 0xCC, 0x49, 0xCD,
+
+0xD1, 0x41, 0xC0, 0xEC,
+0x51, 0xCC, 0x51, 0xCD,
+
+0x80, 0x04,
+0x10, 0x04,
+0x08, 0x04,
+0x00, 0xE0,
+
+0x00, 0xCC, 0xC0, 0xCD,
+0xD1, 0x49, 0xC0, 0xEC,
+
+0x8A, 0x1F, 0x20, 0xE9,
+0x8B, 0x3F, 0x20, 0xE9,
+
+0x41, 0x3C, 0x41, 0xAD,
+0x49, 0x3C, 0x49, 0xAD,
+
+0x10, 0xCC, 0x10, 0xCD,
+0x08, 0xCC, 0x08, 0xCD,
+
+0xB9, 0x41, 0x49, 0xBB,
+0x1F, 0xF0, 0x41, 0xCD,
+
+0x51, 0x3C, 0x51, 0xAD,
+0x00, 0x98, 0x80, 0xE9,
+
+0x83, 0x80, 0x07, 0xEA,
+0x24, 0x1F, 0x20, 0xE9,
+
+0x21, 0x45, 0x80, 0xE8,
+0x1A, 0x4D, 0x80, 0xE8,
+
+0x31, 0x55, 0x80, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0x41, 0x49, 0xBD,
+0x1D, 0x41, 0x51, 0xBD,
+
+0x2E, 0x41, 0x2A, 0xB8,
+0x34, 0x53, 0xA0, 0xE8,
+
+0x15, 0x30,
+0x1D, 0x30,
+0x58, 0xE3,
+0x00, 0xE0,
+
+0xB5, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x24, 0x43, 0xA0, 0xE8,
+0x2C, 0x4B, 0xA0, 0xE8,
+
+0x15, 0x72,
+0x09, 0xE3,
+0x00, 0xE0,
+0x1D, 0x72,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0x97, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x6C, 0x64, 0xC8, 0xEC,
+0x98, 0xE1,
+0xB5, 0x05,
+
+0xBD, 0x05,
+0x2E, 0x30,
+0x32, 0xC0, 0xA0, 0xE8,
+
+0x33, 0xC0, 0xA0, 0xE8,
+0x74, 0x64, 0xC8, 0xEC,
+
+0x40, 0x3C, 0x40, 0xAD,
+0x32, 0x6A,
+0x2A, 0x30,
+
+0x20, 0x73,
+0x33, 0x6A,
+0x00, 0xE0,
+0x28, 0x73,
+
+0x1C, 0x72,
+0x83, 0xE2,
+0x6F, 0x80, 0x15, 0xEA,
+
+0xB8, 0x3D, 0x28, 0xDF,
+0x30, 0x35, 0x20, 0xDF,
+
+0x40, 0x30,
+0x00, 0xE0,
+0xCC, 0xE2,
+0x64, 0x72,
+
+0x25, 0x42, 0x52, 0xBF,
+0x2D, 0x42, 0x4A, 0xBF,
+
+0x30, 0x2E, 0x30, 0xDF,
+0x38, 0x2E, 0x38, 0xDF,
+
+0x18, 0x1D, 0x45, 0xE9,
+0x1E, 0x15, 0x45, 0xE9,
+
+0x2B, 0x49, 0x51, 0xBD,
+0x00, 0xE0,
+0x1F, 0x73,
+
+0x38, 0x38, 0x40, 0xAF,
+0x30, 0x30, 0x40, 0xAF,
+
+0x24, 0x1F, 0x24, 0xDF,
+0x1D, 0x32, 0x20, 0xE9,
+
+0x2C, 0x1F, 0x2C, 0xDF,
+0x1A, 0x33, 0x20, 0xE9,
+
+0xB0, 0x10,
+0x08, 0xE3,
+0x40, 0x10,
+0xB8, 0x10,
+
+0x26, 0xF0, 0x30, 0xCD,
+0x2F, 0xF0, 0x38, 0xCD,
+
+0x2B, 0x80, 0x20, 0xE9,
+0x2A, 0x80, 0x20, 0xE9,
+
+0xA6, 0x20,
+0x88, 0xE2,
+0x00, 0xE0,
+0xAF, 0x20,
+
+0x28, 0x2A, 0x26, 0xAF,
+0x20, 0x2A, 0xC0, 0xAF,
+
+0x34, 0x1F, 0x34, 0xDF,
+0x46, 0x24, 0x46, 0xDF,
+
+0x28, 0x30, 0x80, 0xBF,
+0x20, 0x38, 0x80, 0xBF,
+
+0x47, 0x24, 0x47, 0xDF,
+0x4E, 0x2C, 0x4E, 0xDF,
+
+0x4F, 0x2C, 0x4F, 0xDF,
+0x56, 0x34, 0x56, 0xDF,
+
+0x28, 0x15, 0x28, 0xDF,
+0x20, 0x1D, 0x20, 0xDF,
+
+0x57, 0x34, 0x57, 0xDF,
+0x00, 0xE0,
+0x1D, 0x05,
+
+0x04, 0x80, 0x10, 0xEA,
+0x89, 0xE2,
+0x2B, 0x30,
+
+0x3F, 0xC1, 0x1D, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA0, 0x68,
+0xBF, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x20, 0xC0, 0x20, 0xAF,
+0x28, 0x05,
+0x97, 0x74,
+
+0x00, 0xE0,
+0x2A, 0x10,
+0x16, 0xC0, 0x20, 0xE9,
+
+0x04, 0x80, 0x10, 0xEA,
+0x8C, 0xE2,
+0x95, 0x05,
+
+0x28, 0xC1, 0x28, 0xAD,
+0x1F, 0xC1, 0x15, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA8, 0x67,
+0x9F, 0x6B,
+0x00, 0x80, 0x00, 0xE8,
+
+0x28, 0xC0, 0x28, 0xAD,
+0x1D, 0x25,
+0x20, 0x05,
+
+0x28, 0x32, 0x80, 0xAD,
+0x40, 0x2A, 0x40, 0xBD,
+
+0x1C, 0x80, 0x20, 0xE9,
+0x20, 0x33, 0x20, 0xAD,
+
+0x20, 0x73,
+0x00, 0xE0,
+0xB6, 0x49, 0x51, 0xBB,
+
+0x26, 0x2F, 0xB0, 0xE8,
+0x19, 0x20, 0x20, 0xE9,
+
+0x35, 0x20, 0x35, 0xDF,
+0x3D, 0x20, 0x3D, 0xDF,
+
+0x15, 0x20, 0x15, 0xDF,
+0x1D, 0x20, 0x1D, 0xDF,
+
+0x26, 0xD0, 0x26, 0xCD,
+0x29, 0x49, 0x2A, 0xB8,
+
+0x26, 0x40, 0x80, 0xBD,
+0x3B, 0x48, 0x50, 0xBD,
+
+0x3E, 0x54, 0x57, 0x9F,
+0x00, 0xE0,
+0x82, 0xE1,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x26, 0x30,
+0x29, 0x30,
+0x48, 0x3C, 0x48, 0xAD,
+
+0x2B, 0x72,
+0xC2, 0xE1,
+0x2C, 0xC0, 0x44, 0xC2,
+
+0x05, 0x24, 0x34, 0xBF,
+0x0D, 0x24, 0x2C, 0xBF,
+
+0x2D, 0x46, 0x4E, 0xBF,
+0x25, 0x46, 0x56, 0xBF,
+
+0x20, 0x1D, 0x6F, 0x8F,
+0x32, 0x3E, 0x5F, 0xE9,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x30,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x33, 0x1E, 0x5F, 0xE9,
+
+0x05, 0x44, 0x54, 0xB2,
+0x0D, 0x44, 0x4C, 0xB2,
+
+0x19, 0xC0, 0xB0, 0xE8,
+0x34, 0xC0, 0x44, 0xC4,
+
+0x33, 0x73,
+0x00, 0xE0,
+0x3E, 0x62, 0x57, 0x9F,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0xE0,
+0x0D, 0x20,
+
+0x84, 0x3E, 0x58, 0xE9,
+0x28, 0x1D, 0x6F, 0x8F,
+
+0x05, 0x20,
+0x00, 0xE0,
+0x85, 0x1E, 0x58, 0xE9,
+
+0x9B, 0x3B, 0x33, 0xDF,
+0x20, 0x20, 0x42, 0xAF,
+
+0x30, 0x42, 0x56, 0x9F,
+0x80, 0x3E, 0x57, 0xE9,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x30, 0x80, 0x5F, 0xE9,
+
+0x28, 0x28, 0x24, 0xAF,
+0x81, 0x1E, 0x57, 0xE9,
+
+0x05, 0x47, 0x57, 0xBF,
+0x0D, 0x47, 0x4F, 0xBF,
+
+0x88, 0x80, 0x58, 0xE9,
+0x1B, 0x29, 0x1B, 0xDF,
+
+0x30, 0x1D, 0x6F, 0x8F,
+0x3A, 0x30, 0x4F, 0xE9,
+
+0x1C, 0x30, 0x26, 0xDF,
+0x09, 0xE3,
+0x3B, 0x05,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x3B, 0x3F, 0x4F, 0xE9,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x00, 0xE0,
+0xAC, 0x20,
+
+0x2D, 0x44, 0x4C, 0xB4,
+0x2C, 0x1C, 0xC0, 0xAF,
+
+0x25, 0x44, 0x54, 0xB4,
+0x00, 0xE0,
+0xC8, 0x30,
+
+0x30, 0x46, 0x30, 0xAF,
+0x1B, 0x1B, 0x48, 0xAF,
+
+0x00, 0xE0,
+0x25, 0x20,
+0x38, 0x2C, 0x4F, 0xE9,
+
+0x86, 0x80, 0x57, 0xE9,
+0x38, 0x1D, 0x6F, 0x8F,
+
+0x28, 0x74,
+0x00, 0xE0,
+0x0D, 0x44, 0x4C, 0xB0,
+
+0x05, 0x44, 0x54, 0xB0,
+0x2D, 0x20,
+0x9B, 0x10,
+
+0x82, 0x3E, 0x57, 0xE9,
+0x32, 0xF0, 0x1B, 0xCD,
+
+0x1E, 0xBD, 0x59, 0x9F,
+0x83, 0x1E, 0x57, 0xE9,
+
+0x38, 0x47, 0x38, 0xAF,
+0x34, 0x20,
+0x2A, 0x30,
+
+0x00, 0xE0,
+0x0D, 0x20,
+0x32, 0x20,
+0x05, 0x20,
+
+0x87, 0x80, 0x57, 0xE9,
+0x1F, 0x54, 0x57, 0x9F,
+
+0x17, 0x42, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x6A,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x37, 0x1E, 0x4F, 0xE9,
+
+0x37, 0x32, 0x2A, 0xAF,
+0x00, 0xE0,
+0x32, 0x00,
+
+0x00, 0x80, 0x00, 0xE8,
+0x27, 0xC0, 0x44, 0xC0,
+
+0x36, 0x1F, 0x4F, 0xE9,
+0x1F, 0x1F, 0x26, 0xDF,
+
+0x37, 0x1B, 0x37, 0xBF,
+0x17, 0x26, 0x17, 0xDF,
+
+0x3E, 0x17, 0x4F, 0xE9,
+0x3F, 0x3F, 0x4F, 0xE9,
+
+0x34, 0x1F, 0x34, 0xAF,
+0x2B, 0x05,
+0xA7, 0x20,
+
+0x33, 0x2B, 0x37, 0xDF,
+0x27, 0x17, 0xC0, 0xAF,
+
+0x34, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x0D, 0x21, 0x1A, 0xB6,
+0x05, 0x21, 0x31, 0xB6,
+
+0x2D, 0x44, 0x4C, 0xB6,
+0x25, 0x44, 0x54, 0xB6,
+
+0x03, 0x80, 0x2A, 0xEA,
+0x17, 0xC1, 0x2B, 0xBD,
+
+0x0D, 0x20,
+0x05, 0x20,
+0x2F, 0xC0, 0x21, 0xC6,
+
+0xB3, 0x68,
+0x97, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0xC0, 0x33, 0xAF,
+0x3C, 0x27, 0x4F, 0xE9,
+
+0x00, 0xE0,
+0x25, 0x20,
+0x07, 0xC0, 0x44, 0xC6,
+
+0x17, 0x50, 0x56, 0x9F,
+0x00, 0xE0,
+0x2D, 0x20,
+
+0x37, 0x0F, 0x5C, 0x9F,
+0x00, 0xE0,
+0x2F, 0x20,
+
+0x1F, 0x62, 0x57, 0x9F,
+0x00, 0xE0,
+0x07, 0x20,
+
+0x3F, 0x3D, 0x5D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x28, 0x19, 0x60, 0xEC,
+
+0xB3, 0x05,
+0x00, 0xE0,
+0x17, 0x26, 0x17, 0xDF,
+
+0x23, 0x3B, 0x33, 0xAD,
+0x35, 0x17, 0x4F, 0xE9,
+
+0x1F, 0x26, 0x1F, 0xDF,
+0x9D, 0x1F, 0x4F, 0xE9,
+
+0x9E, 0x3F, 0x4F, 0xE9,
+0x39, 0x37, 0x4F, 0xE9,
+
+0x2F, 0x2F, 0x17, 0xAF,
+0x00, 0x80, 0x00, 0xE8,
+
+0x07, 0x07, 0x1F, 0xAF,
+0x00, 0x80, 0x00, 0xE8,
+
+0x31, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x9C, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x57, 0x39, 0x20, 0xE9,
+
+0x16, 0x28, 0x20, 0xE9,
+0x1D, 0x3B, 0x20, 0xE9,
+
+0x1E, 0x2B, 0x20, 0xE9,
+0x2B, 0x32, 0x20, 0xE9,
+
+0x1C, 0x23, 0x20, 0xE9,
+0x57, 0x36, 0x20, 0xE9,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x90, 0xE2,
+0x00, 0xE0,
+
+0x74, 0xFF, 0x20, 0xEA,
+0x19, 0xC8, 0xC1, 0xCD,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x9F, 0x41, 0x49, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x41, 0x49, 0xBD,
+0x2D, 0x41, 0x51, 0xBD,
+
+0x0D, 0x80, 0x07, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x35, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x25, 0x30,
+0x2D, 0x30,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0xA7, 0x5B, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x73, 0xFF, 0x0A, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC9, 0x41, 0xC8, 0xEC,
+0x42, 0xE1,
+0x00, 0xE0,
+
+0x71, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC8, 0x40, 0xC0, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x6E, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+};
+unsigned char WARP_G200_tgzf[] = {
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x98, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x81, 0x04,
+0x89, 0x04,
+0x01, 0x04,
+0x09, 0x04,
+
+0xC9, 0x41, 0xC0, 0xEC,
+0x11, 0x04,
+0x00, 0xE0,
+
+0x41, 0xCC, 0x41, 0xCD,
+0x49, 0xCC, 0x49, 0xCD,
+
+0xD1, 0x41, 0xC0, 0xEC,
+0x51, 0xCC, 0x51, 0xCD,
+
+0x80, 0x04,
+0x10, 0x04,
+0x08, 0x04,
+0x00, 0xE0,
+
+0x00, 0xCC, 0xC0, 0xCD,
+0xD1, 0x49, 0xC0, 0xEC,
+
+0x8A, 0x1F, 0x20, 0xE9,
+0x8B, 0x3F, 0x20, 0xE9,
+
+0x41, 0x3C, 0x41, 0xAD,
+0x49, 0x3C, 0x49, 0xAD,
+
+0x10, 0xCC, 0x10, 0xCD,
+0x08, 0xCC, 0x08, 0xCD,
+
+0xB9, 0x41, 0x49, 0xBB,
+0x1F, 0xF0, 0x41, 0xCD,
+
+0x51, 0x3C, 0x51, 0xAD,
+0x00, 0x98, 0x80, 0xE9,
+
+0x7F, 0x80, 0x07, 0xEA,
+0x24, 0x1F, 0x20, 0xE9,
+
+0x21, 0x45, 0x80, 0xE8,
+0x1A, 0x4D, 0x80, 0xE8,
+
+0x31, 0x55, 0x80, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0x41, 0x49, 0xBD,
+0x1D, 0x41, 0x51, 0xBD,
+
+0x2E, 0x41, 0x2A, 0xB8,
+0x34, 0x53, 0xA0, 0xE8,
+
+0x15, 0x30,
+0x1D, 0x30,
+0x58, 0xE3,
+0x00, 0xE0,
+
+0xB5, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x24, 0x43, 0xA0, 0xE8,
+0x2C, 0x4B, 0xA0, 0xE8,
+
+0x15, 0x72,
+0x09, 0xE3,
+0x00, 0xE0,
+0x1D, 0x72,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0x97, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x6C, 0x64, 0xC8, 0xEC,
+0x98, 0xE1,
+0xB5, 0x05,
+
+0xBD, 0x05,
+0x2E, 0x30,
+0x32, 0xC0, 0xA0, 0xE8,
+
+0x33, 0xC0, 0xA0, 0xE8,
+0x74, 0x64, 0xC8, 0xEC,
+
+0x40, 0x3C, 0x40, 0xAD,
+0x32, 0x6A,
+0x2A, 0x30,
+
+0x20, 0x73,
+0x33, 0x6A,
+0x00, 0xE0,
+0x28, 0x73,
+
+0x1C, 0x72,
+0x83, 0xE2,
+0x6B, 0x80, 0x15, 0xEA,
+
+0xB8, 0x3D, 0x28, 0xDF,
+0x30, 0x35, 0x20, 0xDF,
+
+0x40, 0x30,
+0x00, 0xE0,
+0xCC, 0xE2,
+0x64, 0x72,
+
+0x25, 0x42, 0x52, 0xBF,
+0x2D, 0x42, 0x4A, 0xBF,
+
+0x30, 0x2E, 0x30, 0xDF,
+0x38, 0x2E, 0x38, 0xDF,
+
+0x18, 0x1D, 0x45, 0xE9,
+0x1E, 0x15, 0x45, 0xE9,
+
+0x2B, 0x49, 0x51, 0xBD,
+0x00, 0xE0,
+0x1F, 0x73,
+
+0x38, 0x38, 0x40, 0xAF,
+0x30, 0x30, 0x40, 0xAF,
+
+0x24, 0x1F, 0x24, 0xDF,
+0x1D, 0x32, 0x20, 0xE9,
+
+0x2C, 0x1F, 0x2C, 0xDF,
+0x1A, 0x33, 0x20, 0xE9,
+
+0xB0, 0x10,
+0x08, 0xE3,
+0x40, 0x10,
+0xB8, 0x10,
+
+0x26, 0xF0, 0x30, 0xCD,
+0x2F, 0xF0, 0x38, 0xCD,
+
+0x2B, 0x80, 0x20, 0xE9,
+0x2A, 0x80, 0x20, 0xE9,
+
+0xA6, 0x20,
+0x88, 0xE2,
+0x00, 0xE0,
+0xAF, 0x20,
+
+0x28, 0x2A, 0x26, 0xAF,
+0x20, 0x2A, 0xC0, 0xAF,
+
+0x34, 0x1F, 0x34, 0xDF,
+0x46, 0x24, 0x46, 0xDF,
+
+0x28, 0x30, 0x80, 0xBF,
+0x20, 0x38, 0x80, 0xBF,
+
+0x47, 0x24, 0x47, 0xDF,
+0x4E, 0x2C, 0x4E, 0xDF,
+
+0x4F, 0x2C, 0x4F, 0xDF,
+0x56, 0x34, 0x56, 0xDF,
+
+0x28, 0x15, 0x28, 0xDF,
+0x20, 0x1D, 0x20, 0xDF,
+
+0x57, 0x34, 0x57, 0xDF,
+0x00, 0xE0,
+0x1D, 0x05,
+
+0x04, 0x80, 0x10, 0xEA,
+0x89, 0xE2,
+0x2B, 0x30,
+
+0x3F, 0xC1, 0x1D, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA0, 0x68,
+0xBF, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x20, 0xC0, 0x20, 0xAF,
+0x28, 0x05,
+0x97, 0x74,
+
+0x00, 0xE0,
+0x2A, 0x10,
+0x16, 0xC0, 0x20, 0xE9,
+
+0x04, 0x80, 0x10, 0xEA,
+0x8C, 0xE2,
+0x95, 0x05,
+
+0x28, 0xC1, 0x28, 0xAD,
+0x1F, 0xC1, 0x15, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA8, 0x67,
+0x9F, 0x6B,
+0x00, 0x80, 0x00, 0xE8,
+
+0x28, 0xC0, 0x28, 0xAD,
+0x1D, 0x25,
+0x20, 0x05,
+
+0x28, 0x32, 0x80, 0xAD,
+0x40, 0x2A, 0x40, 0xBD,
+
+0x1C, 0x80, 0x20, 0xE9,
+0x20, 0x33, 0x20, 0xAD,
+
+0x20, 0x73,
+0x00, 0xE0,
+0xB6, 0x49, 0x51, 0xBB,
+
+0x26, 0x2F, 0xB0, 0xE8,
+0x19, 0x20, 0x20, 0xE9,
+
+0x35, 0x20, 0x35, 0xDF,
+0x3D, 0x20, 0x3D, 0xDF,
+
+0x15, 0x20, 0x15, 0xDF,
+0x1D, 0x20, 0x1D, 0xDF,
+
+0x26, 0xD0, 0x26, 0xCD,
+0x29, 0x49, 0x2A, 0xB8,
+
+0x26, 0x40, 0x80, 0xBD,
+0x3B, 0x48, 0x50, 0xBD,
+
+0x3E, 0x54, 0x57, 0x9F,
+0x00, 0xE0,
+0x82, 0xE1,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x26, 0x30,
+0x29, 0x30,
+0x48, 0x3C, 0x48, 0xAD,
+
+0x2B, 0x72,
+0xC2, 0xE1,
+0x2C, 0xC0, 0x44, 0xC2,
+
+0x05, 0x24, 0x34, 0xBF,
+0x0D, 0x24, 0x2C, 0xBF,
+
+0x2D, 0x46, 0x4E, 0xBF,
+0x25, 0x46, 0x56, 0xBF,
+
+0x20, 0x1D, 0x6F, 0x8F,
+0x32, 0x3E, 0x5F, 0xE9,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x30,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x33, 0x1E, 0x5F, 0xE9,
+
+0x05, 0x44, 0x54, 0xB2,
+0x0D, 0x44, 0x4C, 0xB2,
+
+0x19, 0xC0, 0xB0, 0xE8,
+0x34, 0xC0, 0x44, 0xC4,
+
+0x33, 0x73,
+0x00, 0xE0,
+0x3E, 0x62, 0x57, 0x9F,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0xE0,
+0x0D, 0x20,
+
+0x84, 0x3E, 0x58, 0xE9,
+0x28, 0x1D, 0x6F, 0x8F,
+
+0x05, 0x20,
+0x00, 0xE0,
+0x85, 0x1E, 0x58, 0xE9,
+
+0x9B, 0x3B, 0x33, 0xDF,
+0x20, 0x20, 0x42, 0xAF,
+
+0x30, 0x42, 0x56, 0x9F,
+0x80, 0x3E, 0x57, 0xE9,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x30, 0x80, 0x5F, 0xE9,
+
+0x28, 0x28, 0x24, 0xAF,
+0x81, 0x1E, 0x57, 0xE9,
+
+0x05, 0x47, 0x57, 0xBF,
+0x0D, 0x47, 0x4F, 0xBF,
+
+0x88, 0x80, 0x58, 0xE9,
+0x1B, 0x29, 0x1B, 0xDF,
+
+0x30, 0x1D, 0x6F, 0x8F,
+0x3A, 0x30, 0x4F, 0xE9,
+
+0x1C, 0x30, 0x26, 0xDF,
+0x09, 0xE3,
+0x3B, 0x05,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x3B, 0x3F, 0x4F, 0xE9,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x00, 0xE0,
+0xAC, 0x20,
+
+0x2D, 0x44, 0x4C, 0xB4,
+0x2C, 0x1C, 0xC0, 0xAF,
+
+0x25, 0x44, 0x54, 0xB4,
+0x00, 0xE0,
+0xC8, 0x30,
+
+0x30, 0x46, 0x30, 0xAF,
+0x1B, 0x1B, 0x48, 0xAF,
+
+0x00, 0xE0,
+0x25, 0x20,
+0x38, 0x2C, 0x4F, 0xE9,
+
+0x86, 0x80, 0x57, 0xE9,
+0x38, 0x1D, 0x6F, 0x8F,
+
+0x28, 0x74,
+0x00, 0xE0,
+0x0D, 0x44, 0x4C, 0xB0,
+
+0x05, 0x44, 0x54, 0xB0,
+0x2D, 0x20,
+0x9B, 0x10,
+
+0x82, 0x3E, 0x57, 0xE9,
+0x32, 0xF0, 0x1B, 0xCD,
+
+0x1E, 0xBD, 0x59, 0x9F,
+0x83, 0x1E, 0x57, 0xE9,
+
+0x38, 0x47, 0x38, 0xAF,
+0x34, 0x20,
+0x2A, 0x30,
+
+0x00, 0xE0,
+0x0D, 0x20,
+0x32, 0x20,
+0x05, 0x20,
+
+0x87, 0x80, 0x57, 0xE9,
+0x1F, 0x54, 0x57, 0x9F,
+
+0x17, 0x42, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x6A,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x37, 0x1E, 0x4F, 0xE9,
+
+0x37, 0x32, 0x2A, 0xAF,
+0x00, 0xE0,
+0x32, 0x00,
+
+0x00, 0x80, 0x00, 0xE8,
+0x27, 0xC0, 0x44, 0xC0,
+
+0x36, 0x1F, 0x4F, 0xE9,
+0x1F, 0x1F, 0x26, 0xDF,
+
+0x37, 0x1B, 0x37, 0xBF,
+0x17, 0x26, 0x17, 0xDF,
+
+0x3E, 0x17, 0x4F, 0xE9,
+0x3F, 0x3F, 0x4F, 0xE9,
+
+0x34, 0x1F, 0x34, 0xAF,
+0x2B, 0x05,
+0xA7, 0x20,
+
+0x33, 0x2B, 0x37, 0xDF,
+0x27, 0x17, 0xC0, 0xAF,
+
+0x34, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x0D, 0x21, 0x1A, 0xB6,
+0x05, 0x21, 0x31, 0xB6,
+
+0x03, 0x80, 0x2A, 0xEA,
+0x17, 0xC1, 0x2B, 0xBD,
+
+0x0D, 0x20,
+0x05, 0x20,
+0x2F, 0xC0, 0x21, 0xC6,
+
+0xB3, 0x68,
+0x97, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0xC0, 0x33, 0xAF,
+0x3C, 0x27, 0x4F, 0xE9,
+
+0x17, 0x50, 0x56, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x37, 0x0F, 0x5C, 0x9F,
+0x00, 0xE0,
+0x2F, 0x20,
+
+0x00, 0x80, 0x00, 0xE8,
+0x28, 0x19, 0x60, 0xEC,
+
+0xB3, 0x05,
+0x00, 0xE0,
+0x00, 0x80, 0x00, 0xE8,
+
+0x23, 0x3B, 0x33, 0xAD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x17, 0x26, 0x17, 0xDF,
+0x35, 0x17, 0x4F, 0xE9,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x39, 0x37, 0x4F, 0xE9,
+
+0x2F, 0x2F, 0x17, 0xAF,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x31, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x57, 0x39, 0x20, 0xE9,
+
+0x16, 0x28, 0x20, 0xE9,
+0x1D, 0x3B, 0x20, 0xE9,
+
+0x1E, 0x2B, 0x20, 0xE9,
+0x2B, 0x32, 0x20, 0xE9,
+
+0x1C, 0x23, 0x20, 0xE9,
+0x57, 0x36, 0x20, 0xE9,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x90, 0xE2,
+0x00, 0xE0,
+
+0x78, 0xFF, 0x20, 0xEA,
+0x19, 0xC8, 0xC1, 0xCD,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x9F, 0x41, 0x49, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x41, 0x49, 0xBD,
+0x2D, 0x41, 0x51, 0xBD,
+
+0x0D, 0x80, 0x07, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x35, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x25, 0x30,
+0x2D, 0x30,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0xA7, 0x5B, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x77, 0xFF, 0x0A, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC9, 0x41, 0xC8, 0xEC,
+0x42, 0xE1,
+0x00, 0xE0,
+
+0x75, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC8, 0x40, 0xC0, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x72, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+};
+unsigned char WARP_G200_tgzs[] = {
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x98, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x81, 0x04,
+0x89, 0x04,
+0x01, 0x04,
+0x09, 0x04,
+
+0xC9, 0x41, 0xC0, 0xEC,
+0x11, 0x04,
+0x00, 0xE0,
+
+0x41, 0xCC, 0x41, 0xCD,
+0x49, 0xCC, 0x49, 0xCD,
+
+0xD1, 0x41, 0xC0, 0xEC,
+0x51, 0xCC, 0x51, 0xCD,
+
+0x80, 0x04,
+0x10, 0x04,
+0x08, 0x04,
+0x00, 0xE0,
+
+0x00, 0xCC, 0xC0, 0xCD,
+0xD1, 0x49, 0xC0, 0xEC,
+
+0x8A, 0x1F, 0x20, 0xE9,
+0x8B, 0x3F, 0x20, 0xE9,
+
+0x41, 0x3C, 0x41, 0xAD,
+0x49, 0x3C, 0x49, 0xAD,
+
+0x10, 0xCC, 0x10, 0xCD,
+0x08, 0xCC, 0x08, 0xCD,
+
+0xB9, 0x41, 0x49, 0xBB,
+0x1F, 0xF0, 0x41, 0xCD,
+
+0x51, 0x3C, 0x51, 0xAD,
+0x00, 0x98, 0x80, 0xE9,
+
+0x8B, 0x80, 0x07, 0xEA,
+0x24, 0x1F, 0x20, 0xE9,
+
+0x21, 0x45, 0x80, 0xE8,
+0x1A, 0x4D, 0x80, 0xE8,
+
+0x31, 0x55, 0x80, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0x41, 0x49, 0xBD,
+0x1D, 0x41, 0x51, 0xBD,
+
+0x2E, 0x41, 0x2A, 0xB8,
+0x34, 0x53, 0xA0, 0xE8,
+
+0x15, 0x30,
+0x1D, 0x30,
+0x58, 0xE3,
+0x00, 0xE0,
+
+0xB5, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x24, 0x43, 0xA0, 0xE8,
+0x2C, 0x4B, 0xA0, 0xE8,
+
+0x15, 0x72,
+0x09, 0xE3,
+0x00, 0xE0,
+0x1D, 0x72,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0x97, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x6C, 0x64, 0xC8, 0xEC,
+0x98, 0xE1,
+0xB5, 0x05,
+
+0xBD, 0x05,
+0x2E, 0x30,
+0x32, 0xC0, 0xA0, 0xE8,
+
+0x33, 0xC0, 0xA0, 0xE8,
+0x74, 0x64, 0xC8, 0xEC,
+
+0x40, 0x3C, 0x40, 0xAD,
+0x32, 0x6A,
+0x2A, 0x30,
+
+0x20, 0x73,
+0x33, 0x6A,
+0x00, 0xE0,
+0x28, 0x73,
+
+0x1C, 0x72,
+0x83, 0xE2,
+0x77, 0x80, 0x15, 0xEA,
+
+0xB8, 0x3D, 0x28, 0xDF,
+0x30, 0x35, 0x20, 0xDF,
+
+0x40, 0x30,
+0x00, 0xE0,
+0xCC, 0xE2,
+0x64, 0x72,
+
+0x25, 0x42, 0x52, 0xBF,
+0x2D, 0x42, 0x4A, 0xBF,
+
+0x30, 0x2E, 0x30, 0xDF,
+0x38, 0x2E, 0x38, 0xDF,
+
+0x18, 0x1D, 0x45, 0xE9,
+0x1E, 0x15, 0x45, 0xE9,
+
+0x2B, 0x49, 0x51, 0xBD,
+0x00, 0xE0,
+0x1F, 0x73,
+
+0x38, 0x38, 0x40, 0xAF,
+0x30, 0x30, 0x40, 0xAF,
+
+0x24, 0x1F, 0x24, 0xDF,
+0x1D, 0x32, 0x20, 0xE9,
+
+0x2C, 0x1F, 0x2C, 0xDF,
+0x1A, 0x33, 0x20, 0xE9,
+
+0xB0, 0x10,
+0x08, 0xE3,
+0x40, 0x10,
+0xB8, 0x10,
+
+0x26, 0xF0, 0x30, 0xCD,
+0x2F, 0xF0, 0x38, 0xCD,
+
+0x2B, 0x80, 0x20, 0xE9,
+0x2A, 0x80, 0x20, 0xE9,
+
+0xA6, 0x20,
+0x88, 0xE2,
+0x00, 0xE0,
+0xAF, 0x20,
+
+0x28, 0x2A, 0x26, 0xAF,
+0x20, 0x2A, 0xC0, 0xAF,
+
+0x34, 0x1F, 0x34, 0xDF,
+0x46, 0x24, 0x46, 0xDF,
+
+0x28, 0x30, 0x80, 0xBF,
+0x20, 0x38, 0x80, 0xBF,
+
+0x47, 0x24, 0x47, 0xDF,
+0x4E, 0x2C, 0x4E, 0xDF,
+
+0x4F, 0x2C, 0x4F, 0xDF,
+0x56, 0x34, 0x56, 0xDF,
+
+0x28, 0x15, 0x28, 0xDF,
+0x20, 0x1D, 0x20, 0xDF,
+
+0x57, 0x34, 0x57, 0xDF,
+0x00, 0xE0,
+0x1D, 0x05,
+
+0x04, 0x80, 0x10, 0xEA,
+0x89, 0xE2,
+0x2B, 0x30,
+
+0x3F, 0xC1, 0x1D, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA0, 0x68,
+0xBF, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x20, 0xC0, 0x20, 0xAF,
+0x28, 0x05,
+0x97, 0x74,
+
+0x00, 0xE0,
+0x2A, 0x10,
+0x16, 0xC0, 0x20, 0xE9,
+
+0x04, 0x80, 0x10, 0xEA,
+0x8C, 0xE2,
+0x95, 0x05,
+
+0x28, 0xC1, 0x28, 0xAD,
+0x1F, 0xC1, 0x15, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA8, 0x67,
+0x9F, 0x6B,
+0x00, 0x80, 0x00, 0xE8,
+
+0x28, 0xC0, 0x28, 0xAD,
+0x1D, 0x25,
+0x20, 0x05,
+
+0x28, 0x32, 0x80, 0xAD,
+0x40, 0x2A, 0x40, 0xBD,
+
+0x1C, 0x80, 0x20, 0xE9,
+0x20, 0x33, 0x20, 0xAD,
+
+0x20, 0x73,
+0x00, 0xE0,
+0xB6, 0x49, 0x51, 0xBB,
+
+0x26, 0x2F, 0xB0, 0xE8,
+0x19, 0x20, 0x20, 0xE9,
+
+0x35, 0x20, 0x35, 0xDF,
+0x3D, 0x20, 0x3D, 0xDF,
+
+0x15, 0x20, 0x15, 0xDF,
+0x1D, 0x20, 0x1D, 0xDF,
+
+0x26, 0xD0, 0x26, 0xCD,
+0x29, 0x49, 0x2A, 0xB8,
+
+0x26, 0x40, 0x80, 0xBD,
+0x3B, 0x48, 0x50, 0xBD,
+
+0x3E, 0x54, 0x57, 0x9F,
+0x00, 0xE0,
+0x82, 0xE1,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x26, 0x30,
+0x29, 0x30,
+0x48, 0x3C, 0x48, 0xAD,
+
+0x2B, 0x72,
+0xC2, 0xE1,
+0x2C, 0xC0, 0x44, 0xC2,
+
+0x05, 0x24, 0x34, 0xBF,
+0x0D, 0x24, 0x2C, 0xBF,
+
+0x2D, 0x46, 0x4E, 0xBF,
+0x25, 0x46, 0x56, 0xBF,
+
+0x20, 0x1D, 0x6F, 0x8F,
+0x32, 0x3E, 0x5F, 0xE9,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x30,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x33, 0x1E, 0x5F, 0xE9,
+
+0x05, 0x44, 0x54, 0xB2,
+0x0D, 0x44, 0x4C, 0xB2,
+
+0x19, 0xC0, 0xB0, 0xE8,
+0x34, 0xC0, 0x44, 0xC4,
+
+0x33, 0x73,
+0x00, 0xE0,
+0x3E, 0x62, 0x57, 0x9F,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0xE0,
+0x0D, 0x20,
+
+0x84, 0x3E, 0x58, 0xE9,
+0x28, 0x1D, 0x6F, 0x8F,
+
+0x05, 0x20,
+0x00, 0xE0,
+0x85, 0x1E, 0x58, 0xE9,
+
+0x9B, 0x3B, 0x33, 0xDF,
+0x20, 0x20, 0x42, 0xAF,
+
+0x30, 0x42, 0x56, 0x9F,
+0x80, 0x3E, 0x57, 0xE9,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x30, 0x80, 0x5F, 0xE9,
+
+0x28, 0x28, 0x24, 0xAF,
+0x81, 0x1E, 0x57, 0xE9,
+
+0x05, 0x47, 0x57, 0xBF,
+0x0D, 0x47, 0x4F, 0xBF,
+
+0x88, 0x80, 0x58, 0xE9,
+0x1B, 0x29, 0x1B, 0xDF,
+
+0x30, 0x1D, 0x6F, 0x8F,
+0x3A, 0x30, 0x4F, 0xE9,
+
+0x1C, 0x30, 0x26, 0xDF,
+0x09, 0xE3,
+0x3B, 0x05,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x3B, 0x3F, 0x4F, 0xE9,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x00, 0xE0,
+0xAC, 0x20,
+
+0x2D, 0x44, 0x4C, 0xB4,
+0x2C, 0x1C, 0xC0, 0xAF,
+
+0x25, 0x44, 0x54, 0xB4,
+0x00, 0xE0,
+0xC8, 0x30,
+
+0x30, 0x46, 0x30, 0xAF,
+0x1B, 0x1B, 0x48, 0xAF,
+
+0x00, 0xE0,
+0x25, 0x20,
+0x38, 0x2C, 0x4F, 0xE9,
+
+0x86, 0x80, 0x57, 0xE9,
+0x38, 0x1D, 0x6F, 0x8F,
+
+0x28, 0x74,
+0x00, 0xE0,
+0x0D, 0x44, 0x4C, 0xB0,
+
+0x05, 0x44, 0x54, 0xB0,
+0x2D, 0x20,
+0x9B, 0x10,
+
+0x82, 0x3E, 0x57, 0xE9,
+0x32, 0xF0, 0x1B, 0xCD,
+
+0x1E, 0xBD, 0x59, 0x9F,
+0x83, 0x1E, 0x57, 0xE9,
+
+0x38, 0x47, 0x38, 0xAF,
+0x34, 0x20,
+0x2A, 0x30,
+
+0x00, 0xE0,
+0x0D, 0x20,
+0x32, 0x20,
+0x05, 0x20,
+
+0x87, 0x80, 0x57, 0xE9,
+0x1F, 0x54, 0x57, 0x9F,
+
+0x17, 0x42, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x6A,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x37, 0x1E, 0x4F, 0xE9,
+
+0x37, 0x32, 0x2A, 0xAF,
+0x00, 0xE0,
+0x32, 0x00,
+
+0x00, 0x80, 0x00, 0xE8,
+0x27, 0xC0, 0x44, 0xC0,
+
+0x36, 0x1F, 0x4F, 0xE9,
+0x1F, 0x1F, 0x26, 0xDF,
+
+0x37, 0x1B, 0x37, 0xBF,
+0x17, 0x26, 0x17, 0xDF,
+
+0x3E, 0x17, 0x4F, 0xE9,
+0x3F, 0x3F, 0x4F, 0xE9,
+
+0x34, 0x1F, 0x34, 0xAF,
+0x2B, 0x05,
+0xA7, 0x20,
+
+0x33, 0x2B, 0x37, 0xDF,
+0x27, 0x17, 0xC0, 0xAF,
+
+0x34, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x2D, 0x21, 0x1A, 0xB0,
+0x25, 0x21, 0x31, 0xB0,
+
+0x0D, 0x21, 0x1A, 0xB2,
+0x05, 0x21, 0x31, 0xB2,
+
+0x03, 0x80, 0x2A, 0xEA,
+0x17, 0xC1, 0x2B, 0xBD,
+
+0x2D, 0x20,
+0x25, 0x20,
+0x05, 0x20,
+0x0D, 0x20,
+
+0xB3, 0x68,
+0x97, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0xC0, 0x33, 0xAF,
+0x2F, 0xC0, 0x21, 0xC0,
+
+0x16, 0x42, 0x56, 0x9F,
+0x3C, 0x27, 0x4F, 0xE9,
+
+0x1E, 0x62, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x21, 0x31, 0xB4,
+0x2D, 0x21, 0x1A, 0xB4,
+
+0x3F, 0x2F, 0x5D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0x05,
+0x00, 0xE0,
+0x28, 0x19, 0x60, 0xEC,
+
+0x37, 0x0F, 0x5C, 0x9F,
+0x00, 0xE0,
+0x2F, 0x20,
+
+0x23, 0x3B, 0x33, 0xAD,
+0x1E, 0x26, 0x1E, 0xDF,
+
+0xA7, 0x1E, 0x4F, 0xE9,
+0x17, 0x26, 0x16, 0xDF,
+
+0x2D, 0x20,
+0x00, 0xE0,
+0xA8, 0x3F, 0x4F, 0xE9,
+
+0x2F, 0x2F, 0x1E, 0xAF,
+0x25, 0x20,
+0x00, 0xE0,
+
+0xA4, 0x16, 0x4F, 0xE9,
+0x0F, 0xC0, 0x21, 0xC2,
+
+0xA6, 0x80, 0x4F, 0xE9,
+0x1F, 0x62, 0x57, 0x9F,
+
+0x3F, 0x2F, 0x5D, 0x9F,
+0x00, 0xE0,
+0x8F, 0x20,
+
+0xA5, 0x37, 0x4F, 0xE9,
+0x0F, 0x17, 0x0F, 0xAF,
+
+0x06, 0xC0, 0x21, 0xC4,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0xA3, 0x80, 0x4F, 0xE9,
+
+0x06, 0x20,
+0x00, 0xE0,
+0x1F, 0x26, 0x1F, 0xDF,
+
+0xA1, 0x1F, 0x4F, 0xE9,
+0xA2, 0x3F, 0x4F, 0xE9,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x06, 0x06, 0x1F, 0xAF,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA0, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x57, 0x39, 0x20, 0xE9,
+
+0x16, 0x28, 0x20, 0xE9,
+0x1D, 0x3B, 0x20, 0xE9,
+
+0x1E, 0x2B, 0x20, 0xE9,
+0x2B, 0x32, 0x20, 0xE9,
+
+0x1C, 0x23, 0x20, 0xE9,
+0x57, 0x36, 0x20, 0xE9,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x90, 0xE2,
+0x00, 0xE0,
+
+0x6C, 0xFF, 0x20, 0xEA,
+0x19, 0xC8, 0xC1, 0xCD,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x9F, 0x41, 0x49, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x41, 0x49, 0xBD,
+0x2D, 0x41, 0x51, 0xBD,
+
+0x0D, 0x80, 0x07, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x35, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x25, 0x30,
+0x2D, 0x30,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0xA7, 0x5B, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x6B, 0xFF, 0x0A, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC9, 0x41, 0xC8, 0xEC,
+0x42, 0xE1,
+0x00, 0xE0,
+
+0x69, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC8, 0x40, 0xC0, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x66, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+};
+unsigned char WARP_G200_tgzsa[] = {
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x98, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x81, 0x04,
+0x89, 0x04,
+0x01, 0x04,
+0x09, 0x04,
+
+0xC9, 0x41, 0xC0, 0xEC,
+0x11, 0x04,
+0x00, 0xE0,
+
+0x41, 0xCC, 0x41, 0xCD,
+0x49, 0xCC, 0x49, 0xCD,
+
+0xD1, 0x41, 0xC0, 0xEC,
+0x51, 0xCC, 0x51, 0xCD,
+
+0x80, 0x04,
+0x10, 0x04,
+0x08, 0x04,
+0x00, 0xE0,
+
+0x00, 0xCC, 0xC0, 0xCD,
+0xD1, 0x49, 0xC0, 0xEC,
+
+0x8A, 0x1F, 0x20, 0xE9,
+0x8B, 0x3F, 0x20, 0xE9,
+
+0x41, 0x3C, 0x41, 0xAD,
+0x49, 0x3C, 0x49, 0xAD,
+
+0x10, 0xCC, 0x10, 0xCD,
+0x08, 0xCC, 0x08, 0xCD,
+
+0xB9, 0x41, 0x49, 0xBB,
+0x1F, 0xF0, 0x41, 0xCD,
+
+0x51, 0x3C, 0x51, 0xAD,
+0x00, 0x98, 0x80, 0xE9,
+
+0x8F, 0x80, 0x07, 0xEA,
+0x24, 0x1F, 0x20, 0xE9,
+
+0x21, 0x45, 0x80, 0xE8,
+0x1A, 0x4D, 0x80, 0xE8,
+
+0x31, 0x55, 0x80, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0x41, 0x49, 0xBD,
+0x1D, 0x41, 0x51, 0xBD,
+
+0x2E, 0x41, 0x2A, 0xB8,
+0x34, 0x53, 0xA0, 0xE8,
+
+0x15, 0x30,
+0x1D, 0x30,
+0x58, 0xE3,
+0x00, 0xE0,
+
+0xB5, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x24, 0x43, 0xA0, 0xE8,
+0x2C, 0x4B, 0xA0, 0xE8,
+
+0x15, 0x72,
+0x09, 0xE3,
+0x00, 0xE0,
+0x1D, 0x72,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0x97, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x6C, 0x64, 0xC8, 0xEC,
+0x98, 0xE1,
+0xB5, 0x05,
+
+0xBD, 0x05,
+0x2E, 0x30,
+0x32, 0xC0, 0xA0, 0xE8,
+
+0x33, 0xC0, 0xA0, 0xE8,
+0x74, 0x64, 0xC8, 0xEC,
+
+0x40, 0x3C, 0x40, 0xAD,
+0x32, 0x6A,
+0x2A, 0x30,
+
+0x20, 0x73,
+0x33, 0x6A,
+0x00, 0xE0,
+0x28, 0x73,
+
+0x1C, 0x72,
+0x83, 0xE2,
+0x7B, 0x80, 0x15, 0xEA,
+
+0xB8, 0x3D, 0x28, 0xDF,
+0x30, 0x35, 0x20, 0xDF,
+
+0x40, 0x30,
+0x00, 0xE0,
+0xCC, 0xE2,
+0x64, 0x72,
+
+0x25, 0x42, 0x52, 0xBF,
+0x2D, 0x42, 0x4A, 0xBF,
+
+0x30, 0x2E, 0x30, 0xDF,
+0x38, 0x2E, 0x38, 0xDF,
+
+0x18, 0x1D, 0x45, 0xE9,
+0x1E, 0x15, 0x45, 0xE9,
+
+0x2B, 0x49, 0x51, 0xBD,
+0x00, 0xE0,
+0x1F, 0x73,
+
+0x38, 0x38, 0x40, 0xAF,
+0x30, 0x30, 0x40, 0xAF,
+
+0x24, 0x1F, 0x24, 0xDF,
+0x1D, 0x32, 0x20, 0xE9,
+
+0x2C, 0x1F, 0x2C, 0xDF,
+0x1A, 0x33, 0x20, 0xE9,
+
+0xB0, 0x10,
+0x08, 0xE3,
+0x40, 0x10,
+0xB8, 0x10,
+
+0x26, 0xF0, 0x30, 0xCD,
+0x2F, 0xF0, 0x38, 0xCD,
+
+0x2B, 0x80, 0x20, 0xE9,
+0x2A, 0x80, 0x20, 0xE9,
+
+0xA6, 0x20,
+0x88, 0xE2,
+0x00, 0xE0,
+0xAF, 0x20,
+
+0x28, 0x2A, 0x26, 0xAF,
+0x20, 0x2A, 0xC0, 0xAF,
+
+0x34, 0x1F, 0x34, 0xDF,
+0x46, 0x24, 0x46, 0xDF,
+
+0x28, 0x30, 0x80, 0xBF,
+0x20, 0x38, 0x80, 0xBF,
+
+0x47, 0x24, 0x47, 0xDF,
+0x4E, 0x2C, 0x4E, 0xDF,
+
+0x4F, 0x2C, 0x4F, 0xDF,
+0x56, 0x34, 0x56, 0xDF,
+
+0x28, 0x15, 0x28, 0xDF,
+0x20, 0x1D, 0x20, 0xDF,
+
+0x57, 0x34, 0x57, 0xDF,
+0x00, 0xE0,
+0x1D, 0x05,
+
+0x04, 0x80, 0x10, 0xEA,
+0x89, 0xE2,
+0x2B, 0x30,
+
+0x3F, 0xC1, 0x1D, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA0, 0x68,
+0xBF, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x20, 0xC0, 0x20, 0xAF,
+0x28, 0x05,
+0x97, 0x74,
+
+0x00, 0xE0,
+0x2A, 0x10,
+0x16, 0xC0, 0x20, 0xE9,
+
+0x04, 0x80, 0x10, 0xEA,
+0x8C, 0xE2,
+0x95, 0x05,
+
+0x28, 0xC1, 0x28, 0xAD,
+0x1F, 0xC1, 0x15, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA8, 0x67,
+0x9F, 0x6B,
+0x00, 0x80, 0x00, 0xE8,
+
+0x28, 0xC0, 0x28, 0xAD,
+0x1D, 0x25,
+0x20, 0x05,
+
+0x28, 0x32, 0x80, 0xAD,
+0x40, 0x2A, 0x40, 0xBD,
+
+0x1C, 0x80, 0x20, 0xE9,
+0x20, 0x33, 0x20, 0xAD,
+
+0x20, 0x73,
+0x00, 0xE0,
+0xB6, 0x49, 0x51, 0xBB,
+
+0x26, 0x2F, 0xB0, 0xE8,
+0x19, 0x20, 0x20, 0xE9,
+
+0x35, 0x20, 0x35, 0xDF,
+0x3D, 0x20, 0x3D, 0xDF,
+
+0x15, 0x20, 0x15, 0xDF,
+0x1D, 0x20, 0x1D, 0xDF,
+
+0x26, 0xD0, 0x26, 0xCD,
+0x29, 0x49, 0x2A, 0xB8,
+
+0x26, 0x40, 0x80, 0xBD,
+0x3B, 0x48, 0x50, 0xBD,
+
+0x3E, 0x54, 0x57, 0x9F,
+0x00, 0xE0,
+0x82, 0xE1,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x26, 0x30,
+0x29, 0x30,
+0x48, 0x3C, 0x48, 0xAD,
+
+0x2B, 0x72,
+0xC2, 0xE1,
+0x2C, 0xC0, 0x44, 0xC2,
+
+0x05, 0x24, 0x34, 0xBF,
+0x0D, 0x24, 0x2C, 0xBF,
+
+0x2D, 0x46, 0x4E, 0xBF,
+0x25, 0x46, 0x56, 0xBF,
+
+0x20, 0x1D, 0x6F, 0x8F,
+0x32, 0x3E, 0x5F, 0xE9,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x30,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x33, 0x1E, 0x5F, 0xE9,
+
+0x05, 0x44, 0x54, 0xB2,
+0x0D, 0x44, 0x4C, 0xB2,
+
+0x19, 0xC0, 0xB0, 0xE8,
+0x34, 0xC0, 0x44, 0xC4,
+
+0x33, 0x73,
+0x00, 0xE0,
+0x3E, 0x62, 0x57, 0x9F,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0xE0,
+0x0D, 0x20,
+
+0x84, 0x3E, 0x58, 0xE9,
+0x28, 0x1D, 0x6F, 0x8F,
+
+0x05, 0x20,
+0x00, 0xE0,
+0x85, 0x1E, 0x58, 0xE9,
+
+0x9B, 0x3B, 0x33, 0xDF,
+0x20, 0x20, 0x42, 0xAF,
+
+0x30, 0x42, 0x56, 0x9F,
+0x80, 0x3E, 0x57, 0xE9,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x30, 0x80, 0x5F, 0xE9,
+
+0x28, 0x28, 0x24, 0xAF,
+0x81, 0x1E, 0x57, 0xE9,
+
+0x05, 0x47, 0x57, 0xBF,
+0x0D, 0x47, 0x4F, 0xBF,
+
+0x88, 0x80, 0x58, 0xE9,
+0x1B, 0x29, 0x1B, 0xDF,
+
+0x30, 0x1D, 0x6F, 0x8F,
+0x3A, 0x30, 0x4F, 0xE9,
+
+0x1C, 0x30, 0x26, 0xDF,
+0x09, 0xE3,
+0x3B, 0x05,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x3B, 0x3F, 0x4F, 0xE9,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x00, 0xE0,
+0xAC, 0x20,
+
+0x2D, 0x44, 0x4C, 0xB4,
+0x2C, 0x1C, 0xC0, 0xAF,
+
+0x25, 0x44, 0x54, 0xB4,
+0x00, 0xE0,
+0xC8, 0x30,
+
+0x30, 0x46, 0x30, 0xAF,
+0x1B, 0x1B, 0x48, 0xAF,
+
+0x00, 0xE0,
+0x25, 0x20,
+0x38, 0x2C, 0x4F, 0xE9,
+
+0x86, 0x80, 0x57, 0xE9,
+0x38, 0x1D, 0x6F, 0x8F,
+
+0x28, 0x74,
+0x00, 0xE0,
+0x0D, 0x44, 0x4C, 0xB0,
+
+0x05, 0x44, 0x54, 0xB0,
+0x2D, 0x20,
+0x9B, 0x10,
+
+0x82, 0x3E, 0x57, 0xE9,
+0x32, 0xF0, 0x1B, 0xCD,
+
+0x1E, 0xBD, 0x59, 0x9F,
+0x83, 0x1E, 0x57, 0xE9,
+
+0x38, 0x47, 0x38, 0xAF,
+0x34, 0x20,
+0x2A, 0x30,
+
+0x00, 0xE0,
+0x0D, 0x20,
+0x32, 0x20,
+0x05, 0x20,
+
+0x87, 0x80, 0x57, 0xE9,
+0x1F, 0x54, 0x57, 0x9F,
+
+0x17, 0x42, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x6A,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x37, 0x1E, 0x4F, 0xE9,
+
+0x37, 0x32, 0x2A, 0xAF,
+0x00, 0xE0,
+0x32, 0x00,
+
+0x00, 0x80, 0x00, 0xE8,
+0x27, 0xC0, 0x44, 0xC0,
+
+0x36, 0x1F, 0x4F, 0xE9,
+0x1F, 0x1F, 0x26, 0xDF,
+
+0x37, 0x1B, 0x37, 0xBF,
+0x17, 0x26, 0x17, 0xDF,
+
+0x3E, 0x17, 0x4F, 0xE9,
+0x3F, 0x3F, 0x4F, 0xE9,
+
+0x34, 0x1F, 0x34, 0xAF,
+0x2B, 0x05,
+0xA7, 0x20,
+
+0x33, 0x2B, 0x37, 0xDF,
+0x27, 0x17, 0xC0, 0xAF,
+
+0x34, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x2D, 0x21, 0x1A, 0xB0,
+0x25, 0x21, 0x31, 0xB0,
+
+0x0D, 0x21, 0x1A, 0xB2,
+0x05, 0x21, 0x31, 0xB2,
+
+0x03, 0x80, 0x2A, 0xEA,
+0x17, 0xC1, 0x2B, 0xBD,
+
+0x2D, 0x20,
+0x25, 0x20,
+0x05, 0x20,
+0x0D, 0x20,
+
+0xB3, 0x68,
+0x97, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0xC0, 0x33, 0xAF,
+0x2F, 0xC0, 0x21, 0xC0,
+
+0x16, 0x42, 0x56, 0x9F,
+0x3C, 0x27, 0x4F, 0xE9,
+
+0x1E, 0x62, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x21, 0x31, 0xB4,
+0x2D, 0x21, 0x1A, 0xB4,
+
+0x3F, 0x2F, 0x5D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0x05,
+0x00, 0xE0,
+0x28, 0x19, 0x60, 0xEC,
+
+0x0D, 0x44, 0x4C, 0xB6,
+0x05, 0x44, 0x54, 0xB6,
+
+0x37, 0x0F, 0x5C, 0x9F,
+0x00, 0xE0,
+0x2F, 0x20,
+
+0x23, 0x3B, 0x33, 0xAD,
+0x1E, 0x26, 0x1E, 0xDF,
+
+0xA7, 0x1E, 0x4F, 0xE9,
+0x17, 0x26, 0x16, 0xDF,
+
+0x2D, 0x20,
+0x00, 0xE0,
+0xA8, 0x3F, 0x4F, 0xE9,
+
+0x2F, 0x2F, 0x1E, 0xAF,
+0x25, 0x20,
+0x00, 0xE0,
+
+0xA4, 0x16, 0x4F, 0xE9,
+0x0F, 0xC0, 0x21, 0xC2,
+
+0xA6, 0x80, 0x4F, 0xE9,
+0x1F, 0x62, 0x57, 0x9F,
+
+0x0D, 0x20,
+0x05, 0x20,
+0x00, 0x80, 0x00, 0xE8,
+
+0x3F, 0x2F, 0x5D, 0x9F,
+0x00, 0xE0,
+0x0F, 0x20,
+
+0x17, 0x50, 0x56, 0x9F,
+0xA5, 0x37, 0x4F, 0xE9,
+
+0x06, 0xC0, 0x21, 0xC4,
+0x0F, 0x17, 0x0F, 0xAF,
+
+0x37, 0x0F, 0x5C, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x2F, 0xC0, 0x44, 0xC6,
+0xA3, 0x80, 0x4F, 0xE9,
+
+0x06, 0x20,
+0x00, 0xE0,
+0x1F, 0x26, 0x1F, 0xDF,
+
+0x17, 0x26, 0x17, 0xDF,
+0x9D, 0x17, 0x4F, 0xE9,
+
+0xA1, 0x1F, 0x4F, 0xE9,
+0xA2, 0x3F, 0x4F, 0xE9,
+
+0x06, 0x06, 0x1F, 0xAF,
+0x00, 0xE0,
+0xAF, 0x20,
+
+0x9E, 0x37, 0x4F, 0xE9,
+0x2F, 0x17, 0x2F, 0xAF,
+
+0xA0, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x9C, 0x80, 0x4F, 0xE9,
+
+0x00, 0x80, 0x00, 0xE8,
+0x57, 0x39, 0x20, 0xE9,
+
+0x16, 0x28, 0x20, 0xE9,
+0x1D, 0x3B, 0x20, 0xE9,
+
+0x1E, 0x2B, 0x20, 0xE9,
+0x2B, 0x32, 0x20, 0xE9,
+
+0x1C, 0x23, 0x20, 0xE9,
+0x57, 0x36, 0x20, 0xE9,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x90, 0xE2,
+0x00, 0xE0,
+
+0x68, 0xFF, 0x20, 0xEA,
+0x19, 0xC8, 0xC1, 0xCD,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x9F, 0x41, 0x49, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x41, 0x49, 0xBD,
+0x2D, 0x41, 0x51, 0xBD,
+
+0x0D, 0x80, 0x07, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x35, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x25, 0x30,
+0x2D, 0x30,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0xA7, 0x5B, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x67, 0xFF, 0x0A, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC9, 0x41, 0xC8, 0xEC,
+0x42, 0xE1,
+0x00, 0xE0,
+
+0x65, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC8, 0x40, 0xC0, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x62, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+};
+unsigned char WARP_G200_tgzsaf[] = {
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x98, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x81, 0x04,
+0x89, 0x04,
+0x01, 0x04,
+0x09, 0x04,
+
+0xC9, 0x41, 0xC0, 0xEC,
+0x11, 0x04,
+0x00, 0xE0,
+
+0x41, 0xCC, 0x41, 0xCD,
+0x49, 0xCC, 0x49, 0xCD,
+
+0xD1, 0x41, 0xC0, 0xEC,
+0x51, 0xCC, 0x51, 0xCD,
+
+0x80, 0x04,
+0x10, 0x04,
+0x08, 0x04,
+0x00, 0xE0,
+
+0x00, 0xCC, 0xC0, 0xCD,
+0xD1, 0x49, 0xC0, 0xEC,
+
+0x8A, 0x1F, 0x20, 0xE9,
+0x8B, 0x3F, 0x20, 0xE9,
+
+0x41, 0x3C, 0x41, 0xAD,
+0x49, 0x3C, 0x49, 0xAD,
+
+0x10, 0xCC, 0x10, 0xCD,
+0x08, 0xCC, 0x08, 0xCD,
+
+0xB9, 0x41, 0x49, 0xBB,
+0x1F, 0xF0, 0x41, 0xCD,
+
+0x51, 0x3C, 0x51, 0xAD,
+0x00, 0x98, 0x80, 0xE9,
+
+0x94, 0x80, 0x07, 0xEA,
+0x24, 0x1F, 0x20, 0xE9,
+
+0x21, 0x45, 0x80, 0xE8,
+0x1A, 0x4D, 0x80, 0xE8,
+
+0x31, 0x55, 0x80, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0x41, 0x49, 0xBD,
+0x1D, 0x41, 0x51, 0xBD,
+
+0x2E, 0x41, 0x2A, 0xB8,
+0x34, 0x53, 0xA0, 0xE8,
+
+0x15, 0x30,
+0x1D, 0x30,
+0x58, 0xE3,
+0x00, 0xE0,
+
+0xB5, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x24, 0x43, 0xA0, 0xE8,
+0x2C, 0x4B, 0xA0, 0xE8,
+
+0x15, 0x72,
+0x09, 0xE3,
+0x00, 0xE0,
+0x1D, 0x72,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0x97, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x6C, 0x64, 0xC8, 0xEC,
+0x98, 0xE1,
+0xB5, 0x05,
+
+0xBD, 0x05,
+0x2E, 0x30,
+0x32, 0xC0, 0xA0, 0xE8,
+
+0x33, 0xC0, 0xA0, 0xE8,
+0x74, 0x64, 0xC8, 0xEC,
+
+0x40, 0x3C, 0x40, 0xAD,
+0x32, 0x6A,
+0x2A, 0x30,
+
+0x20, 0x73,
+0x33, 0x6A,
+0x00, 0xE0,
+0x28, 0x73,
+
+0x1C, 0x72,
+0x83, 0xE2,
+0x80, 0x80, 0x15, 0xEA,
+
+0xB8, 0x3D, 0x28, 0xDF,
+0x30, 0x35, 0x20, 0xDF,
+
+0x40, 0x30,
+0x00, 0xE0,
+0xCC, 0xE2,
+0x64, 0x72,
+
+0x25, 0x42, 0x52, 0xBF,
+0x2D, 0x42, 0x4A, 0xBF,
+
+0x30, 0x2E, 0x30, 0xDF,
+0x38, 0x2E, 0x38, 0xDF,
+
+0x18, 0x1D, 0x45, 0xE9,
+0x1E, 0x15, 0x45, 0xE9,
+
+0x2B, 0x49, 0x51, 0xBD,
+0x00, 0xE0,
+0x1F, 0x73,
+
+0x38, 0x38, 0x40, 0xAF,
+0x30, 0x30, 0x40, 0xAF,
+
+0x24, 0x1F, 0x24, 0xDF,
+0x1D, 0x32, 0x20, 0xE9,
+
+0x2C, 0x1F, 0x2C, 0xDF,
+0x1A, 0x33, 0x20, 0xE9,
+
+0xB0, 0x10,
+0x08, 0xE3,
+0x40, 0x10,
+0xB8, 0x10,
+
+0x26, 0xF0, 0x30, 0xCD,
+0x2F, 0xF0, 0x38, 0xCD,
+
+0x2B, 0x80, 0x20, 0xE9,
+0x2A, 0x80, 0x20, 0xE9,
+
+0xA6, 0x20,
+0x88, 0xE2,
+0x00, 0xE0,
+0xAF, 0x20,
+
+0x28, 0x2A, 0x26, 0xAF,
+0x20, 0x2A, 0xC0, 0xAF,
+
+0x34, 0x1F, 0x34, 0xDF,
+0x46, 0x24, 0x46, 0xDF,
+
+0x28, 0x30, 0x80, 0xBF,
+0x20, 0x38, 0x80, 0xBF,
+
+0x47, 0x24, 0x47, 0xDF,
+0x4E, 0x2C, 0x4E, 0xDF,
+
+0x4F, 0x2C, 0x4F, 0xDF,
+0x56, 0x34, 0x56, 0xDF,
+
+0x28, 0x15, 0x28, 0xDF,
+0x20, 0x1D, 0x20, 0xDF,
+
+0x57, 0x34, 0x57, 0xDF,
+0x00, 0xE0,
+0x1D, 0x05,
+
+0x04, 0x80, 0x10, 0xEA,
+0x89, 0xE2,
+0x2B, 0x30,
+
+0x3F, 0xC1, 0x1D, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA0, 0x68,
+0xBF, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x20, 0xC0, 0x20, 0xAF,
+0x28, 0x05,
+0x97, 0x74,
+
+0x00, 0xE0,
+0x2A, 0x10,
+0x16, 0xC0, 0x20, 0xE9,
+
+0x04, 0x80, 0x10, 0xEA,
+0x8C, 0xE2,
+0x95, 0x05,
+
+0x28, 0xC1, 0x28, 0xAD,
+0x1F, 0xC1, 0x15, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA8, 0x67,
+0x9F, 0x6B,
+0x00, 0x80, 0x00, 0xE8,
+
+0x28, 0xC0, 0x28, 0xAD,
+0x1D, 0x25,
+0x20, 0x05,
+
+0x28, 0x32, 0x80, 0xAD,
+0x40, 0x2A, 0x40, 0xBD,
+
+0x1C, 0x80, 0x20, 0xE9,
+0x20, 0x33, 0x20, 0xAD,
+
+0x20, 0x73,
+0x00, 0xE0,
+0xB6, 0x49, 0x51, 0xBB,
+
+0x26, 0x2F, 0xB0, 0xE8,
+0x19, 0x20, 0x20, 0xE9,
+
+0x35, 0x20, 0x35, 0xDF,
+0x3D, 0x20, 0x3D, 0xDF,
+
+0x15, 0x20, 0x15, 0xDF,
+0x1D, 0x20, 0x1D, 0xDF,
+
+0x26, 0xD0, 0x26, 0xCD,
+0x29, 0x49, 0x2A, 0xB8,
+
+0x26, 0x40, 0x80, 0xBD,
+0x3B, 0x48, 0x50, 0xBD,
+
+0x3E, 0x54, 0x57, 0x9F,
+0x00, 0xE0,
+0x82, 0xE1,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x26, 0x30,
+0x29, 0x30,
+0x48, 0x3C, 0x48, 0xAD,
+
+0x2B, 0x72,
+0xC2, 0xE1,
+0x2C, 0xC0, 0x44, 0xC2,
+
+0x05, 0x24, 0x34, 0xBF,
+0x0D, 0x24, 0x2C, 0xBF,
+
+0x2D, 0x46, 0x4E, 0xBF,
+0x25, 0x46, 0x56, 0xBF,
+
+0x20, 0x1D, 0x6F, 0x8F,
+0x32, 0x3E, 0x5F, 0xE9,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x30,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x33, 0x1E, 0x5F, 0xE9,
+
+0x05, 0x44, 0x54, 0xB2,
+0x0D, 0x44, 0x4C, 0xB2,
+
+0x19, 0xC0, 0xB0, 0xE8,
+0x34, 0xC0, 0x44, 0xC4,
+
+0x33, 0x73,
+0x00, 0xE0,
+0x3E, 0x62, 0x57, 0x9F,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0xE0,
+0x0D, 0x20,
+
+0x84, 0x3E, 0x58, 0xE9,
+0x28, 0x1D, 0x6F, 0x8F,
+
+0x05, 0x20,
+0x00, 0xE0,
+0x85, 0x1E, 0x58, 0xE9,
+
+0x9B, 0x3B, 0x33, 0xDF,
+0x20, 0x20, 0x42, 0xAF,
+
+0x30, 0x42, 0x56, 0x9F,
+0x80, 0x3E, 0x57, 0xE9,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x30, 0x80, 0x5F, 0xE9,
+
+0x28, 0x28, 0x24, 0xAF,
+0x81, 0x1E, 0x57, 0xE9,
+
+0x05, 0x47, 0x57, 0xBF,
+0x0D, 0x47, 0x4F, 0xBF,
+
+0x88, 0x80, 0x58, 0xE9,
+0x1B, 0x29, 0x1B, 0xDF,
+
+0x30, 0x1D, 0x6F, 0x8F,
+0x3A, 0x30, 0x4F, 0xE9,
+
+0x1C, 0x30, 0x26, 0xDF,
+0x09, 0xE3,
+0x3B, 0x05,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x3B, 0x3F, 0x4F, 0xE9,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x00, 0xE0,
+0xAC, 0x20,
+
+0x2D, 0x44, 0x4C, 0xB4,
+0x2C, 0x1C, 0xC0, 0xAF,
+
+0x25, 0x44, 0x54, 0xB4,
+0x00, 0xE0,
+0xC8, 0x30,
+
+0x30, 0x46, 0x30, 0xAF,
+0x1B, 0x1B, 0x48, 0xAF,
+
+0x00, 0xE0,
+0x25, 0x20,
+0x38, 0x2C, 0x4F, 0xE9,
+
+0x86, 0x80, 0x57, 0xE9,
+0x38, 0x1D, 0x6F, 0x8F,
+
+0x28, 0x74,
+0x00, 0xE0,
+0x0D, 0x44, 0x4C, 0xB0,
+
+0x05, 0x44, 0x54, 0xB0,
+0x2D, 0x20,
+0x9B, 0x10,
+
+0x82, 0x3E, 0x57, 0xE9,
+0x32, 0xF0, 0x1B, 0xCD,
+
+0x1E, 0xBD, 0x59, 0x9F,
+0x83, 0x1E, 0x57, 0xE9,
+
+0x38, 0x47, 0x38, 0xAF,
+0x34, 0x20,
+0x2A, 0x30,
+
+0x00, 0xE0,
+0x0D, 0x20,
+0x32, 0x20,
+0x05, 0x20,
+
+0x87, 0x80, 0x57, 0xE9,
+0x1F, 0x54, 0x57, 0x9F,
+
+0x17, 0x42, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x6A,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x37, 0x1E, 0x4F, 0xE9,
+
+0x37, 0x32, 0x2A, 0xAF,
+0x00, 0xE0,
+0x32, 0x00,
+
+0x00, 0x80, 0x00, 0xE8,
+0x27, 0xC0, 0x44, 0xC0,
+
+0x36, 0x1F, 0x4F, 0xE9,
+0x1F, 0x1F, 0x26, 0xDF,
+
+0x37, 0x1B, 0x37, 0xBF,
+0x17, 0x26, 0x17, 0xDF,
+
+0x3E, 0x17, 0x4F, 0xE9,
+0x3F, 0x3F, 0x4F, 0xE9,
+
+0x34, 0x1F, 0x34, 0xAF,
+0x2B, 0x05,
+0xA7, 0x20,
+
+0x33, 0x2B, 0x37, 0xDF,
+0x27, 0x17, 0xC0, 0xAF,
+
+0x34, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x2D, 0x21, 0x1A, 0xB0,
+0x25, 0x21, 0x31, 0xB0,
+
+0x0D, 0x21, 0x1A, 0xB2,
+0x05, 0x21, 0x31, 0xB2,
+
+0x03, 0x80, 0x2A, 0xEA,
+0x17, 0xC1, 0x2B, 0xBD,
+
+0x2D, 0x20,
+0x25, 0x20,
+0x05, 0x20,
+0x0D, 0x20,
+
+0xB3, 0x68,
+0x97, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0xC0, 0x33, 0xAF,
+0x2F, 0xC0, 0x21, 0xC0,
+
+0x16, 0x42, 0x56, 0x9F,
+0x3C, 0x27, 0x4F, 0xE9,
+
+0x1E, 0x62, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x21, 0x31, 0xB4,
+0x2D, 0x21, 0x1A, 0xB4,
+
+0x3F, 0x2F, 0x5D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0x05,
+0x00, 0xE0,
+0x28, 0x19, 0x60, 0xEC,
+
+0x0D, 0x21, 0x1A, 0xB6,
+0x05, 0x21, 0x31, 0xB6,
+
+0x37, 0x0F, 0x5C, 0x9F,
+0x00, 0xE0,
+0x2F, 0x20,
+
+0x23, 0x3B, 0x33, 0xAD,
+0x1E, 0x26, 0x1E, 0xDF,
+
+0xA7, 0x1E, 0x4F, 0xE9,
+0x17, 0x26, 0x16, 0xDF,
+
+0x2D, 0x20,
+0x00, 0xE0,
+0xA8, 0x3F, 0x4F, 0xE9,
+
+0x2F, 0x2F, 0x1E, 0xAF,
+0x25, 0x20,
+0x00, 0xE0,
+
+0xA4, 0x16, 0x4F, 0xE9,
+0x0F, 0xC0, 0x21, 0xC2,
+
+0xA6, 0x80, 0x4F, 0xE9,
+0x1F, 0x62, 0x57, 0x9F,
+
+0x0D, 0x20,
+0x05, 0x20,
+0x2F, 0xC0, 0x21, 0xC6,
+
+0x2D, 0x44, 0x4C, 0xB6,
+0x25, 0x44, 0x54, 0xB6,
+
+0x3F, 0x2F, 0x5D, 0x9F,
+0x00, 0xE0,
+0x0F, 0x20,
+
+0x2D, 0x20,
+0x25, 0x20,
+0x07, 0xC0, 0x44, 0xC6,
+
+0x17, 0x50, 0x56, 0x9F,
+0xA5, 0x37, 0x4F, 0xE9,
+
+0x06, 0xC0, 0x21, 0xC4,
+0x0F, 0x17, 0x0F, 0xAF,
+
+0x37, 0x0F, 0x5C, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x1E, 0x62, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x3E, 0x3D, 0x5D, 0x9F,
+0x00, 0xE0,
+0x07, 0x20,
+
+0x2F, 0x20,
+0x00, 0xE0,
+0xA3, 0x0F, 0x4F, 0xE9,
+
+0x06, 0x20,
+0x00, 0xE0,
+0x1F, 0x26, 0x1F, 0xDF,
+
+0x17, 0x26, 0x17, 0xDF,
+0xA1, 0x1F, 0x4F, 0xE9,
+
+0x1E, 0x26, 0x1E, 0xDF,
+0x9D, 0x1E, 0x4F, 0xE9,
+
+0x35, 0x17, 0x4F, 0xE9,
+0xA2, 0x3F, 0x4F, 0xE9,
+
+0x06, 0x06, 0x1F, 0xAF,
+0x39, 0x37, 0x4F, 0xE9,
+
+0x2F, 0x2F, 0x17, 0xAF,
+0x07, 0x07, 0x1E, 0xAF,
+
+0xA0, 0x80, 0x4F, 0xE9,
+0x9E, 0x3E, 0x4F, 0xE9,
+
+0x31, 0x80, 0x4F, 0xE9,
+0x9C, 0x80, 0x4F, 0xE9,
+
+0x00, 0x80, 0x00, 0xE8,
+0x57, 0x39, 0x20, 0xE9,
+
+0x16, 0x28, 0x20, 0xE9,
+0x1D, 0x3B, 0x20, 0xE9,
+
+0x1E, 0x2B, 0x20, 0xE9,
+0x2B, 0x32, 0x20, 0xE9,
+
+0x1C, 0x23, 0x20, 0xE9,
+0x57, 0x36, 0x20, 0xE9,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x90, 0xE2,
+0x00, 0xE0,
+
+0x63, 0xFF, 0x20, 0xEA,
+0x19, 0xC8, 0xC1, 0xCD,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x9F, 0x41, 0x49, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x41, 0x49, 0xBD,
+0x2D, 0x41, 0x51, 0xBD,
+
+0x0D, 0x80, 0x07, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x35, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x25, 0x30,
+0x2D, 0x30,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0xA7, 0x5B, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x62, 0xFF, 0x0A, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC9, 0x41, 0xC8, 0xEC,
+0x42, 0xE1,
+0x00, 0xE0,
+
+0x60, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC8, 0x40, 0xC0, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x5D, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+};
+unsigned char WARP_G200_tgzsf[] = {
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x98, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x81, 0x04,
+0x89, 0x04,
+0x01, 0x04,
+0x09, 0x04,
+
+0xC9, 0x41, 0xC0, 0xEC,
+0x11, 0x04,
+0x00, 0xE0,
+
+0x41, 0xCC, 0x41, 0xCD,
+0x49, 0xCC, 0x49, 0xCD,
+
+0xD1, 0x41, 0xC0, 0xEC,
+0x51, 0xCC, 0x51, 0xCD,
+
+0x80, 0x04,
+0x10, 0x04,
+0x08, 0x04,
+0x00, 0xE0,
+
+0x00, 0xCC, 0xC0, 0xCD,
+0xD1, 0x49, 0xC0, 0xEC,
+
+0x8A, 0x1F, 0x20, 0xE9,
+0x8B, 0x3F, 0x20, 0xE9,
+
+0x41, 0x3C, 0x41, 0xAD,
+0x49, 0x3C, 0x49, 0xAD,
+
+0x10, 0xCC, 0x10, 0xCD,
+0x08, 0xCC, 0x08, 0xCD,
+
+0xB9, 0x41, 0x49, 0xBB,
+0x1F, 0xF0, 0x41, 0xCD,
+
+0x51, 0x3C, 0x51, 0xAD,
+0x00, 0x98, 0x80, 0xE9,
+
+0x8F, 0x80, 0x07, 0xEA,
+0x24, 0x1F, 0x20, 0xE9,
+
+0x21, 0x45, 0x80, 0xE8,
+0x1A, 0x4D, 0x80, 0xE8,
+
+0x31, 0x55, 0x80, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0x41, 0x49, 0xBD,
+0x1D, 0x41, 0x51, 0xBD,
+
+0x2E, 0x41, 0x2A, 0xB8,
+0x34, 0x53, 0xA0, 0xE8,
+
+0x15, 0x30,
+0x1D, 0x30,
+0x58, 0xE3,
+0x00, 0xE0,
+
+0xB5, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x24, 0x43, 0xA0, 0xE8,
+0x2C, 0x4B, 0xA0, 0xE8,
+
+0x15, 0x72,
+0x09, 0xE3,
+0x00, 0xE0,
+0x1D, 0x72,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0x97, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x6C, 0x64, 0xC8, 0xEC,
+0x98, 0xE1,
+0xB5, 0x05,
+
+0xBD, 0x05,
+0x2E, 0x30,
+0x32, 0xC0, 0xA0, 0xE8,
+
+0x33, 0xC0, 0xA0, 0xE8,
+0x74, 0x64, 0xC8, 0xEC,
+
+0x40, 0x3C, 0x40, 0xAD,
+0x32, 0x6A,
+0x2A, 0x30,
+
+0x20, 0x73,
+0x33, 0x6A,
+0x00, 0xE0,
+0x28, 0x73,
+
+0x1C, 0x72,
+0x83, 0xE2,
+0x7B, 0x80, 0x15, 0xEA,
+
+0xB8, 0x3D, 0x28, 0xDF,
+0x30, 0x35, 0x20, 0xDF,
+
+0x40, 0x30,
+0x00, 0xE0,
+0xCC, 0xE2,
+0x64, 0x72,
+
+0x25, 0x42, 0x52, 0xBF,
+0x2D, 0x42, 0x4A, 0xBF,
+
+0x30, 0x2E, 0x30, 0xDF,
+0x38, 0x2E, 0x38, 0xDF,
+
+0x18, 0x1D, 0x45, 0xE9,
+0x1E, 0x15, 0x45, 0xE9,
+
+0x2B, 0x49, 0x51, 0xBD,
+0x00, 0xE0,
+0x1F, 0x73,
+
+0x38, 0x38, 0x40, 0xAF,
+0x30, 0x30, 0x40, 0xAF,
+
+0x24, 0x1F, 0x24, 0xDF,
+0x1D, 0x32, 0x20, 0xE9,
+
+0x2C, 0x1F, 0x2C, 0xDF,
+0x1A, 0x33, 0x20, 0xE9,
+
+0xB0, 0x10,
+0x08, 0xE3,
+0x40, 0x10,
+0xB8, 0x10,
+
+0x26, 0xF0, 0x30, 0xCD,
+0x2F, 0xF0, 0x38, 0xCD,
+
+0x2B, 0x80, 0x20, 0xE9,
+0x2A, 0x80, 0x20, 0xE9,
+
+0xA6, 0x20,
+0x88, 0xE2,
+0x00, 0xE0,
+0xAF, 0x20,
+
+0x28, 0x2A, 0x26, 0xAF,
+0x20, 0x2A, 0xC0, 0xAF,
+
+0x34, 0x1F, 0x34, 0xDF,
+0x46, 0x24, 0x46, 0xDF,
+
+0x28, 0x30, 0x80, 0xBF,
+0x20, 0x38, 0x80, 0xBF,
+
+0x47, 0x24, 0x47, 0xDF,
+0x4E, 0x2C, 0x4E, 0xDF,
+
+0x4F, 0x2C, 0x4F, 0xDF,
+0x56, 0x34, 0x56, 0xDF,
+
+0x28, 0x15, 0x28, 0xDF,
+0x20, 0x1D, 0x20, 0xDF,
+
+0x57, 0x34, 0x57, 0xDF,
+0x00, 0xE0,
+0x1D, 0x05,
+
+0x04, 0x80, 0x10, 0xEA,
+0x89, 0xE2,
+0x2B, 0x30,
+
+0x3F, 0xC1, 0x1D, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA0, 0x68,
+0xBF, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x20, 0xC0, 0x20, 0xAF,
+0x28, 0x05,
+0x97, 0x74,
+
+0x00, 0xE0,
+0x2A, 0x10,
+0x16, 0xC0, 0x20, 0xE9,
+
+0x04, 0x80, 0x10, 0xEA,
+0x8C, 0xE2,
+0x95, 0x05,
+
+0x28, 0xC1, 0x28, 0xAD,
+0x1F, 0xC1, 0x15, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA8, 0x67,
+0x9F, 0x6B,
+0x00, 0x80, 0x00, 0xE8,
+
+0x28, 0xC0, 0x28, 0xAD,
+0x1D, 0x25,
+0x20, 0x05,
+
+0x28, 0x32, 0x80, 0xAD,
+0x40, 0x2A, 0x40, 0xBD,
+
+0x1C, 0x80, 0x20, 0xE9,
+0x20, 0x33, 0x20, 0xAD,
+
+0x20, 0x73,
+0x00, 0xE0,
+0xB6, 0x49, 0x51, 0xBB,
+
+0x26, 0x2F, 0xB0, 0xE8,
+0x19, 0x20, 0x20, 0xE9,
+
+0x35, 0x20, 0x35, 0xDF,
+0x3D, 0x20, 0x3D, 0xDF,
+
+0x15, 0x20, 0x15, 0xDF,
+0x1D, 0x20, 0x1D, 0xDF,
+
+0x26, 0xD0, 0x26, 0xCD,
+0x29, 0x49, 0x2A, 0xB8,
+
+0x26, 0x40, 0x80, 0xBD,
+0x3B, 0x48, 0x50, 0xBD,
+
+0x3E, 0x54, 0x57, 0x9F,
+0x00, 0xE0,
+0x82, 0xE1,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x26, 0x30,
+0x29, 0x30,
+0x48, 0x3C, 0x48, 0xAD,
+
+0x2B, 0x72,
+0xC2, 0xE1,
+0x2C, 0xC0, 0x44, 0xC2,
+
+0x05, 0x24, 0x34, 0xBF,
+0x0D, 0x24, 0x2C, 0xBF,
+
+0x2D, 0x46, 0x4E, 0xBF,
+0x25, 0x46, 0x56, 0xBF,
+
+0x20, 0x1D, 0x6F, 0x8F,
+0x32, 0x3E, 0x5F, 0xE9,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x30,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x33, 0x1E, 0x5F, 0xE9,
+
+0x05, 0x44, 0x54, 0xB2,
+0x0D, 0x44, 0x4C, 0xB2,
+
+0x19, 0xC0, 0xB0, 0xE8,
+0x34, 0xC0, 0x44, 0xC4,
+
+0x33, 0x73,
+0x00, 0xE0,
+0x3E, 0x62, 0x57, 0x9F,
+
+0x1E, 0xAF, 0x59, 0x9F,
+0x00, 0xE0,
+0x0D, 0x20,
+
+0x84, 0x3E, 0x58, 0xE9,
+0x28, 0x1D, 0x6F, 0x8F,
+
+0x05, 0x20,
+0x00, 0xE0,
+0x85, 0x1E, 0x58, 0xE9,
+
+0x9B, 0x3B, 0x33, 0xDF,
+0x20, 0x20, 0x42, 0xAF,
+
+0x30, 0x42, 0x56, 0x9F,
+0x80, 0x3E, 0x57, 0xE9,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x30, 0x80, 0x5F, 0xE9,
+
+0x28, 0x28, 0x24, 0xAF,
+0x81, 0x1E, 0x57, 0xE9,
+
+0x05, 0x47, 0x57, 0xBF,
+0x0D, 0x47, 0x4F, 0xBF,
+
+0x88, 0x80, 0x58, 0xE9,
+0x1B, 0x29, 0x1B, 0xDF,
+
+0x30, 0x1D, 0x6F, 0x8F,
+0x3A, 0x30, 0x4F, 0xE9,
+
+0x1C, 0x30, 0x26, 0xDF,
+0x09, 0xE3,
+0x3B, 0x05,
+
+0x3E, 0x50, 0x56, 0x9F,
+0x3B, 0x3F, 0x4F, 0xE9,
+
+0x1E, 0x8F, 0x51, 0x9F,
+0x00, 0xE0,
+0xAC, 0x20,
+
+0x2D, 0x44, 0x4C, 0xB4,
+0x2C, 0x1C, 0xC0, 0xAF,
+
+0x25, 0x44, 0x54, 0xB4,
+0x00, 0xE0,
+0xC8, 0x30,
+
+0x30, 0x46, 0x30, 0xAF,
+0x1B, 0x1B, 0x48, 0xAF,
+
+0x00, 0xE0,
+0x25, 0x20,
+0x38, 0x2C, 0x4F, 0xE9,
+
+0x86, 0x80, 0x57, 0xE9,
+0x38, 0x1D, 0x6F, 0x8F,
+
+0x28, 0x74,
+0x00, 0xE0,
+0x0D, 0x44, 0x4C, 0xB0,
+
+0x05, 0x44, 0x54, 0xB0,
+0x2D, 0x20,
+0x9B, 0x10,
+
+0x82, 0x3E, 0x57, 0xE9,
+0x32, 0xF0, 0x1B, 0xCD,
+
+0x1E, 0xBD, 0x59, 0x9F,
+0x83, 0x1E, 0x57, 0xE9,
+
+0x38, 0x47, 0x38, 0xAF,
+0x34, 0x20,
+0x2A, 0x30,
+
+0x00, 0xE0,
+0x0D, 0x20,
+0x32, 0x20,
+0x05, 0x20,
+
+0x87, 0x80, 0x57, 0xE9,
+0x1F, 0x54, 0x57, 0x9F,
+
+0x17, 0x42, 0x56, 0x9F,
+0x00, 0xE0,
+0x3B, 0x6A,
+
+0x3F, 0x8F, 0x51, 0x9F,
+0x37, 0x1E, 0x4F, 0xE9,
+
+0x37, 0x32, 0x2A, 0xAF,
+0x00, 0xE0,
+0x32, 0x00,
+
+0x00, 0x80, 0x00, 0xE8,
+0x27, 0xC0, 0x44, 0xC0,
+
+0x36, 0x1F, 0x4F, 0xE9,
+0x1F, 0x1F, 0x26, 0xDF,
+
+0x37, 0x1B, 0x37, 0xBF,
+0x17, 0x26, 0x17, 0xDF,
+
+0x3E, 0x17, 0x4F, 0xE9,
+0x3F, 0x3F, 0x4F, 0xE9,
+
+0x34, 0x1F, 0x34, 0xAF,
+0x2B, 0x05,
+0xA7, 0x20,
+
+0x33, 0x2B, 0x37, 0xDF,
+0x27, 0x17, 0xC0, 0xAF,
+
+0x34, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x2D, 0x21, 0x1A, 0xB0,
+0x25, 0x21, 0x31, 0xB0,
+
+0x0D, 0x21, 0x1A, 0xB2,
+0x05, 0x21, 0x31, 0xB2,
+
+0x03, 0x80, 0x2A, 0xEA,
+0x17, 0xC1, 0x2B, 0xBD,
+
+0x2D, 0x20,
+0x25, 0x20,
+0x05, 0x20,
+0x0D, 0x20,
+
+0xB3, 0x68,
+0x97, 0x25,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0xC0, 0x33, 0xAF,
+0x2F, 0xC0, 0x21, 0xC0,
+
+0x16, 0x42, 0x56, 0x9F,
+0x3C, 0x27, 0x4F, 0xE9,
+
+0x1E, 0x62, 0x57, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x21, 0x31, 0xB4,
+0x2D, 0x21, 0x1A, 0xB4,
+
+0x3F, 0x2F, 0x5D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x33, 0x05,
+0x00, 0xE0,
+0x28, 0x19, 0x60, 0xEC,
+
+0x0D, 0x21, 0x1A, 0xB6,
+0x05, 0x21, 0x31, 0xB6,
+
+0x37, 0x0F, 0x5C, 0x9F,
+0x00, 0xE0,
+0x2F, 0x20,
+
+0x23, 0x3B, 0x33, 0xAD,
+0x1E, 0x26, 0x1E, 0xDF,
+
+0xA7, 0x1E, 0x4F, 0xE9,
+0x17, 0x26, 0x16, 0xDF,
+
+0x2D, 0x20,
+0x00, 0xE0,
+0xA8, 0x3F, 0x4F, 0xE9,
+
+0x2F, 0x2F, 0x1E, 0xAF,
+0x25, 0x20,
+0x00, 0xE0,
+
+0xA4, 0x16, 0x4F, 0xE9,
+0x0F, 0xC0, 0x21, 0xC2,
+
+0xA6, 0x80, 0x4F, 0xE9,
+0x1F, 0x62, 0x57, 0x9F,
+
+0x0D, 0x20,
+0x05, 0x20,
+0x2F, 0xC0, 0x21, 0xC6,
+
+0x3F, 0x2F, 0x5D, 0x9F,
+0x00, 0xE0,
+0x0F, 0x20,
+
+0x17, 0x50, 0x56, 0x9F,
+0xA5, 0x37, 0x4F, 0xE9,
+
+0x06, 0xC0, 0x21, 0xC4,
+0x0F, 0x17, 0x0F, 0xAF,
+
+0x37, 0x0F, 0x5C, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x2F, 0x20,
+0x00, 0xE0,
+0xA3, 0x80, 0x4F, 0xE9,
+
+0x06, 0x20,
+0x00, 0xE0,
+0x1F, 0x26, 0x1F, 0xDF,
+
+0x17, 0x26, 0x17, 0xDF,
+0x35, 0x17, 0x4F, 0xE9,
+
+0xA1, 0x1F, 0x4F, 0xE9,
+0xA2, 0x3F, 0x4F, 0xE9,
+
+0x06, 0x06, 0x1F, 0xAF,
+0x39, 0x37, 0x4F, 0xE9,
+
+0x2F, 0x2F, 0x17, 0xAF,
+0x00, 0x80, 0x00, 0xE8,
+
+0xA0, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x31, 0x80, 0x4F, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x57, 0x39, 0x20, 0xE9,
+
+0x16, 0x28, 0x20, 0xE9,
+0x1D, 0x3B, 0x20, 0xE9,
+
+0x1E, 0x2B, 0x20, 0xE9,
+0x2B, 0x32, 0x20, 0xE9,
+
+0x1C, 0x23, 0x20, 0xE9,
+0x57, 0x36, 0x20, 0xE9,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x40, 0x40, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x90, 0xE2,
+0x00, 0xE0,
+
+0x68, 0xFF, 0x20, 0xEA,
+0x19, 0xC8, 0xC1, 0xCD,
+
+0x1F, 0xD7, 0x18, 0xBD,
+0x3F, 0xD7, 0x22, 0xBD,
+
+0x9F, 0x41, 0x49, 0xBD,
+0x00, 0x80, 0x00, 0xE8,
+
+0x25, 0x41, 0x49, 0xBD,
+0x2D, 0x41, 0x51, 0xBD,
+
+0x0D, 0x80, 0x07, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x35, 0x40, 0x48, 0xBD,
+0x3D, 0x40, 0x50, 0xBD,
+
+0x00, 0x80, 0x00, 0xE8,
+0x25, 0x30,
+0x2D, 0x30,
+
+0x35, 0x30,
+0xB5, 0x30,
+0xBD, 0x30,
+0x3D, 0x30,
+
+0x9C, 0xA7, 0x5B, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x67, 0xFF, 0x0A, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC9, 0x41, 0xC8, 0xEC,
+0x42, 0xE1,
+0x00, 0xE0,
+
+0x65, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0xC8, 0x40, 0xC0, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x62, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+};
+unsigned char WARP_G400_t2gz[] = {
+
+0x00, 0x8A, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x0A, 0x40, 0x50, 0xBF,
+0x2A, 0x40, 0x60, 0xBF,
+
+0x32, 0x41, 0x51, 0xBF,
+0x3A, 0x41, 0x61, 0xBF,
+
+0xC3, 0x6B,
+0xD3, 0x6B,
+0x00, 0x8A, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x53, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x23, 0x9F,
+0x00, 0xE0,
+0x51, 0x04,
+
+0x90, 0xE2,
+0x61, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x51, 0x41, 0xE0, 0xEC,
+0x39, 0x67, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x63, 0xA0, 0xE8,
+
+0x61, 0x41, 0xE0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x78, 0x80, 0x15, 0xEA,
+0x10, 0x04,
+0x20, 0x04,
+
+0x61, 0x51, 0xE0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x52, 0xBF,
+0x0F, 0x52, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x62, 0xBF,
+0x1E, 0x51, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x0E, 0x61, 0x60, 0xEA,
+
+0x32, 0x40, 0x50, 0xBD,
+0x22, 0x40, 0x60, 0xBD,
+
+0x12, 0x41, 0x51, 0xBD,
+0x3A, 0x41, 0x61, 0xBD,
+
+0xBF, 0x2F, 0x0E, 0xBD,
+0x97, 0xE2,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x35, 0x48, 0xB1, 0xE8,
+0x3D, 0x59, 0xB1, 0xE8,
+
+0x46, 0x31, 0x46, 0xBF,
+0x56, 0x31, 0x56, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x66, 0x31, 0x66, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x57, 0x39, 0x57, 0xBF,
+0x67, 0x39, 0x67, 0xBF,
+
+0x69, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x35, 0x00,
+0x3D, 0x00,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0x8D, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x75, 0xF8, 0xEC,
+0x35, 0x20,
+0x3D, 0x20,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x53, 0x53, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x0E, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x48, 0x35, 0x48, 0xBF,
+0x58, 0x35, 0x58, 0xBF,
+
+0x68, 0x35, 0x68, 0xBF,
+0x49, 0x3D, 0x49, 0xBF,
+
+0x59, 0x3D, 0x59, 0xBF,
+0x69, 0x3D, 0x69, 0xBF,
+
+0x63, 0x63, 0x2D, 0xDF,
+0x4D, 0x7D, 0xF8, 0xEC,
+
+0x59, 0xE3,
+0x00, 0xE0,
+0xB8, 0x38, 0x33, 0xBF,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x18, 0x3A, 0x41, 0xE9,
+
+0x3F, 0x53, 0xA0, 0xE8,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x63, 0xA0, 0xE8,
+
+0x50, 0x70, 0xF8, 0xEC,
+0x2B, 0x50, 0x3C, 0xE9,
+
+0x1F, 0x0F, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x59, 0x78, 0xF8, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x46, 0x37, 0x46, 0xDF,
+0x56, 0x3F, 0x56, 0xDF,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x66, 0x3D, 0x66, 0xDF,
+
+0x1D, 0x32, 0x41, 0xE9,
+0x67, 0x3D, 0x67, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3F, 0x57, 0xDF,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x59, 0x3F, 0x59, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x69, 0x3D, 0x69, 0xDF,
+
+0x48, 0x37, 0x48, 0xDF,
+0x58, 0x3F, 0x58, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x68, 0x3D, 0x68, 0xDF,
+0x49, 0x37, 0x49, 0xDF,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x34, 0x80, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x0A, 0x44, 0x54, 0xB0,
+0x02, 0x44, 0x64, 0xB0,
+
+0x2A, 0x44, 0x54, 0xB2,
+0x1A, 0x44, 0x64, 0xB2,
+
+0x25, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x3D, 0xCF, 0x74, 0xC2,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x2A, 0x44, 0x54, 0xB4,
+0x1A, 0x44, 0x64, 0xB4,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x38, 0x3D, 0x20, 0xE9,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x2A, 0x46, 0x56, 0xBF,
+0x1A, 0x46, 0x66, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x0A, 0x47, 0x57, 0xBF,
+0x02, 0x47, 0x67, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x53, 0xBF,
+0x1A, 0x43, 0x63, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x36, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x37, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x48, 0x58, 0xBF,
+0x02, 0x48, 0x68, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x2A, 0x49, 0x59, 0xBF,
+0x1A, 0x49, 0x69, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x82, 0x30, 0x57, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x83, 0x38, 0x57, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x84, 0x31, 0x5E, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x85, 0x39, 0x5E, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x87, 0x77, 0x57, 0xE9,
+0x8B, 0x3E, 0xBF, 0xEA,
+
+0x80, 0x30, 0x57, 0xE9,
+0x81, 0x38, 0x57, 0xE9,
+
+0x82, 0x31, 0x57, 0xE9,
+0x86, 0x78, 0x57, 0xE9,
+
+0x83, 0x39, 0x57, 0xE9,
+0x87, 0x79, 0x57, 0xE9,
+
+0x30, 0x1F, 0x5F, 0xE9,
+0x8A, 0x34, 0x20, 0xE9,
+
+0x8B, 0x3C, 0x20, 0xE9,
+0x37, 0x50, 0x60, 0xBD,
+
+0x57, 0x0D, 0x20, 0xE9,
+0x35, 0x51, 0x61, 0xBD,
+
+0x2B, 0x50, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x0E, 0x77,
+
+0x24, 0x51, 0x20, 0xE9,
+0x9F, 0xFF, 0x20, 0xEA,
+
+0x16, 0x0E, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x0B, 0x46, 0xA0, 0xE8,
+0x1B, 0x56, 0xA0, 0xE8,
+
+0x2B, 0x66, 0xA0, 0xE8,
+0x0C, 0x47, 0xA0, 0xE8,
+
+0x1C, 0x57, 0xA0, 0xE8,
+0x2C, 0x67, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x57, 0x80, 0x57, 0xCF,
+
+0x66, 0x33, 0x66, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x67, 0x3B, 0x67, 0xCF,
+
+0x0B, 0x48, 0xA0, 0xE8,
+0x1B, 0x58, 0xA0, 0xE8,
+
+0x2B, 0x68, 0xA0, 0xE8,
+0x0C, 0x49, 0xA0, 0xE8,
+
+0x1C, 0x59, 0xA0, 0xE8,
+0x2C, 0x69, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x34, 0xD7, 0x34, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3C, 0xD7, 0x3C, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x34, 0x80, 0x34, 0xBD,
+0x3C, 0x80, 0x3C, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x48, 0x80, 0x48, 0xCF,
+0x59, 0x80, 0x59, 0xCF,
+
+0x68, 0x33, 0x68, 0xCF,
+0x49, 0x3B, 0x49, 0xCF,
+
+0xBE, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x58, 0x33, 0x58, 0xCF,
+0x69, 0x3B, 0x69, 0xCF,
+
+0x7D, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_t2gza[] = {
+
+0x00, 0x8A, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x0A, 0x40, 0x50, 0xBF,
+0x2A, 0x40, 0x60, 0xBF,
+
+0x32, 0x41, 0x51, 0xBF,
+0x3A, 0x41, 0x61, 0xBF,
+
+0xC3, 0x6B,
+0xD3, 0x6B,
+0x00, 0x8A, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x53, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x23, 0x9F,
+0x00, 0xE0,
+0x51, 0x04,
+
+0x90, 0xE2,
+0x61, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x51, 0x41, 0xE0, 0xEC,
+0x39, 0x67, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x63, 0xA0, 0xE8,
+
+0x61, 0x41, 0xE0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x7C, 0x80, 0x15, 0xEA,
+0x10, 0x04,
+0x20, 0x04,
+
+0x61, 0x51, 0xE0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x52, 0xBF,
+0x0F, 0x52, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x62, 0xBF,
+0x1E, 0x51, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x0E, 0x61, 0x60, 0xEA,
+
+0x32, 0x40, 0x50, 0xBD,
+0x22, 0x40, 0x60, 0xBD,
+
+0x12, 0x41, 0x51, 0xBD,
+0x3A, 0x41, 0x61, 0xBD,
+
+0xBF, 0x2F, 0x0E, 0xBD,
+0x97, 0xE2,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x35, 0x48, 0xB1, 0xE8,
+0x3D, 0x59, 0xB1, 0xE8,
+
+0x46, 0x31, 0x46, 0xBF,
+0x56, 0x31, 0x56, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x66, 0x31, 0x66, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x57, 0x39, 0x57, 0xBF,
+0x67, 0x39, 0x67, 0xBF,
+
+0x6D, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x35, 0x00,
+0x3D, 0x00,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0x8D, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x75, 0xF8, 0xEC,
+0x35, 0x20,
+0x3D, 0x20,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x53, 0x53, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x0E, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x48, 0x35, 0x48, 0xBF,
+0x58, 0x35, 0x58, 0xBF,
+
+0x68, 0x35, 0x68, 0xBF,
+0x49, 0x3D, 0x49, 0xBF,
+
+0x59, 0x3D, 0x59, 0xBF,
+0x69, 0x3D, 0x69, 0xBF,
+
+0x63, 0x63, 0x2D, 0xDF,
+0x4D, 0x7D, 0xF8, 0xEC,
+
+0x59, 0xE3,
+0x00, 0xE0,
+0xB8, 0x38, 0x33, 0xBF,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x18, 0x3A, 0x41, 0xE9,
+
+0x3F, 0x53, 0xA0, 0xE8,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x63, 0xA0, 0xE8,
+
+0x50, 0x70, 0xF8, 0xEC,
+0x2B, 0x50, 0x3C, 0xE9,
+
+0x1F, 0x0F, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x59, 0x78, 0xF8, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x46, 0x37, 0x46, 0xDF,
+0x56, 0x3F, 0x56, 0xDF,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x66, 0x3D, 0x66, 0xDF,
+
+0x1D, 0x32, 0x41, 0xE9,
+0x67, 0x3D, 0x67, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3F, 0x57, 0xDF,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x59, 0x3F, 0x59, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x69, 0x3D, 0x69, 0xDF,
+
+0x48, 0x37, 0x48, 0xDF,
+0x58, 0x3F, 0x58, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x68, 0x3D, 0x68, 0xDF,
+0x49, 0x37, 0x49, 0xDF,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x34, 0x80, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x0A, 0x44, 0x54, 0xB0,
+0x02, 0x44, 0x64, 0xB0,
+
+0x2A, 0x44, 0x54, 0xB2,
+0x1A, 0x44, 0x64, 0xB2,
+
+0x29, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x0F, 0xCF, 0x74, 0xC6,
+0x3D, 0xCF, 0x74, 0xC2,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9C, 0x0F, 0x20, 0xE9,
+
+0x0A, 0x44, 0x54, 0xB4,
+0x02, 0x44, 0x64, 0xB4,
+
+0x2A, 0x44, 0x54, 0xB6,
+0x1A, 0x44, 0x64, 0xB6,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x38, 0x3D, 0x20, 0xE9,
+
+0x0A, 0x20,
+0x02, 0x20,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x0A, 0x47, 0x57, 0xBF,
+0x02, 0x47, 0x67, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x46, 0x56, 0xBF,
+0x1A, 0x46, 0x66, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x36, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x37, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x53, 0xBF,
+0x1A, 0x43, 0x63, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x9D, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x9E, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x48, 0x58, 0xBF,
+0x02, 0x48, 0x68, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x2A, 0x49, 0x59, 0xBF,
+0x1A, 0x49, 0x69, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x82, 0x30, 0x57, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x83, 0x38, 0x57, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x84, 0x31, 0x5E, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x85, 0x39, 0x5E, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x87, 0x77, 0x57, 0xE9,
+0x8B, 0x3E, 0xBF, 0xEA,
+
+0x80, 0x30, 0x57, 0xE9,
+0x81, 0x38, 0x57, 0xE9,
+
+0x82, 0x31, 0x57, 0xE9,
+0x86, 0x78, 0x57, 0xE9,
+
+0x83, 0x39, 0x57, 0xE9,
+0x87, 0x79, 0x57, 0xE9,
+
+0x30, 0x1F, 0x5F, 0xE9,
+0x8A, 0x34, 0x20, 0xE9,
+
+0x8B, 0x3C, 0x20, 0xE9,
+0x37, 0x50, 0x60, 0xBD,
+
+0x57, 0x0D, 0x20, 0xE9,
+0x35, 0x51, 0x61, 0xBD,
+
+0x2B, 0x50, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x0E, 0x77,
+
+0x24, 0x51, 0x20, 0xE9,
+0x9B, 0xFF, 0x20, 0xEA,
+
+0x16, 0x0E, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x0B, 0x46, 0xA0, 0xE8,
+0x1B, 0x56, 0xA0, 0xE8,
+
+0x2B, 0x66, 0xA0, 0xE8,
+0x0C, 0x47, 0xA0, 0xE8,
+
+0x1C, 0x57, 0xA0, 0xE8,
+0x2C, 0x67, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x57, 0x80, 0x57, 0xCF,
+
+0x66, 0x33, 0x66, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x67, 0x3B, 0x67, 0xCF,
+
+0x0B, 0x48, 0xA0, 0xE8,
+0x1B, 0x58, 0xA0, 0xE8,
+
+0x2B, 0x68, 0xA0, 0xE8,
+0x0C, 0x49, 0xA0, 0xE8,
+
+0x1C, 0x59, 0xA0, 0xE8,
+0x2C, 0x69, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x34, 0xD7, 0x34, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3C, 0xD7, 0x3C, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x34, 0x80, 0x34, 0xBD,
+0x3C, 0x80, 0x3C, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x48, 0x80, 0x48, 0xCF,
+0x59, 0x80, 0x59, 0xCF,
+
+0x68, 0x33, 0x68, 0xCF,
+0x49, 0x3B, 0x49, 0xCF,
+
+0xBA, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x58, 0x33, 0x58, 0xCF,
+0x69, 0x3B, 0x69, 0xCF,
+
+0x79, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_t2gzaf[] = {
+
+0x00, 0x8A, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x0A, 0x40, 0x50, 0xBF,
+0x2A, 0x40, 0x60, 0xBF,
+
+0x32, 0x41, 0x51, 0xBF,
+0x3A, 0x41, 0x61, 0xBF,
+
+0xC3, 0x6B,
+0xD3, 0x6B,
+0x00, 0x8A, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x53, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x23, 0x9F,
+0x00, 0xE0,
+0x51, 0x04,
+
+0x90, 0xE2,
+0x61, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x51, 0x41, 0xE0, 0xEC,
+0x39, 0x67, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x63, 0xA0, 0xE8,
+
+0x61, 0x41, 0xE0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x81, 0x80, 0x15, 0xEA,
+0x10, 0x04,
+0x20, 0x04,
+
+0x61, 0x51, 0xE0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x52, 0xBF,
+0x0F, 0x52, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x62, 0xBF,
+0x1E, 0x51, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x0E, 0x61, 0x60, 0xEA,
+
+0x32, 0x40, 0x50, 0xBD,
+0x22, 0x40, 0x60, 0xBD,
+
+0x12, 0x41, 0x51, 0xBD,
+0x3A, 0x41, 0x61, 0xBD,
+
+0xBF, 0x2F, 0x0E, 0xBD,
+0x97, 0xE2,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x35, 0x48, 0xB1, 0xE8,
+0x3D, 0x59, 0xB1, 0xE8,
+
+0x46, 0x31, 0x46, 0xBF,
+0x56, 0x31, 0x56, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x66, 0x31, 0x66, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x57, 0x39, 0x57, 0xBF,
+0x67, 0x39, 0x67, 0xBF,
+
+0x72, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x35, 0x00,
+0x3D, 0x00,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0x8D, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x75, 0xF8, 0xEC,
+0x35, 0x20,
+0x3D, 0x20,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x53, 0x53, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x0E, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x48, 0x35, 0x48, 0xBF,
+0x58, 0x35, 0x58, 0xBF,
+
+0x68, 0x35, 0x68, 0xBF,
+0x49, 0x3D, 0x49, 0xBF,
+
+0x59, 0x3D, 0x59, 0xBF,
+0x69, 0x3D, 0x69, 0xBF,
+
+0x63, 0x63, 0x2D, 0xDF,
+0x4D, 0x7D, 0xF8, 0xEC,
+
+0x59, 0xE3,
+0x00, 0xE0,
+0xB8, 0x38, 0x33, 0xBF,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x18, 0x3A, 0x41, 0xE9,
+
+0x3F, 0x53, 0xA0, 0xE8,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x63, 0xA0, 0xE8,
+
+0x50, 0x70, 0xF8, 0xEC,
+0x2B, 0x50, 0x3C, 0xE9,
+
+0x1F, 0x0F, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x59, 0x78, 0xF8, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x46, 0x37, 0x46, 0xDF,
+0x56, 0x3F, 0x56, 0xDF,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x66, 0x3D, 0x66, 0xDF,
+
+0x1D, 0x32, 0x41, 0xE9,
+0x67, 0x3D, 0x67, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3F, 0x57, 0xDF,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x59, 0x3F, 0x59, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x69, 0x3D, 0x69, 0xDF,
+
+0x48, 0x37, 0x48, 0xDF,
+0x58, 0x3F, 0x58, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x68, 0x3D, 0x68, 0xDF,
+0x49, 0x37, 0x49, 0xDF,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x0A, 0x44, 0x54, 0xB0,
+0x02, 0x44, 0x64, 0xB0,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x34, 0x37, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x54, 0xB2,
+0x1A, 0x44, 0x64, 0xB2,
+
+0x2E, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x3D, 0xCF, 0x74, 0xC2,
+0x0F, 0xCF, 0x74, 0xC6,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9C, 0x0F, 0x20, 0xE9,
+
+0x0A, 0x44, 0x54, 0xB4,
+0x02, 0x44, 0x64, 0xB4,
+
+0x2A, 0x44, 0x54, 0xB6,
+0x1A, 0x44, 0x64, 0xB6,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x38, 0x3D, 0x20, 0xE9,
+
+0x0A, 0x20,
+0x02, 0x20,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x3D, 0xCF, 0x75, 0xC6,
+0x00, 0x80, 0x00, 0xE8,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x0A, 0x45, 0x55, 0xB6,
+0x02, 0x45, 0x65, 0xB6,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x31, 0x3D, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x2A, 0x46, 0x56, 0xBF,
+0x1A, 0x46, 0x66, 0xBF,
+
+0x0A, 0x47, 0x57, 0xBF,
+0x02, 0x47, 0x67, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x36, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x37, 0x38, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9D, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x9E, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x53, 0xBF,
+0x1A, 0x43, 0x63, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x35, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x39, 0x38, 0x4F, 0xE9,
+
+0x0A, 0x48, 0x58, 0xBF,
+0x02, 0x48, 0x68, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x2A, 0x49, 0x59, 0xBF,
+0x1A, 0x49, 0x69, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x82, 0x30, 0x57, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x83, 0x38, 0x57, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x84, 0x31, 0x5E, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x85, 0x39, 0x5E, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x87, 0x77, 0x57, 0xE9,
+0x8B, 0x3E, 0xBF, 0xEA,
+
+0x80, 0x30, 0x57, 0xE9,
+0x81, 0x38, 0x57, 0xE9,
+
+0x82, 0x31, 0x57, 0xE9,
+0x86, 0x78, 0x57, 0xE9,
+
+0x83, 0x39, 0x57, 0xE9,
+0x87, 0x79, 0x57, 0xE9,
+
+0x30, 0x1F, 0x5F, 0xE9,
+0x8A, 0x34, 0x20, 0xE9,
+
+0x8B, 0x3C, 0x20, 0xE9,
+0x37, 0x50, 0x60, 0xBD,
+
+0x57, 0x0D, 0x20, 0xE9,
+0x35, 0x51, 0x61, 0xBD,
+
+0x2B, 0x50, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x0E, 0x77,
+
+0x24, 0x51, 0x20, 0xE9,
+0x96, 0xFF, 0x20, 0xEA,
+
+0x16, 0x0E, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x0B, 0x46, 0xA0, 0xE8,
+0x1B, 0x56, 0xA0, 0xE8,
+
+0x2B, 0x66, 0xA0, 0xE8,
+0x0C, 0x47, 0xA0, 0xE8,
+
+0x1C, 0x57, 0xA0, 0xE8,
+0x2C, 0x67, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x57, 0x80, 0x57, 0xCF,
+
+0x66, 0x33, 0x66, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x67, 0x3B, 0x67, 0xCF,
+
+0x0B, 0x48, 0xA0, 0xE8,
+0x1B, 0x58, 0xA0, 0xE8,
+
+0x2B, 0x68, 0xA0, 0xE8,
+0x0C, 0x49, 0xA0, 0xE8,
+
+0x1C, 0x59, 0xA0, 0xE8,
+0x2C, 0x69, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x34, 0xD7, 0x34, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3C, 0xD7, 0x3C, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x34, 0x80, 0x34, 0xBD,
+0x3C, 0x80, 0x3C, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x48, 0x80, 0x48, 0xCF,
+0x59, 0x80, 0x59, 0xCF,
+
+0x68, 0x33, 0x68, 0xCF,
+0x49, 0x3B, 0x49, 0xCF,
+
+0xB5, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x58, 0x33, 0x58, 0xCF,
+0x69, 0x3B, 0x69, 0xCF,
+
+0x74, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_t2gzf[] = {
+
+0x00, 0x8A, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x0A, 0x40, 0x50, 0xBF,
+0x2A, 0x40, 0x60, 0xBF,
+
+0x32, 0x41, 0x51, 0xBF,
+0x3A, 0x41, 0x61, 0xBF,
+
+0xC3, 0x6B,
+0xD3, 0x6B,
+0x00, 0x8A, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x53, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x23, 0x9F,
+0x00, 0xE0,
+0x51, 0x04,
+
+0x90, 0xE2,
+0x61, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x51, 0x41, 0xE0, 0xEC,
+0x39, 0x67, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x63, 0xA0, 0xE8,
+
+0x61, 0x41, 0xE0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x7D, 0x80, 0x15, 0xEA,
+0x10, 0x04,
+0x20, 0x04,
+
+0x61, 0x51, 0xE0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x52, 0xBF,
+0x0F, 0x52, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x62, 0xBF,
+0x1E, 0x51, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x0E, 0x61, 0x60, 0xEA,
+
+0x32, 0x40, 0x50, 0xBD,
+0x22, 0x40, 0x60, 0xBD,
+
+0x12, 0x41, 0x51, 0xBD,
+0x3A, 0x41, 0x61, 0xBD,
+
+0xBF, 0x2F, 0x0E, 0xBD,
+0x97, 0xE2,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x35, 0x48, 0xB1, 0xE8,
+0x3D, 0x59, 0xB1, 0xE8,
+
+0x46, 0x31, 0x46, 0xBF,
+0x56, 0x31, 0x56, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x66, 0x31, 0x66, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x57, 0x39, 0x57, 0xBF,
+0x67, 0x39, 0x67, 0xBF,
+
+0x6E, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x35, 0x00,
+0x3D, 0x00,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0x8D, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x75, 0xF8, 0xEC,
+0x35, 0x20,
+0x3D, 0x20,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x53, 0x53, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x0E, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x48, 0x35, 0x48, 0xBF,
+0x58, 0x35, 0x58, 0xBF,
+
+0x68, 0x35, 0x68, 0xBF,
+0x49, 0x3D, 0x49, 0xBF,
+
+0x59, 0x3D, 0x59, 0xBF,
+0x69, 0x3D, 0x69, 0xBF,
+
+0x63, 0x63, 0x2D, 0xDF,
+0x4D, 0x7D, 0xF8, 0xEC,
+
+0x59, 0xE3,
+0x00, 0xE0,
+0xB8, 0x38, 0x33, 0xBF,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x18, 0x3A, 0x41, 0xE9,
+
+0x3F, 0x53, 0xA0, 0xE8,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x63, 0xA0, 0xE8,
+
+0x50, 0x70, 0xF8, 0xEC,
+0x2B, 0x50, 0x3C, 0xE9,
+
+0x1F, 0x0F, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x59, 0x78, 0xF8, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x46, 0x37, 0x46, 0xDF,
+0x56, 0x3F, 0x56, 0xDF,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x66, 0x3D, 0x66, 0xDF,
+
+0x1D, 0x32, 0x41, 0xE9,
+0x67, 0x3D, 0x67, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3F, 0x57, 0xDF,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x59, 0x3F, 0x59, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x69, 0x3D, 0x69, 0xDF,
+
+0x48, 0x37, 0x48, 0xDF,
+0x58, 0x3F, 0x58, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x68, 0x3D, 0x68, 0xDF,
+0x49, 0x37, 0x49, 0xDF,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x34, 0x80, 0x20, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x0F, 0xCF, 0x75, 0xC6,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x0A, 0x44, 0x54, 0xB0,
+0x02, 0x44, 0x64, 0xB0,
+
+0x2A, 0x44, 0x54, 0xB2,
+0x1A, 0x44, 0x64, 0xB2,
+
+0x28, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x3D, 0xCF, 0x74, 0xC2,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x31, 0x0F, 0x20, 0xE9,
+
+0x0A, 0x44, 0x54, 0xB4,
+0x02, 0x44, 0x64, 0xB4,
+
+0x2A, 0x45, 0x55, 0xB6,
+0x1A, 0x45, 0x65, 0xB6,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x38, 0x3D, 0x20, 0xE9,
+
+0x0A, 0x20,
+0x02, 0x20,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x0A, 0x47, 0x57, 0xBF,
+0x02, 0x47, 0x67, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x46, 0x56, 0xBF,
+0x1A, 0x46, 0x66, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x36, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x37, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x53, 0xBF,
+0x1A, 0x43, 0x63, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x35, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x39, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x48, 0x58, 0xBF,
+0x02, 0x48, 0x68, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x2A, 0x49, 0x59, 0xBF,
+0x1A, 0x49, 0x69, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x82, 0x30, 0x57, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x83, 0x38, 0x57, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x84, 0x31, 0x5E, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x85, 0x39, 0x5E, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x87, 0x77, 0x57, 0xE9,
+0x8B, 0x3E, 0xBF, 0xEA,
+
+0x80, 0x30, 0x57, 0xE9,
+0x81, 0x38, 0x57, 0xE9,
+
+0x82, 0x31, 0x57, 0xE9,
+0x86, 0x78, 0x57, 0xE9,
+
+0x83, 0x39, 0x57, 0xE9,
+0x87, 0x79, 0x57, 0xE9,
+
+0x30, 0x1F, 0x5F, 0xE9,
+0x8A, 0x34, 0x20, 0xE9,
+
+0x8B, 0x3C, 0x20, 0xE9,
+0x37, 0x50, 0x60, 0xBD,
+
+0x57, 0x0D, 0x20, 0xE9,
+0x35, 0x51, 0x61, 0xBD,
+
+0x2B, 0x50, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x0E, 0x77,
+
+0x24, 0x51, 0x20, 0xE9,
+0x9A, 0xFF, 0x20, 0xEA,
+
+0x16, 0x0E, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x0B, 0x46, 0xA0, 0xE8,
+0x1B, 0x56, 0xA0, 0xE8,
+
+0x2B, 0x66, 0xA0, 0xE8,
+0x0C, 0x47, 0xA0, 0xE8,
+
+0x1C, 0x57, 0xA0, 0xE8,
+0x2C, 0x67, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x57, 0x80, 0x57, 0xCF,
+
+0x66, 0x33, 0x66, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x67, 0x3B, 0x67, 0xCF,
+
+0x0B, 0x48, 0xA0, 0xE8,
+0x1B, 0x58, 0xA0, 0xE8,
+
+0x2B, 0x68, 0xA0, 0xE8,
+0x0C, 0x49, 0xA0, 0xE8,
+
+0x1C, 0x59, 0xA0, 0xE8,
+0x2C, 0x69, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x34, 0xD7, 0x34, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3C, 0xD7, 0x3C, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x34, 0x80, 0x34, 0xBD,
+0x3C, 0x80, 0x3C, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x48, 0x80, 0x48, 0xCF,
+0x59, 0x80, 0x59, 0xCF,
+
+0x68, 0x33, 0x68, 0xCF,
+0x49, 0x3B, 0x49, 0xCF,
+
+0xBB, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x58, 0x33, 0x58, 0xCF,
+0x69, 0x3B, 0x69, 0xCF,
+
+0x78, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_t2gzs[] = {
+
+0x00, 0x8A, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x0A, 0x40, 0x50, 0xBF,
+0x2A, 0x40, 0x60, 0xBF,
+
+0x32, 0x41, 0x51, 0xBF,
+0x3A, 0x41, 0x61, 0xBF,
+
+0xC3, 0x6B,
+0xD3, 0x6B,
+0x00, 0x8A, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x53, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x23, 0x9F,
+0x00, 0xE0,
+0x51, 0x04,
+
+0x90, 0xE2,
+0x61, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x51, 0x41, 0xE0, 0xEC,
+0x39, 0x67, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x63, 0xA0, 0xE8,
+
+0x61, 0x41, 0xE0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x85, 0x80, 0x15, 0xEA,
+0x10, 0x04,
+0x20, 0x04,
+
+0x61, 0x51, 0xE0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x52, 0xBF,
+0x0F, 0x52, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x62, 0xBF,
+0x1E, 0x51, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x0E, 0x61, 0x60, 0xEA,
+
+0x32, 0x40, 0x50, 0xBD,
+0x22, 0x40, 0x60, 0xBD,
+
+0x12, 0x41, 0x51, 0xBD,
+0x3A, 0x41, 0x61, 0xBD,
+
+0xBF, 0x2F, 0x0E, 0xBD,
+0x97, 0xE2,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x35, 0x48, 0xB1, 0xE8,
+0x3D, 0x59, 0xB1, 0xE8,
+
+0x46, 0x31, 0x46, 0xBF,
+0x56, 0x31, 0x56, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x66, 0x31, 0x66, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x57, 0x39, 0x57, 0xBF,
+0x67, 0x39, 0x67, 0xBF,
+
+0x76, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x35, 0x00,
+0x3D, 0x00,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0x8D, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x75, 0xF8, 0xEC,
+0x35, 0x20,
+0x3D, 0x20,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x53, 0x53, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x0E, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x48, 0x35, 0x48, 0xBF,
+0x58, 0x35, 0x58, 0xBF,
+
+0x68, 0x35, 0x68, 0xBF,
+0x49, 0x3D, 0x49, 0xBF,
+
+0x59, 0x3D, 0x59, 0xBF,
+0x69, 0x3D, 0x69, 0xBF,
+
+0x63, 0x63, 0x2D, 0xDF,
+0x4D, 0x7D, 0xF8, 0xEC,
+
+0x59, 0xE3,
+0x00, 0xE0,
+0xB8, 0x38, 0x33, 0xBF,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x18, 0x3A, 0x41, 0xE9,
+
+0x3F, 0x53, 0xA0, 0xE8,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x63, 0xA0, 0xE8,
+
+0x50, 0x70, 0xF8, 0xEC,
+0x2B, 0x50, 0x3C, 0xE9,
+
+0x1F, 0x0F, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x59, 0x78, 0xF8, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x46, 0x37, 0x46, 0xDF,
+0x56, 0x3F, 0x56, 0xDF,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x66, 0x3D, 0x66, 0xDF,
+
+0x1D, 0x32, 0x41, 0xE9,
+0x67, 0x3D, 0x67, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3F, 0x57, 0xDF,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x59, 0x3F, 0x59, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x69, 0x3D, 0x69, 0xDF,
+
+0x48, 0x37, 0x48, 0xDF,
+0x58, 0x3F, 0x58, 0xDF,
+
+0x68, 0x3D, 0x68, 0xDF,
+0x49, 0x37, 0x49, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x0F, 0xCF, 0x74, 0xC2,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x0A, 0x44, 0x54, 0xB0,
+0x02, 0x44, 0x64, 0xB0,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x34, 0x37, 0x20, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x38, 0x0F, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x54, 0xB2,
+0x1A, 0x44, 0x64, 0xB2,
+
+0x31, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x0F, 0xCF, 0x75, 0xC0,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x3D, 0xCF, 0x75, 0xC2,
+0x37, 0xCF, 0x75, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA6, 0x0F, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA3, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x54, 0xB4,
+0x1A, 0x44, 0x64, 0xB4,
+
+0x0A, 0x45, 0x55, 0xB0,
+0x02, 0x45, 0x65, 0xB0,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA0, 0x37, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x2A, 0x45, 0x55, 0xB2,
+0x1A, 0x45, 0x65, 0xB2,
+
+0x0A, 0x45, 0x55, 0xB4,
+0x02, 0x45, 0x65, 0xB4,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x20,
+0x1A, 0x20,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x2A, 0x46, 0x56, 0xBF,
+0x1A, 0x46, 0x66, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x36, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x37, 0x39, 0x4F, 0xE9,
+
+0x30, 0x50, 0x2E, 0x9F,
+0xA7, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0xA8, 0x38, 0x4F, 0xE9,
+
+0x0A, 0x47, 0x57, 0xBF,
+0x02, 0x47, 0x67, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA4, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA5, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x53, 0xBF,
+0x1A, 0x43, 0x63, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0xA1, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0xA2, 0x38, 0x4F, 0xE9,
+
+0x0A, 0x48, 0x58, 0xBF,
+0x02, 0x48, 0x68, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x2A, 0x49, 0x59, 0xBF,
+0x1A, 0x49, 0x69, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x82, 0x30, 0x57, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x83, 0x38, 0x57, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x84, 0x31, 0x5E, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x85, 0x39, 0x5E, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x87, 0x77, 0x57, 0xE9,
+0x8B, 0x3E, 0xBF, 0xEA,
+
+0x80, 0x30, 0x57, 0xE9,
+0x81, 0x38, 0x57, 0xE9,
+
+0x82, 0x31, 0x57, 0xE9,
+0x86, 0x78, 0x57, 0xE9,
+
+0x83, 0x39, 0x57, 0xE9,
+0x87, 0x79, 0x57, 0xE9,
+
+0x30, 0x1F, 0x5F, 0xE9,
+0x8A, 0x34, 0x20, 0xE9,
+
+0x8B, 0x3C, 0x20, 0xE9,
+0x37, 0x50, 0x60, 0xBD,
+
+0x57, 0x0D, 0x20, 0xE9,
+0x35, 0x51, 0x61, 0xBD,
+
+0x2B, 0x50, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x0E, 0x77,
+
+0x24, 0x51, 0x20, 0xE9,
+0x92, 0xFF, 0x20, 0xEA,
+
+0x16, 0x0E, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x0B, 0x46, 0xA0, 0xE8,
+0x1B, 0x56, 0xA0, 0xE8,
+
+0x2B, 0x66, 0xA0, 0xE8,
+0x0C, 0x47, 0xA0, 0xE8,
+
+0x1C, 0x57, 0xA0, 0xE8,
+0x2C, 0x67, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x57, 0x80, 0x57, 0xCF,
+
+0x66, 0x33, 0x66, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x67, 0x3B, 0x67, 0xCF,
+
+0x0B, 0x48, 0xA0, 0xE8,
+0x1B, 0x58, 0xA0, 0xE8,
+
+0x2B, 0x68, 0xA0, 0xE8,
+0x0C, 0x49, 0xA0, 0xE8,
+
+0x1C, 0x59, 0xA0, 0xE8,
+0x2C, 0x69, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x34, 0xD7, 0x34, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3C, 0xD7, 0x3C, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x34, 0x80, 0x34, 0xBD,
+0x3C, 0x80, 0x3C, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x48, 0x80, 0x48, 0xCF,
+0x59, 0x80, 0x59, 0xCF,
+
+0x68, 0x33, 0x68, 0xCF,
+0x49, 0x3B, 0x49, 0xCF,
+
+0xB2, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x58, 0x33, 0x58, 0xCF,
+0x69, 0x3B, 0x69, 0xCF,
+
+0x70, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_t2gzsa[] = {
+
+0x00, 0x8A, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x0A, 0x40, 0x50, 0xBF,
+0x2A, 0x40, 0x60, 0xBF,
+
+0x32, 0x41, 0x51, 0xBF,
+0x3A, 0x41, 0x61, 0xBF,
+
+0xC3, 0x6B,
+0xD3, 0x6B,
+0x00, 0x8A, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x53, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x23, 0x9F,
+0x00, 0xE0,
+0x51, 0x04,
+
+0x90, 0xE2,
+0x61, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x51, 0x41, 0xE0, 0xEC,
+0x39, 0x67, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x63, 0xA0, 0xE8,
+
+0x61, 0x41, 0xE0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x8A, 0x80, 0x15, 0xEA,
+0x10, 0x04,
+0x20, 0x04,
+
+0x61, 0x51, 0xE0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x52, 0xBF,
+0x0F, 0x52, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x62, 0xBF,
+0x1E, 0x51, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x0E, 0x61, 0x60, 0xEA,
+
+0x32, 0x40, 0x50, 0xBD,
+0x22, 0x40, 0x60, 0xBD,
+
+0x12, 0x41, 0x51, 0xBD,
+0x3A, 0x41, 0x61, 0xBD,
+
+0xBF, 0x2F, 0x0E, 0xBD,
+0x97, 0xE2,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x35, 0x48, 0xB1, 0xE8,
+0x3D, 0x59, 0xB1, 0xE8,
+
+0x46, 0x31, 0x46, 0xBF,
+0x56, 0x31, 0x56, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x66, 0x31, 0x66, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x57, 0x39, 0x57, 0xBF,
+0x67, 0x39, 0x67, 0xBF,
+
+0x7B, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x35, 0x00,
+0x3D, 0x00,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0x8D, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x75, 0xF8, 0xEC,
+0x35, 0x20,
+0x3D, 0x20,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x53, 0x53, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x0E, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x48, 0x35, 0x48, 0xBF,
+0x58, 0x35, 0x58, 0xBF,
+
+0x68, 0x35, 0x68, 0xBF,
+0x49, 0x3D, 0x49, 0xBF,
+
+0x59, 0x3D, 0x59, 0xBF,
+0x69, 0x3D, 0x69, 0xBF,
+
+0x63, 0x63, 0x2D, 0xDF,
+0x4D, 0x7D, 0xF8, 0xEC,
+
+0x59, 0xE3,
+0x00, 0xE0,
+0xB8, 0x38, 0x33, 0xBF,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x18, 0x3A, 0x41, 0xE9,
+
+0x3F, 0x53, 0xA0, 0xE8,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x63, 0xA0, 0xE8,
+
+0x50, 0x70, 0xF8, 0xEC,
+0x2B, 0x50, 0x3C, 0xE9,
+
+0x1F, 0x0F, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x59, 0x78, 0xF8, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x46, 0x37, 0x46, 0xDF,
+0x56, 0x3F, 0x56, 0xDF,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x66, 0x3D, 0x66, 0xDF,
+
+0x1D, 0x32, 0x41, 0xE9,
+0x67, 0x3D, 0x67, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3F, 0x57, 0xDF,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x59, 0x3F, 0x59, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x69, 0x3D, 0x69, 0xDF,
+
+0x48, 0x37, 0x48, 0xDF,
+0x58, 0x3F, 0x58, 0xDF,
+
+0x68, 0x3D, 0x68, 0xDF,
+0x49, 0x37, 0x49, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x0F, 0xCF, 0x74, 0xC2,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x0A, 0x44, 0x54, 0xB0,
+0x02, 0x44, 0x64, 0xB0,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x34, 0x37, 0x20, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x38, 0x0F, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x54, 0xB2,
+0x1A, 0x44, 0x64, 0xB2,
+
+0x36, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x0F, 0xCF, 0x75, 0xC0,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x3D, 0xCF, 0x75, 0xC2,
+0x37, 0xCF, 0x75, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA6, 0x0F, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA3, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x54, 0xB4,
+0x1A, 0x44, 0x64, 0xB4,
+
+0x0A, 0x45, 0x55, 0xB0,
+0x02, 0x45, 0x65, 0xB0,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA0, 0x37, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x45, 0x55, 0xB2,
+0x1A, 0x45, 0x65, 0xB2,
+
+0x0A, 0x45, 0x55, 0xB4,
+0x02, 0x45, 0x65, 0xB4,
+
+0x0F, 0xCF, 0x74, 0xC6,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA7, 0x30, 0x4F, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9C, 0x0F, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA8, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x44, 0x54, 0xB6,
+0x1A, 0x44, 0x64, 0xB6,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x36, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x37, 0x39, 0x4F, 0xE9,
+
+0x00, 0x80, 0x00, 0xE8,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x2A, 0x46, 0x56, 0xBF,
+0x1A, 0x46, 0x66, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA4, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA5, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x47, 0x57, 0xBF,
+0x02, 0x47, 0x67, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA1, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA2, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x53, 0xBF,
+0x1A, 0x43, 0x63, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x9D, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x9E, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x48, 0x58, 0xBF,
+0x02, 0x48, 0x68, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x2A, 0x49, 0x59, 0xBF,
+0x1A, 0x49, 0x69, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x82, 0x30, 0x57, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x83, 0x38, 0x57, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x84, 0x31, 0x5E, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x85, 0x39, 0x5E, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x87, 0x77, 0x57, 0xE9,
+0x8B, 0x3E, 0xBF, 0xEA,
+
+0x80, 0x30, 0x57, 0xE9,
+0x81, 0x38, 0x57, 0xE9,
+
+0x82, 0x31, 0x57, 0xE9,
+0x86, 0x78, 0x57, 0xE9,
+
+0x83, 0x39, 0x57, 0xE9,
+0x87, 0x79, 0x57, 0xE9,
+
+0x30, 0x1F, 0x5F, 0xE9,
+0x8A, 0x34, 0x20, 0xE9,
+
+0x8B, 0x3C, 0x20, 0xE9,
+0x37, 0x50, 0x60, 0xBD,
+
+0x57, 0x0D, 0x20, 0xE9,
+0x35, 0x51, 0x61, 0xBD,
+
+0x2B, 0x50, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x0E, 0x77,
+
+0x24, 0x51, 0x20, 0xE9,
+0x8D, 0xFF, 0x20, 0xEA,
+
+0x16, 0x0E, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x0B, 0x46, 0xA0, 0xE8,
+0x1B, 0x56, 0xA0, 0xE8,
+
+0x2B, 0x66, 0xA0, 0xE8,
+0x0C, 0x47, 0xA0, 0xE8,
+
+0x1C, 0x57, 0xA0, 0xE8,
+0x2C, 0x67, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x57, 0x80, 0x57, 0xCF,
+
+0x66, 0x33, 0x66, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x67, 0x3B, 0x67, 0xCF,
+
+0x0B, 0x48, 0xA0, 0xE8,
+0x1B, 0x58, 0xA0, 0xE8,
+
+0x2B, 0x68, 0xA0, 0xE8,
+0x0C, 0x49, 0xA0, 0xE8,
+
+0x1C, 0x59, 0xA0, 0xE8,
+0x2C, 0x69, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x34, 0xD7, 0x34, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3C, 0xD7, 0x3C, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x34, 0x80, 0x34, 0xBD,
+0x3C, 0x80, 0x3C, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x48, 0x80, 0x48, 0xCF,
+0x59, 0x80, 0x59, 0xCF,
+
+0x68, 0x33, 0x68, 0xCF,
+0x49, 0x3B, 0x49, 0xCF,
+
+0xAD, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x58, 0x33, 0x58, 0xCF,
+0x69, 0x3B, 0x69, 0xCF,
+
+0x6B, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_t2gzsaf[] = {
+
+0x00, 0x8A, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x0A, 0x40, 0x50, 0xBF,
+0x2A, 0x40, 0x60, 0xBF,
+
+0x32, 0x41, 0x51, 0xBF,
+0x3A, 0x41, 0x61, 0xBF,
+
+0xC3, 0x6B,
+0xD3, 0x6B,
+0x00, 0x8A, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x53, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x23, 0x9F,
+0x00, 0xE0,
+0x51, 0x04,
+
+0x90, 0xE2,
+0x61, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x51, 0x41, 0xE0, 0xEC,
+0x39, 0x67, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x63, 0xA0, 0xE8,
+
+0x61, 0x41, 0xE0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x8E, 0x80, 0x15, 0xEA,
+0x10, 0x04,
+0x20, 0x04,
+
+0x61, 0x51, 0xE0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x52, 0xBF,
+0x0F, 0x52, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x62, 0xBF,
+0x1E, 0x51, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x0E, 0x61, 0x60, 0xEA,
+
+0x32, 0x40, 0x50, 0xBD,
+0x22, 0x40, 0x60, 0xBD,
+
+0x12, 0x41, 0x51, 0xBD,
+0x3A, 0x41, 0x61, 0xBD,
+
+0xBF, 0x2F, 0x0E, 0xBD,
+0x97, 0xE2,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x35, 0x48, 0xB1, 0xE8,
+0x3D, 0x59, 0xB1, 0xE8,
+
+0x46, 0x31, 0x46, 0xBF,
+0x56, 0x31, 0x56, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x66, 0x31, 0x66, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x57, 0x39, 0x57, 0xBF,
+0x67, 0x39, 0x67, 0xBF,
+
+0x7F, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x35, 0x00,
+0x3D, 0x00,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0x8D, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x75, 0xF8, 0xEC,
+0x35, 0x20,
+0x3D, 0x20,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x53, 0x53, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x0E, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x48, 0x35, 0x48, 0xBF,
+0x58, 0x35, 0x58, 0xBF,
+
+0x68, 0x35, 0x68, 0xBF,
+0x49, 0x3D, 0x49, 0xBF,
+
+0x59, 0x3D, 0x59, 0xBF,
+0x69, 0x3D, 0x69, 0xBF,
+
+0x63, 0x63, 0x2D, 0xDF,
+0x4D, 0x7D, 0xF8, 0xEC,
+
+0x59, 0xE3,
+0x00, 0xE0,
+0xB8, 0x38, 0x33, 0xBF,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x18, 0x3A, 0x41, 0xE9,
+
+0x3F, 0x53, 0xA0, 0xE8,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x63, 0xA0, 0xE8,
+
+0x50, 0x70, 0xF8, 0xEC,
+0x2B, 0x50, 0x3C, 0xE9,
+
+0x1F, 0x0F, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x59, 0x78, 0xF8, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x46, 0x37, 0x46, 0xDF,
+0x56, 0x3F, 0x56, 0xDF,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x66, 0x3D, 0x66, 0xDF,
+
+0x1D, 0x32, 0x41, 0xE9,
+0x67, 0x3D, 0x67, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3F, 0x57, 0xDF,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x59, 0x3F, 0x59, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x69, 0x3D, 0x69, 0xDF,
+
+0x48, 0x37, 0x48, 0xDF,
+0x58, 0x3F, 0x58, 0xDF,
+
+0x68, 0x3D, 0x68, 0xDF,
+0x49, 0x37, 0x49, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x0F, 0xCF, 0x74, 0xC2,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x0A, 0x44, 0x54, 0xB0,
+0x02, 0x44, 0x64, 0xB0,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x34, 0x37, 0x20, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x38, 0x0F, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x54, 0xB2,
+0x1A, 0x44, 0x64, 0xB2,
+
+0x3A, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x0F, 0xCF, 0x75, 0xC0,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x3D, 0xCF, 0x75, 0xC2,
+0x37, 0xCF, 0x75, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA6, 0x0F, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA3, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x54, 0xB4,
+0x1A, 0x44, 0x64, 0xB4,
+
+0x0A, 0x45, 0x55, 0xB0,
+0x02, 0x45, 0x65, 0xB0,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA0, 0x37, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x45, 0x55, 0xB2,
+0x1A, 0x45, 0x65, 0xB2,
+
+0x0A, 0x45, 0x55, 0xB4,
+0x02, 0x45, 0x65, 0xB4,
+
+0x0F, 0xCF, 0x74, 0xC6,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA7, 0x30, 0x4F, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9C, 0x0F, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA8, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x44, 0x54, 0xB6,
+0x1A, 0x44, 0x64, 0xB6,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x36, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x37, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x45, 0x55, 0xB6,
+0x02, 0x45, 0x65, 0xB6,
+
+0x3D, 0xCF, 0x75, 0xC6,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x2A, 0x46, 0x56, 0xBF,
+0x1A, 0x46, 0x66, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA4, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA5, 0x39, 0x4F, 0xE9,
+
+0x31, 0x3D, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x0A, 0x47, 0x57, 0xBF,
+0x02, 0x47, 0x67, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0xA1, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0xA2, 0x38, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9D, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x9E, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x53, 0xBF,
+0x1A, 0x43, 0x63, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x35, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x39, 0x38, 0x4F, 0xE9,
+
+0x0A, 0x48, 0x58, 0xBF,
+0x02, 0x48, 0x68, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x2A, 0x49, 0x59, 0xBF,
+0x1A, 0x49, 0x69, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x82, 0x30, 0x57, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x83, 0x38, 0x57, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x84, 0x31, 0x5E, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x85, 0x39, 0x5E, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x87, 0x77, 0x57, 0xE9,
+0x8B, 0x3E, 0xBF, 0xEA,
+
+0x80, 0x30, 0x57, 0xE9,
+0x81, 0x38, 0x57, 0xE9,
+
+0x82, 0x31, 0x57, 0xE9,
+0x86, 0x78, 0x57, 0xE9,
+
+0x83, 0x39, 0x57, 0xE9,
+0x87, 0x79, 0x57, 0xE9,
+
+0x30, 0x1F, 0x5F, 0xE9,
+0x8A, 0x34, 0x20, 0xE9,
+
+0x8B, 0x3C, 0x20, 0xE9,
+0x37, 0x50, 0x60, 0xBD,
+
+0x57, 0x0D, 0x20, 0xE9,
+0x35, 0x51, 0x61, 0xBD,
+
+0x2B, 0x50, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x0E, 0x77,
+
+0x24, 0x51, 0x20, 0xE9,
+0x89, 0xFF, 0x20, 0xEA,
+
+0x16, 0x0E, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x0B, 0x46, 0xA0, 0xE8,
+0x1B, 0x56, 0xA0, 0xE8,
+
+0x2B, 0x66, 0xA0, 0xE8,
+0x0C, 0x47, 0xA0, 0xE8,
+
+0x1C, 0x57, 0xA0, 0xE8,
+0x2C, 0x67, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x57, 0x80, 0x57, 0xCF,
+
+0x66, 0x33, 0x66, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x67, 0x3B, 0x67, 0xCF,
+
+0x0B, 0x48, 0xA0, 0xE8,
+0x1B, 0x58, 0xA0, 0xE8,
+
+0x2B, 0x68, 0xA0, 0xE8,
+0x0C, 0x49, 0xA0, 0xE8,
+
+0x1C, 0x59, 0xA0, 0xE8,
+0x2C, 0x69, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x34, 0xD7, 0x34, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3C, 0xD7, 0x3C, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x34, 0x80, 0x34, 0xBD,
+0x3C, 0x80, 0x3C, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x48, 0x80, 0x48, 0xCF,
+0x59, 0x80, 0x59, 0xCF,
+
+0x68, 0x33, 0x68, 0xCF,
+0x49, 0x3B, 0x49, 0xCF,
+
+0xA9, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x58, 0x33, 0x58, 0xCF,
+0x69, 0x3B, 0x69, 0xCF,
+
+0x67, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_t2gzsf[] = {
+
+0x00, 0x8A, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x0A, 0x40, 0x50, 0xBF,
+0x2A, 0x40, 0x60, 0xBF,
+
+0x32, 0x41, 0x51, 0xBF,
+0x3A, 0x41, 0x61, 0xBF,
+
+0xC3, 0x6B,
+0xD3, 0x6B,
+0x00, 0x8A, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x53, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x23, 0x9F,
+0x00, 0xE0,
+0x51, 0x04,
+
+0x90, 0xE2,
+0x61, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x51, 0x41, 0xE0, 0xEC,
+0x39, 0x67, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x63, 0xA0, 0xE8,
+
+0x61, 0x41, 0xE0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x8A, 0x80, 0x15, 0xEA,
+0x10, 0x04,
+0x20, 0x04,
+
+0x61, 0x51, 0xE0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x52, 0xBF,
+0x0F, 0x52, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x62, 0xBF,
+0x1E, 0x51, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x0E, 0x61, 0x60, 0xEA,
+
+0x32, 0x40, 0x50, 0xBD,
+0x22, 0x40, 0x60, 0xBD,
+
+0x12, 0x41, 0x51, 0xBD,
+0x3A, 0x41, 0x61, 0xBD,
+
+0xBF, 0x2F, 0x0E, 0xBD,
+0x97, 0xE2,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x35, 0x48, 0xB1, 0xE8,
+0x3D, 0x59, 0xB1, 0xE8,
+
+0x46, 0x31, 0x46, 0xBF,
+0x56, 0x31, 0x56, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x66, 0x31, 0x66, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x57, 0x39, 0x57, 0xBF,
+0x67, 0x39, 0x67, 0xBF,
+
+0x7B, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x35, 0x00,
+0x3D, 0x00,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0x8D, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x75, 0xF8, 0xEC,
+0x35, 0x20,
+0x3D, 0x20,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x53, 0x53, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x0E, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x48, 0x35, 0x48, 0xBF,
+0x58, 0x35, 0x58, 0xBF,
+
+0x68, 0x35, 0x68, 0xBF,
+0x49, 0x3D, 0x49, 0xBF,
+
+0x59, 0x3D, 0x59, 0xBF,
+0x69, 0x3D, 0x69, 0xBF,
+
+0x63, 0x63, 0x2D, 0xDF,
+0x4D, 0x7D, 0xF8, 0xEC,
+
+0x59, 0xE3,
+0x00, 0xE0,
+0xB8, 0x38, 0x33, 0xBF,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x18, 0x3A, 0x41, 0xE9,
+
+0x3F, 0x53, 0xA0, 0xE8,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x63, 0xA0, 0xE8,
+
+0x50, 0x70, 0xF8, 0xEC,
+0x2B, 0x50, 0x3C, 0xE9,
+
+0x1F, 0x0F, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x59, 0x78, 0xF8, 0xEC,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x46, 0x37, 0x46, 0xDF,
+0x56, 0x3F, 0x56, 0xDF,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x66, 0x3D, 0x66, 0xDF,
+
+0x1D, 0x32, 0x41, 0xE9,
+0x67, 0x3D, 0x67, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3F, 0x57, 0xDF,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x59, 0x3F, 0x59, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x69, 0x3D, 0x69, 0xDF,
+
+0x48, 0x37, 0x48, 0xDF,
+0x58, 0x3F, 0x58, 0xDF,
+
+0x68, 0x3D, 0x68, 0xDF,
+0x49, 0x37, 0x49, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x0F, 0xCF, 0x74, 0xC2,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x0A, 0x44, 0x54, 0xB0,
+0x02, 0x44, 0x64, 0xB0,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x34, 0x37, 0x20, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x38, 0x0F, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x54, 0xB2,
+0x1A, 0x44, 0x64, 0xB2,
+
+0x36, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x0F, 0xCF, 0x75, 0xC0,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x3D, 0xCF, 0x75, 0xC2,
+0x37, 0xCF, 0x75, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA6, 0x0F, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA3, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x54, 0xB4,
+0x1A, 0x44, 0x64, 0xB4,
+
+0x0A, 0x45, 0x55, 0xB0,
+0x02, 0x45, 0x65, 0xB0,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA0, 0x37, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x45, 0x55, 0xB2,
+0x1A, 0x45, 0x65, 0xB2,
+
+0x0A, 0x45, 0x55, 0xB4,
+0x02, 0x45, 0x65, 0xB4,
+
+0x0F, 0xCF, 0x75, 0xC6,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA7, 0x30, 0x4F, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x31, 0x0F, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA8, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x45, 0x55, 0xB6,
+0x1A, 0x45, 0x65, 0xB6,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x36, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x37, 0x39, 0x4F, 0xE9,
+
+0x00, 0x80, 0x00, 0xE8,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x2A, 0x46, 0x56, 0xBF,
+0x1A, 0x46, 0x66, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA4, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA5, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x47, 0x57, 0xBF,
+0x02, 0x47, 0x67, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA1, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA2, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x53, 0xBF,
+0x1A, 0x43, 0x63, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x35, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x39, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x48, 0x58, 0xBF,
+0x02, 0x48, 0x68, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x2A, 0x49, 0x59, 0xBF,
+0x1A, 0x49, 0x69, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x82, 0x30, 0x57, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x83, 0x38, 0x57, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x84, 0x31, 0x5E, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x85, 0x39, 0x5E, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x87, 0x77, 0x57, 0xE9,
+0x8B, 0x3E, 0xBF, 0xEA,
+
+0x80, 0x30, 0x57, 0xE9,
+0x81, 0x38, 0x57, 0xE9,
+
+0x82, 0x31, 0x57, 0xE9,
+0x86, 0x78, 0x57, 0xE9,
+
+0x83, 0x39, 0x57, 0xE9,
+0x87, 0x79, 0x57, 0xE9,
+
+0x30, 0x1F, 0x5F, 0xE9,
+0x8A, 0x34, 0x20, 0xE9,
+
+0x8B, 0x3C, 0x20, 0xE9,
+0x37, 0x50, 0x60, 0xBD,
+
+0x57, 0x0D, 0x20, 0xE9,
+0x35, 0x51, 0x61, 0xBD,
+
+0x2B, 0x50, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x0E, 0x77,
+
+0x24, 0x51, 0x20, 0xE9,
+0x8D, 0xFF, 0x20, 0xEA,
+
+0x16, 0x0E, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x0B, 0x46, 0xA0, 0xE8,
+0x1B, 0x56, 0xA0, 0xE8,
+
+0x2B, 0x66, 0xA0, 0xE8,
+0x0C, 0x47, 0xA0, 0xE8,
+
+0x1C, 0x57, 0xA0, 0xE8,
+0x2C, 0x67, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x57, 0x80, 0x57, 0xCF,
+
+0x66, 0x33, 0x66, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x67, 0x3B, 0x67, 0xCF,
+
+0x0B, 0x48, 0xA0, 0xE8,
+0x1B, 0x58, 0xA0, 0xE8,
+
+0x2B, 0x68, 0xA0, 0xE8,
+0x0C, 0x49, 0xA0, 0xE8,
+
+0x1C, 0x59, 0xA0, 0xE8,
+0x2C, 0x69, 0xA0, 0xE8,
+
+0x0B, 0x00,
+0x1B, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x0C, 0x00,
+0x1C, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x0B, 0x65,
+0x1B, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x0C, 0x65,
+0x1C, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x0B, 0x1B, 0x60, 0xEC,
+0x34, 0xD7, 0x34, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x0C, 0x1C, 0x60, 0xEC,
+
+0x3C, 0xD7, 0x3C, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x0B, 0x2B, 0xDE, 0xE8,
+0x1B, 0x80, 0xDE, 0xE8,
+
+0x34, 0x80, 0x34, 0xBD,
+0x3C, 0x80, 0x3C, 0xBD,
+
+0x33, 0xD7, 0x0B, 0xBD,
+0x3B, 0xD7, 0x1B, 0xBD,
+
+0x48, 0x80, 0x48, 0xCF,
+0x59, 0x80, 0x59, 0xCF,
+
+0x68, 0x33, 0x68, 0xCF,
+0x49, 0x3B, 0x49, 0xCF,
+
+0xAD, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x58, 0x33, 0x58, 0xCF,
+0x69, 0x3B, 0x69, 0xCF,
+
+0x6B, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_tgz[] = {
+
+0x00, 0x88, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x22, 0x40, 0x48, 0xBF,
+0x2A, 0x40, 0x50, 0xBF,
+
+0x32, 0x41, 0x49, 0xBF,
+0x3A, 0x41, 0x51, 0xBF,
+
+0xC3, 0x6B,
+0xCB, 0x6B,
+0x00, 0x88, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x4B, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x29, 0x9F,
+0x00, 0xE0,
+0x49, 0x04,
+
+0x90, 0xE2,
+0x51, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x49, 0x41, 0xC0, 0xEC,
+0x39, 0x57, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x53, 0xA0, 0xE8,
+
+0x51, 0x41, 0xC0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x58, 0x80, 0x15, 0xEA,
+0x08, 0x04,
+0x10, 0x04,
+
+0x51, 0x49, 0xC0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x4A, 0xBF,
+0x27, 0x4A, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x52, 0xBF,
+0x1E, 0x49, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x26, 0x51, 0x60, 0xEA,
+
+0x32, 0x40, 0x48, 0xBD,
+0x22, 0x40, 0x50, 0xBD,
+
+0x12, 0x41, 0x49, 0xBD,
+0x3A, 0x41, 0x51, 0xBD,
+
+0xBF, 0x2F, 0x26, 0xBD,
+0x00, 0xE0,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x46, 0x31, 0x46, 0xBF,
+0x4E, 0x31, 0x4E, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x56, 0x31, 0x56, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x4F, 0x39, 0x4F, 0xBF,
+0x57, 0x39, 0x57, 0xBF,
+
+0x4A, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x42, 0x73, 0xF8, 0xEC,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0xA5, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x4B, 0x4B, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x26, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x53, 0x53, 0x2D, 0xDF,
+0x00, 0x80, 0x00, 0xE8,
+
+0xB8, 0x38, 0x33, 0xBF,
+0x00, 0xE0,
+0x59, 0xE3,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x3F, 0x4B, 0xA0, 0xE8,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x53, 0xA0, 0xE8,
+
+0x48, 0x70, 0xF8, 0xEC,
+0x2B, 0x48, 0x3C, 0xE9,
+
+0x1F, 0x27, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x18, 0x3A, 0x41, 0xE9,
+0x1D, 0x32, 0x41, 0xE9,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x56, 0x3D, 0x56, 0xDF,
+
+0x46, 0x37, 0x46, 0xDF,
+0x4E, 0x3F, 0x4E, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x4F, 0x3F, 0x4F, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3D, 0x57, 0xDF,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x34, 0x80, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x0A, 0x44, 0x4C, 0xB0,
+0x02, 0x44, 0x54, 0xB0,
+
+0x2A, 0x44, 0x4C, 0xB2,
+0x1A, 0x44, 0x54, 0xB2,
+
+0x1D, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x3D, 0xCF, 0x74, 0xC2,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x2A, 0x44, 0x4C, 0xB4,
+0x1A, 0x44, 0x54, 0xB4,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x38, 0x3D, 0x20, 0xE9,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x2A, 0x46, 0x4E, 0xBF,
+0x1A, 0x46, 0x56, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x0A, 0x47, 0x4F, 0xBF,
+0x02, 0x47, 0x57, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x4B, 0xBF,
+0x1A, 0x43, 0x53, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x36, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x37, 0x39, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x37, 0x48, 0x50, 0xBD,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8B, 0x3E, 0x20, 0xE9,
+
+0x82, 0x30, 0x57, 0xE9,
+0x87, 0x77, 0x57, 0xE9,
+
+0x83, 0x38, 0x57, 0xE9,
+0x35, 0x49, 0x51, 0xBD,
+
+0x84, 0x31, 0x5E, 0xE9,
+0x30, 0x1F, 0x5F, 0xE9,
+
+0x85, 0x39, 0x5E, 0xE9,
+0x57, 0x25, 0x20, 0xE9,
+
+0x2B, 0x48, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x26, 0x77,
+
+0x24, 0x49, 0x20, 0xE9,
+0xAF, 0xFF, 0x20, 0xEA,
+
+0x16, 0x26, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x1C, 0x46, 0xA0, 0xE8,
+0x23, 0x4E, 0xA0, 0xE8,
+
+0x2B, 0x56, 0xA0, 0xE8,
+0x1D, 0x47, 0xA0, 0xE8,
+
+0x24, 0x4F, 0xA0, 0xE8,
+0x2C, 0x57, 0xA0, 0xE8,
+
+0x1C, 0x00,
+0x23, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x1D, 0x00,
+0x24, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x1C, 0x65,
+0x23, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x1D, 0x65,
+0x24, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x1C, 0x23, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x1D, 0x24, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x1C, 0x2B, 0xDE, 0xE8,
+0x23, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x1C, 0xBD,
+0x3B, 0xD7, 0x23, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x4F, 0x80, 0x4F, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0xD6, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x4E, 0x33, 0x4E, 0xCF,
+0x57, 0x3B, 0x57, 0xCF,
+
+0x9D, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_tgza[] = {
+
+0x00, 0x88, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x22, 0x40, 0x48, 0xBF,
+0x2A, 0x40, 0x50, 0xBF,
+
+0x32, 0x41, 0x49, 0xBF,
+0x3A, 0x41, 0x51, 0xBF,
+
+0xC3, 0x6B,
+0xCB, 0x6B,
+0x00, 0x88, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x4B, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x29, 0x9F,
+0x00, 0xE0,
+0x49, 0x04,
+
+0x90, 0xE2,
+0x51, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x49, 0x41, 0xC0, 0xEC,
+0x39, 0x57, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x53, 0xA0, 0xE8,
+
+0x51, 0x41, 0xC0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x5C, 0x80, 0x15, 0xEA,
+0x08, 0x04,
+0x10, 0x04,
+
+0x51, 0x49, 0xC0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x4A, 0xBF,
+0x27, 0x4A, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x52, 0xBF,
+0x1E, 0x49, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x26, 0x51, 0x60, 0xEA,
+
+0x32, 0x40, 0x48, 0xBD,
+0x22, 0x40, 0x50, 0xBD,
+
+0x12, 0x41, 0x49, 0xBD,
+0x3A, 0x41, 0x51, 0xBD,
+
+0xBF, 0x2F, 0x26, 0xBD,
+0x00, 0xE0,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x46, 0x31, 0x46, 0xBF,
+0x4E, 0x31, 0x4E, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x56, 0x31, 0x56, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x4F, 0x39, 0x4F, 0xBF,
+0x57, 0x39, 0x57, 0xBF,
+
+0x4E, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x42, 0x73, 0xF8, 0xEC,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0xA5, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x4B, 0x4B, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x26, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x53, 0x53, 0x2D, 0xDF,
+0x00, 0x80, 0x00, 0xE8,
+
+0xB8, 0x38, 0x33, 0xBF,
+0x00, 0xE0,
+0x59, 0xE3,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x3F, 0x4B, 0xA0, 0xE8,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x53, 0xA0, 0xE8,
+
+0x48, 0x70, 0xF8, 0xEC,
+0x2B, 0x48, 0x3C, 0xE9,
+
+0x1F, 0x27, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x18, 0x3A, 0x41, 0xE9,
+0x1D, 0x32, 0x41, 0xE9,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x56, 0x3D, 0x56, 0xDF,
+
+0x46, 0x37, 0x46, 0xDF,
+0x4E, 0x3F, 0x4E, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x4F, 0x3F, 0x4F, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3D, 0x57, 0xDF,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x34, 0x80, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x27, 0xCF, 0x74, 0xC6,
+0x3D, 0xCF, 0x74, 0xC2,
+
+0x0A, 0x44, 0x4C, 0xB0,
+0x02, 0x44, 0x54, 0xB0,
+
+0x2A, 0x44, 0x4C, 0xB2,
+0x1A, 0x44, 0x54, 0xB2,
+
+0x20, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9C, 0x27, 0x20, 0xE9,
+
+0x0A, 0x44, 0x4C, 0xB4,
+0x02, 0x44, 0x54, 0xB4,
+
+0x2A, 0x44, 0x4C, 0xB6,
+0x1A, 0x44, 0x54, 0xB6,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x38, 0x3D, 0x20, 0xE9,
+
+0x0A, 0x20,
+0x02, 0x20,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x0A, 0x47, 0x4F, 0xBF,
+0x02, 0x47, 0x57, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x46, 0x4E, 0xBF,
+0x1A, 0x46, 0x56, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x36, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x37, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x4B, 0xBF,
+0x1A, 0x43, 0x53, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x9D, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x9E, 0x39, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x37, 0x48, 0x50, 0xBD,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8B, 0x3E, 0x20, 0xE9,
+
+0x82, 0x30, 0x57, 0xE9,
+0x87, 0x77, 0x57, 0xE9,
+
+0x83, 0x38, 0x57, 0xE9,
+0x35, 0x49, 0x51, 0xBD,
+
+0x84, 0x31, 0x5E, 0xE9,
+0x30, 0x1F, 0x5F, 0xE9,
+
+0x85, 0x39, 0x5E, 0xE9,
+0x57, 0x25, 0x20, 0xE9,
+
+0x2B, 0x48, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x26, 0x77,
+
+0x24, 0x49, 0x20, 0xE9,
+0xAB, 0xFF, 0x20, 0xEA,
+
+0x16, 0x26, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x1C, 0x46, 0xA0, 0xE8,
+0x23, 0x4E, 0xA0, 0xE8,
+
+0x2B, 0x56, 0xA0, 0xE8,
+0x1D, 0x47, 0xA0, 0xE8,
+
+0x24, 0x4F, 0xA0, 0xE8,
+0x2C, 0x57, 0xA0, 0xE8,
+
+0x1C, 0x00,
+0x23, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x1D, 0x00,
+0x24, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x1C, 0x65,
+0x23, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x1D, 0x65,
+0x24, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x1C, 0x23, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x1D, 0x24, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x1C, 0x2B, 0xDE, 0xE8,
+0x23, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x1C, 0xBD,
+0x3B, 0xD7, 0x23, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x4F, 0x80, 0x4F, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0xD3, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x4E, 0x33, 0x4E, 0xCF,
+0x57, 0x3B, 0x57, 0xCF,
+
+0x99, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_tgzaf[] = {
+
+0x00, 0x88, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x22, 0x40, 0x48, 0xBF,
+0x2A, 0x40, 0x50, 0xBF,
+
+0x32, 0x41, 0x49, 0xBF,
+0x3A, 0x41, 0x51, 0xBF,
+
+0xC3, 0x6B,
+0xCB, 0x6B,
+0x00, 0x88, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x4B, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x29, 0x9F,
+0x00, 0xE0,
+0x49, 0x04,
+
+0x90, 0xE2,
+0x51, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x49, 0x41, 0xC0, 0xEC,
+0x39, 0x57, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x53, 0xA0, 0xE8,
+
+0x51, 0x41, 0xC0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x61, 0x80, 0x15, 0xEA,
+0x08, 0x04,
+0x10, 0x04,
+
+0x51, 0x49, 0xC0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x4A, 0xBF,
+0x27, 0x4A, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x52, 0xBF,
+0x1E, 0x49, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x26, 0x51, 0x60, 0xEA,
+
+0x32, 0x40, 0x48, 0xBD,
+0x22, 0x40, 0x50, 0xBD,
+
+0x12, 0x41, 0x49, 0xBD,
+0x3A, 0x41, 0x51, 0xBD,
+
+0xBF, 0x2F, 0x26, 0xBD,
+0x00, 0xE0,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x46, 0x31, 0x46, 0xBF,
+0x4E, 0x31, 0x4E, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x56, 0x31, 0x56, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x4F, 0x39, 0x4F, 0xBF,
+0x57, 0x39, 0x57, 0xBF,
+
+0x53, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x42, 0x73, 0xF8, 0xEC,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0xA5, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x4B, 0x4B, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x26, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x53, 0x53, 0x2D, 0xDF,
+0x00, 0x80, 0x00, 0xE8,
+
+0xB8, 0x38, 0x33, 0xBF,
+0x00, 0xE0,
+0x59, 0xE3,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x3F, 0x4B, 0xA0, 0xE8,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x53, 0xA0, 0xE8,
+
+0x48, 0x70, 0xF8, 0xEC,
+0x2B, 0x48, 0x3C, 0xE9,
+
+0x1F, 0x27, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x18, 0x3A, 0x41, 0xE9,
+0x1D, 0x32, 0x41, 0xE9,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x56, 0x3D, 0x56, 0xDF,
+
+0x46, 0x37, 0x46, 0xDF,
+0x4E, 0x3F, 0x4E, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x4F, 0x3F, 0x4F, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3D, 0x57, 0xDF,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x0A, 0x44, 0x4C, 0xB0,
+0x02, 0x44, 0x54, 0xB0,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x34, 0x37, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x4C, 0xB2,
+0x1A, 0x44, 0x54, 0xB2,
+
+0x26, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x3D, 0xCF, 0x74, 0xC2,
+0x27, 0xCF, 0x74, 0xC6,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9C, 0x27, 0x20, 0xE9,
+
+0x0A, 0x44, 0x4C, 0xB4,
+0x02, 0x44, 0x54, 0xB4,
+
+0x2A, 0x44, 0x4C, 0xB6,
+0x1A, 0x44, 0x54, 0xB6,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x38, 0x3D, 0x20, 0xE9,
+
+0x0A, 0x20,
+0x02, 0x20,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x3D, 0xCF, 0x75, 0xC6,
+0x00, 0x80, 0x00, 0xE8,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x0A, 0x45, 0x4D, 0xB6,
+0x02, 0x45, 0x55, 0xB6,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x31, 0x3D, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x2A, 0x46, 0x4E, 0xBF,
+0x1A, 0x46, 0x56, 0xBF,
+
+0x0A, 0x47, 0x4F, 0xBF,
+0x02, 0x47, 0x57, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x36, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x37, 0x38, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9D, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x9E, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x4B, 0xBF,
+0x1A, 0x43, 0x53, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x35, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x39, 0x38, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x37, 0x48, 0x50, 0xBD,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8B, 0x3E, 0x20, 0xE9,
+
+0x82, 0x30, 0x57, 0xE9,
+0x87, 0x77, 0x57, 0xE9,
+
+0x83, 0x38, 0x57, 0xE9,
+0x35, 0x49, 0x51, 0xBD,
+
+0x84, 0x31, 0x5E, 0xE9,
+0x30, 0x1F, 0x5F, 0xE9,
+
+0x85, 0x39, 0x5E, 0xE9,
+0x57, 0x25, 0x20, 0xE9,
+
+0x2B, 0x48, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x26, 0x77,
+
+0x24, 0x49, 0x20, 0xE9,
+0xA6, 0xFF, 0x20, 0xEA,
+
+0x16, 0x26, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x1C, 0x46, 0xA0, 0xE8,
+0x23, 0x4E, 0xA0, 0xE8,
+
+0x2B, 0x56, 0xA0, 0xE8,
+0x1D, 0x47, 0xA0, 0xE8,
+
+0x24, 0x4F, 0xA0, 0xE8,
+0x2C, 0x57, 0xA0, 0xE8,
+
+0x1C, 0x00,
+0x23, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x1D, 0x00,
+0x24, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x1C, 0x65,
+0x23, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x1D, 0x65,
+0x24, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x1C, 0x23, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x1D, 0x24, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x1C, 0x2B, 0xDE, 0xE8,
+0x23, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x1C, 0xBD,
+0x3B, 0xD7, 0x23, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x4F, 0x80, 0x4F, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0xCD, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x4E, 0x33, 0x4E, 0xCF,
+0x57, 0x3B, 0x57, 0xCF,
+
+0x94, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_tgzf[] = {
+
+0x00, 0x88, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x22, 0x40, 0x48, 0xBF,
+0x2A, 0x40, 0x50, 0xBF,
+
+0x32, 0x41, 0x49, 0xBF,
+0x3A, 0x41, 0x51, 0xBF,
+
+0xC3, 0x6B,
+0xCB, 0x6B,
+0x00, 0x88, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x4B, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x29, 0x9F,
+0x00, 0xE0,
+0x49, 0x04,
+
+0x90, 0xE2,
+0x51, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x49, 0x41, 0xC0, 0xEC,
+0x39, 0x57, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x53, 0xA0, 0xE8,
+
+0x51, 0x41, 0xC0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x5D, 0x80, 0x15, 0xEA,
+0x08, 0x04,
+0x10, 0x04,
+
+0x51, 0x49, 0xC0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x4A, 0xBF,
+0x27, 0x4A, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x52, 0xBF,
+0x1E, 0x49, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x26, 0x51, 0x60, 0xEA,
+
+0x32, 0x40, 0x48, 0xBD,
+0x22, 0x40, 0x50, 0xBD,
+
+0x12, 0x41, 0x49, 0xBD,
+0x3A, 0x41, 0x51, 0xBD,
+
+0xBF, 0x2F, 0x26, 0xBD,
+0x00, 0xE0,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x46, 0x31, 0x46, 0xBF,
+0x4E, 0x31, 0x4E, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x56, 0x31, 0x56, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x4F, 0x39, 0x4F, 0xBF,
+0x57, 0x39, 0x57, 0xBF,
+
+0x4F, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x42, 0x73, 0xF8, 0xEC,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0xA5, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x4B, 0x4B, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x26, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x53, 0x53, 0x2D, 0xDF,
+0x00, 0x80, 0x00, 0xE8,
+
+0xB8, 0x38, 0x33, 0xBF,
+0x00, 0xE0,
+0x59, 0xE3,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x3F, 0x4B, 0xA0, 0xE8,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x53, 0xA0, 0xE8,
+
+0x48, 0x70, 0xF8, 0xEC,
+0x2B, 0x48, 0x3C, 0xE9,
+
+0x1F, 0x27, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x18, 0x3A, 0x41, 0xE9,
+0x1D, 0x32, 0x41, 0xE9,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x56, 0x3D, 0x56, 0xDF,
+
+0x46, 0x37, 0x46, 0xDF,
+0x4E, 0x3F, 0x4E, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x4F, 0x3F, 0x4F, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3D, 0x57, 0xDF,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x34, 0x80, 0x20, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x27, 0xCF, 0x75, 0xC6,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x0A, 0x44, 0x4C, 0xB0,
+0x02, 0x44, 0x54, 0xB0,
+
+0x2A, 0x44, 0x4C, 0xB2,
+0x1A, 0x44, 0x54, 0xB2,
+
+0x20, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x3D, 0xCF, 0x74, 0xC2,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x31, 0x27, 0x20, 0xE9,
+
+0x0A, 0x44, 0x4C, 0xB4,
+0x02, 0x44, 0x54, 0xB4,
+
+0x2A, 0x45, 0x4D, 0xB6,
+0x1A, 0x45, 0x55, 0xB6,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x38, 0x3D, 0x20, 0xE9,
+
+0x0A, 0x20,
+0x02, 0x20,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x0A, 0x47, 0x4F, 0xBF,
+0x02, 0x47, 0x57, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x46, 0x4E, 0xBF,
+0x1A, 0x46, 0x56, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x36, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x37, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x4B, 0xBF,
+0x1A, 0x43, 0x53, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x35, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x39, 0x39, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x37, 0x48, 0x50, 0xBD,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8B, 0x3E, 0x20, 0xE9,
+
+0x82, 0x30, 0x57, 0xE9,
+0x87, 0x77, 0x57, 0xE9,
+
+0x83, 0x38, 0x57, 0xE9,
+0x35, 0x49, 0x51, 0xBD,
+
+0x84, 0x31, 0x5E, 0xE9,
+0x30, 0x1F, 0x5F, 0xE9,
+
+0x85, 0x39, 0x5E, 0xE9,
+0x57, 0x25, 0x20, 0xE9,
+
+0x2B, 0x48, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x26, 0x77,
+
+0x24, 0x49, 0x20, 0xE9,
+0xAA, 0xFF, 0x20, 0xEA,
+
+0x16, 0x26, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x1C, 0x46, 0xA0, 0xE8,
+0x23, 0x4E, 0xA0, 0xE8,
+
+0x2B, 0x56, 0xA0, 0xE8,
+0x1D, 0x47, 0xA0, 0xE8,
+
+0x24, 0x4F, 0xA0, 0xE8,
+0x2C, 0x57, 0xA0, 0xE8,
+
+0x1C, 0x00,
+0x23, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x1D, 0x00,
+0x24, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x1C, 0x65,
+0x23, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x1D, 0x65,
+0x24, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x1C, 0x23, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x1D, 0x24, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x1C, 0x2B, 0xDE, 0xE8,
+0x23, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x1C, 0xBD,
+0x3B, 0xD7, 0x23, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x4F, 0x80, 0x4F, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0xD3, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x4E, 0x33, 0x4E, 0xCF,
+0x57, 0x3B, 0x57, 0xCF,
+
+0x98, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_tgzs[] = {
+
+0x00, 0x88, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x22, 0x40, 0x48, 0xBF,
+0x2A, 0x40, 0x50, 0xBF,
+
+0x32, 0x41, 0x49, 0xBF,
+0x3A, 0x41, 0x51, 0xBF,
+
+0xC3, 0x6B,
+0xCB, 0x6B,
+0x00, 0x88, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x4B, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x29, 0x9F,
+0x00, 0xE0,
+0x49, 0x04,
+
+0x90, 0xE2,
+0x51, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x49, 0x41, 0xC0, 0xEC,
+0x39, 0x57, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x53, 0xA0, 0xE8,
+
+0x51, 0x41, 0xC0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x65, 0x80, 0x15, 0xEA,
+0x08, 0x04,
+0x10, 0x04,
+
+0x51, 0x49, 0xC0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x4A, 0xBF,
+0x27, 0x4A, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x52, 0xBF,
+0x1E, 0x49, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x26, 0x51, 0x60, 0xEA,
+
+0x32, 0x40, 0x48, 0xBD,
+0x22, 0x40, 0x50, 0xBD,
+
+0x12, 0x41, 0x49, 0xBD,
+0x3A, 0x41, 0x51, 0xBD,
+
+0xBF, 0x2F, 0x26, 0xBD,
+0x00, 0xE0,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x46, 0x31, 0x46, 0xBF,
+0x4E, 0x31, 0x4E, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x56, 0x31, 0x56, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x4F, 0x39, 0x4F, 0xBF,
+0x57, 0x39, 0x57, 0xBF,
+
+0x57, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x42, 0x73, 0xF8, 0xEC,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0xA5, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x4B, 0x4B, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x26, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x53, 0x53, 0x2D, 0xDF,
+0x00, 0x80, 0x00, 0xE8,
+
+0xB8, 0x38, 0x33, 0xBF,
+0x00, 0xE0,
+0x59, 0xE3,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x3F, 0x4B, 0xA0, 0xE8,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x53, 0xA0, 0xE8,
+
+0x48, 0x70, 0xF8, 0xEC,
+0x2B, 0x48, 0x3C, 0xE9,
+
+0x1F, 0x27, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x18, 0x3A, 0x41, 0xE9,
+0x1D, 0x32, 0x41, 0xE9,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x56, 0x3D, 0x56, 0xDF,
+
+0x46, 0x37, 0x46, 0xDF,
+0x4E, 0x3F, 0x4E, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x4F, 0x3F, 0x4F, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3D, 0x57, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x27, 0xCF, 0x74, 0xC2,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x0A, 0x44, 0x4C, 0xB0,
+0x02, 0x44, 0x54, 0xB0,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x34, 0x37, 0x20, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x38, 0x27, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x4C, 0xB2,
+0x1A, 0x44, 0x54, 0xB2,
+
+0x29, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x27, 0xCF, 0x75, 0xC0,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x3D, 0xCF, 0x75, 0xC2,
+0x37, 0xCF, 0x75, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA6, 0x27, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA3, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x4C, 0xB4,
+0x1A, 0x44, 0x54, 0xB4,
+
+0x0A, 0x45, 0x4D, 0xB0,
+0x02, 0x45, 0x55, 0xB0,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA0, 0x37, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x2A, 0x45, 0x4D, 0xB2,
+0x1A, 0x45, 0x55, 0xB2,
+
+0x0A, 0x45, 0x4D, 0xB4,
+0x02, 0x45, 0x55, 0xB4,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x20,
+0x02, 0x20,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x2A, 0x46, 0x4E, 0xBF,
+0x1A, 0x46, 0x56, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x36, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x37, 0x39, 0x4F, 0xE9,
+
+0x30, 0x50, 0x2E, 0x9F,
+0xA7, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0xA8, 0x38, 0x4F, 0xE9,
+
+0x0A, 0x47, 0x4F, 0xBF,
+0x02, 0x47, 0x57, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA4, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA5, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x4B, 0xBF,
+0x1A, 0x43, 0x53, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0xA1, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0xA2, 0x38, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x37, 0x48, 0x50, 0xBD,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8B, 0x3E, 0x20, 0xE9,
+
+0x82, 0x30, 0x57, 0xE9,
+0x87, 0x77, 0x57, 0xE9,
+
+0x83, 0x38, 0x57, 0xE9,
+0x35, 0x49, 0x51, 0xBD,
+
+0x84, 0x31, 0x5E, 0xE9,
+0x30, 0x1F, 0x5F, 0xE9,
+
+0x85, 0x39, 0x5E, 0xE9,
+0x57, 0x25, 0x20, 0xE9,
+
+0x2B, 0x48, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x26, 0x77,
+
+0x24, 0x49, 0x20, 0xE9,
+0xA2, 0xFF, 0x20, 0xEA,
+
+0x16, 0x26, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x1C, 0x46, 0xA0, 0xE8,
+0x23, 0x4E, 0xA0, 0xE8,
+
+0x2B, 0x56, 0xA0, 0xE8,
+0x1D, 0x47, 0xA0, 0xE8,
+
+0x24, 0x4F, 0xA0, 0xE8,
+0x2C, 0x57, 0xA0, 0xE8,
+
+0x1C, 0x00,
+0x23, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x1D, 0x00,
+0x24, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x1C, 0x65,
+0x23, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x1D, 0x65,
+0x24, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x1C, 0x23, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x1D, 0x24, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x1C, 0x2B, 0xDE, 0xE8,
+0x23, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x1C, 0xBD,
+0x3B, 0xD7, 0x23, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x4F, 0x80, 0x4F, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0xCA, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x4E, 0x33, 0x4E, 0xCF,
+0x57, 0x3B, 0x57, 0xCF,
+
+0x90, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_tgzsa[] = {
+
+0x00, 0x88, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x22, 0x40, 0x48, 0xBF,
+0x2A, 0x40, 0x50, 0xBF,
+
+0x32, 0x41, 0x49, 0xBF,
+0x3A, 0x41, 0x51, 0xBF,
+
+0xC3, 0x6B,
+0xCB, 0x6B,
+0x00, 0x88, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x4B, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x29, 0x9F,
+0x00, 0xE0,
+0x49, 0x04,
+
+0x90, 0xE2,
+0x51, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x49, 0x41, 0xC0, 0xEC,
+0x39, 0x57, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x53, 0xA0, 0xE8,
+
+0x51, 0x41, 0xC0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x6A, 0x80, 0x15, 0xEA,
+0x08, 0x04,
+0x10, 0x04,
+
+0x51, 0x49, 0xC0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x4A, 0xBF,
+0x27, 0x4A, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x52, 0xBF,
+0x1E, 0x49, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x26, 0x51, 0x60, 0xEA,
+
+0x32, 0x40, 0x48, 0xBD,
+0x22, 0x40, 0x50, 0xBD,
+
+0x12, 0x41, 0x49, 0xBD,
+0x3A, 0x41, 0x51, 0xBD,
+
+0xBF, 0x2F, 0x26, 0xBD,
+0x00, 0xE0,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x46, 0x31, 0x46, 0xBF,
+0x4E, 0x31, 0x4E, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x56, 0x31, 0x56, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x4F, 0x39, 0x4F, 0xBF,
+0x57, 0x39, 0x57, 0xBF,
+
+0x5C, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x42, 0x73, 0xF8, 0xEC,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0xA5, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x4B, 0x4B, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x26, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x53, 0x53, 0x2D, 0xDF,
+0x00, 0x80, 0x00, 0xE8,
+
+0xB8, 0x38, 0x33, 0xBF,
+0x00, 0xE0,
+0x59, 0xE3,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x3F, 0x4B, 0xA0, 0xE8,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x53, 0xA0, 0xE8,
+
+0x48, 0x70, 0xF8, 0xEC,
+0x2B, 0x48, 0x3C, 0xE9,
+
+0x1F, 0x27, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x18, 0x3A, 0x41, 0xE9,
+0x1D, 0x32, 0x41, 0xE9,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x56, 0x3D, 0x56, 0xDF,
+
+0x46, 0x37, 0x46, 0xDF,
+0x4E, 0x3F, 0x4E, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x4F, 0x3F, 0x4F, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3D, 0x57, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x27, 0xCF, 0x74, 0xC2,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x0A, 0x44, 0x4C, 0xB0,
+0x02, 0x44, 0x54, 0xB0,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x34, 0x37, 0x20, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x38, 0x27, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x4C, 0xB2,
+0x1A, 0x44, 0x54, 0xB2,
+
+0x2E, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x27, 0xCF, 0x75, 0xC0,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x3D, 0xCF, 0x75, 0xC2,
+0x37, 0xCF, 0x75, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA6, 0x27, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA3, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x4C, 0xB4,
+0x1A, 0x44, 0x54, 0xB4,
+
+0x0A, 0x45, 0x4D, 0xB0,
+0x02, 0x45, 0x55, 0xB0,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA0, 0x37, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x45, 0x4D, 0xB2,
+0x1A, 0x45, 0x55, 0xB2,
+
+0x0A, 0x45, 0x4D, 0xB4,
+0x02, 0x45, 0x55, 0xB4,
+
+0x27, 0xCF, 0x74, 0xC6,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA7, 0x30, 0x4F, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9C, 0x27, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA8, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x44, 0x4C, 0xB6,
+0x1A, 0x44, 0x54, 0xB6,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x36, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x37, 0x39, 0x4F, 0xE9,
+
+0x00, 0x80, 0x00, 0xE8,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x2A, 0x46, 0x4E, 0xBF,
+0x1A, 0x46, 0x56, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA4, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA5, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x47, 0x4F, 0xBF,
+0x02, 0x47, 0x57, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA1, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA2, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x4B, 0xBF,
+0x1A, 0x43, 0x53, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x9D, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x9E, 0x39, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x37, 0x48, 0x50, 0xBD,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8B, 0x3E, 0x20, 0xE9,
+
+0x82, 0x30, 0x57, 0xE9,
+0x87, 0x77, 0x57, 0xE9,
+
+0x83, 0x38, 0x57, 0xE9,
+0x35, 0x49, 0x51, 0xBD,
+
+0x84, 0x31, 0x5E, 0xE9,
+0x30, 0x1F, 0x5F, 0xE9,
+
+0x85, 0x39, 0x5E, 0xE9,
+0x57, 0x25, 0x20, 0xE9,
+
+0x2B, 0x48, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x26, 0x77,
+
+0x24, 0x49, 0x20, 0xE9,
+0x9D, 0xFF, 0x20, 0xEA,
+
+0x16, 0x26, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x1C, 0x46, 0xA0, 0xE8,
+0x23, 0x4E, 0xA0, 0xE8,
+
+0x2B, 0x56, 0xA0, 0xE8,
+0x1D, 0x47, 0xA0, 0xE8,
+
+0x24, 0x4F, 0xA0, 0xE8,
+0x2C, 0x57, 0xA0, 0xE8,
+
+0x1C, 0x00,
+0x23, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x1D, 0x00,
+0x24, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x1C, 0x65,
+0x23, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x1D, 0x65,
+0x24, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x1C, 0x23, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x1D, 0x24, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x1C, 0x2B, 0xDE, 0xE8,
+0x23, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x1C, 0xBD,
+0x3B, 0xD7, 0x23, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x4F, 0x80, 0x4F, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0xC5, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x4E, 0x33, 0x4E, 0xCF,
+0x57, 0x3B, 0x57, 0xCF,
+
+0x8B, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_tgzsaf[] = {
+
+0x00, 0x88, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x22, 0x40, 0x48, 0xBF,
+0x2A, 0x40, 0x50, 0xBF,
+
+0x32, 0x41, 0x49, 0xBF,
+0x3A, 0x41, 0x51, 0xBF,
+
+0xC3, 0x6B,
+0xCB, 0x6B,
+0x00, 0x88, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x4B, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x29, 0x9F,
+0x00, 0xE0,
+0x49, 0x04,
+
+0x90, 0xE2,
+0x51, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x49, 0x41, 0xC0, 0xEC,
+0x39, 0x57, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x53, 0xA0, 0xE8,
+
+0x51, 0x41, 0xC0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x6E, 0x80, 0x15, 0xEA,
+0x08, 0x04,
+0x10, 0x04,
+
+0x51, 0x49, 0xC0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x4A, 0xBF,
+0x27, 0x4A, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x52, 0xBF,
+0x1E, 0x49, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x26, 0x51, 0x60, 0xEA,
+
+0x32, 0x40, 0x48, 0xBD,
+0x22, 0x40, 0x50, 0xBD,
+
+0x12, 0x41, 0x49, 0xBD,
+0x3A, 0x41, 0x51, 0xBD,
+
+0xBF, 0x2F, 0x26, 0xBD,
+0x00, 0xE0,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x46, 0x31, 0x46, 0xBF,
+0x4E, 0x31, 0x4E, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x56, 0x31, 0x56, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x4F, 0x39, 0x4F, 0xBF,
+0x57, 0x39, 0x57, 0xBF,
+
+0x60, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x42, 0x73, 0xF8, 0xEC,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0xA5, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x4B, 0x4B, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x26, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x53, 0x53, 0x2D, 0xDF,
+0x00, 0x80, 0x00, 0xE8,
+
+0xB8, 0x38, 0x33, 0xBF,
+0x00, 0xE0,
+0x59, 0xE3,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x3F, 0x4B, 0xA0, 0xE8,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x53, 0xA0, 0xE8,
+
+0x48, 0x70, 0xF8, 0xEC,
+0x2B, 0x48, 0x3C, 0xE9,
+
+0x1F, 0x27, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x18, 0x3A, 0x41, 0xE9,
+0x1D, 0x32, 0x41, 0xE9,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x56, 0x3D, 0x56, 0xDF,
+
+0x46, 0x37, 0x46, 0xDF,
+0x4E, 0x3F, 0x4E, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x4F, 0x3F, 0x4F, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3D, 0x57, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x27, 0xCF, 0x74, 0xC2,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x0A, 0x44, 0x4C, 0xB0,
+0x02, 0x44, 0x54, 0xB0,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x34, 0x37, 0x20, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x38, 0x27, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x4C, 0xB2,
+0x1A, 0x44, 0x54, 0xB2,
+
+0x32, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x27, 0xCF, 0x75, 0xC0,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x3D, 0xCF, 0x75, 0xC2,
+0x37, 0xCF, 0x75, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA6, 0x27, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA3, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x4C, 0xB4,
+0x1A, 0x44, 0x54, 0xB4,
+
+0x0A, 0x45, 0x4D, 0xB0,
+0x02, 0x45, 0x55, 0xB0,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA0, 0x37, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x45, 0x4D, 0xB2,
+0x1A, 0x45, 0x55, 0xB2,
+
+0x0A, 0x45, 0x4D, 0xB4,
+0x02, 0x45, 0x55, 0xB4,
+
+0x27, 0xCF, 0x74, 0xC6,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA7, 0x30, 0x4F, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9C, 0x27, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA8, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x44, 0x4C, 0xB6,
+0x1A, 0x44, 0x54, 0xB6,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x36, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x37, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x45, 0x4D, 0xB6,
+0x02, 0x45, 0x55, 0xB6,
+
+0x3D, 0xCF, 0x75, 0xC6,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x2A, 0x46, 0x4E, 0xBF,
+0x1A, 0x46, 0x56, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA4, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA5, 0x39, 0x4F, 0xE9,
+
+0x31, 0x3D, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x0A, 0x47, 0x4F, 0xBF,
+0x02, 0x47, 0x57, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0xA1, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0xA2, 0x38, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x9D, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x9E, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x4B, 0xBF,
+0x1A, 0x43, 0x53, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x35, 0x30, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x39, 0x38, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x37, 0x48, 0x50, 0xBD,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8B, 0x3E, 0x20, 0xE9,
+
+0x82, 0x30, 0x57, 0xE9,
+0x87, 0x77, 0x57, 0xE9,
+
+0x83, 0x38, 0x57, 0xE9,
+0x35, 0x49, 0x51, 0xBD,
+
+0x84, 0x31, 0x5E, 0xE9,
+0x30, 0x1F, 0x5F, 0xE9,
+
+0x85, 0x39, 0x5E, 0xE9,
+0x57, 0x25, 0x20, 0xE9,
+
+0x2B, 0x48, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x26, 0x77,
+
+0x24, 0x49, 0x20, 0xE9,
+0x99, 0xFF, 0x20, 0xEA,
+
+0x16, 0x26, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x1C, 0x46, 0xA0, 0xE8,
+0x23, 0x4E, 0xA0, 0xE8,
+
+0x2B, 0x56, 0xA0, 0xE8,
+0x1D, 0x47, 0xA0, 0xE8,
+
+0x24, 0x4F, 0xA0, 0xE8,
+0x2C, 0x57, 0xA0, 0xE8,
+
+0x1C, 0x00,
+0x23, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x1D, 0x00,
+0x24, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x1C, 0x65,
+0x23, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x1D, 0x65,
+0x24, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x1C, 0x23, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x1D, 0x24, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x1C, 0x2B, 0xDE, 0xE8,
+0x23, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x1C, 0xBD,
+0x3B, 0xD7, 0x23, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x4F, 0x80, 0x4F, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0xC1, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x4E, 0x33, 0x4E, 0xCF,
+0x57, 0x3B, 0x57, 0xCF,
+
+0x87, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
+unsigned char WARP_G400_tgzsf[] = {
+
+0x00, 0x88, 0x98, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+0xFF, 0x80, 0xC0, 0xE9,
+0x00, 0x80, 0x00, 0xE8,
+
+0x22, 0x40, 0x48, 0xBF,
+0x2A, 0x40, 0x50, 0xBF,
+
+0x32, 0x41, 0x49, 0xBF,
+0x3A, 0x41, 0x51, 0xBF,
+
+0xC3, 0x6B,
+0xCB, 0x6B,
+0x00, 0x88, 0x98, 0xE9,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x96, 0xE2,
+0x41, 0x04,
+
+0x7B, 0x43, 0xA0, 0xE8,
+0x73, 0x4B, 0xA0, 0xE8,
+
+0xAD, 0xEE, 0x29, 0x9F,
+0x00, 0xE0,
+0x49, 0x04,
+
+0x90, 0xE2,
+0x51, 0x04,
+0x31, 0x46, 0xB1, 0xE8,
+
+0x49, 0x41, 0xC0, 0xEC,
+0x39, 0x57, 0xB1, 0xE8,
+
+0x00, 0x04,
+0x46, 0xE2,
+0x73, 0x53, 0xA0, 0xE8,
+
+0x51, 0x41, 0xC0, 0xEC,
+0x31, 0x00,
+0x39, 0x00,
+
+0x6A, 0x80, 0x15, 0xEA,
+0x08, 0x04,
+0x10, 0x04,
+
+0x51, 0x49, 0xC0, 0xEC,
+0x2F, 0x41, 0x60, 0xEA,
+
+0x31, 0x20,
+0x39, 0x20,
+0x1F, 0x42, 0xA0, 0xE8,
+
+0x2A, 0x42, 0x4A, 0xBF,
+0x27, 0x4A, 0xA0, 0xE8,
+
+0x1A, 0x42, 0x52, 0xBF,
+0x1E, 0x49, 0x60, 0xEA,
+
+0x73, 0x7B, 0xC8, 0xEC,
+0x26, 0x51, 0x60, 0xEA,
+
+0x32, 0x40, 0x48, 0xBD,
+0x22, 0x40, 0x50, 0xBD,
+
+0x12, 0x41, 0x49, 0xBD,
+0x3A, 0x41, 0x51, 0xBD,
+
+0xBF, 0x2F, 0x26, 0xBD,
+0x00, 0xE0,
+0x7B, 0x72,
+
+0x32, 0x20,
+0x22, 0x20,
+0x12, 0x20,
+0x3A, 0x20,
+
+0x46, 0x31, 0x46, 0xBF,
+0x4E, 0x31, 0x4E, 0xBF,
+
+0xB3, 0xE2, 0x2D, 0x9F,
+0x00, 0x80, 0x00, 0xE8,
+
+0x56, 0x31, 0x56, 0xBF,
+0x47, 0x39, 0x47, 0xBF,
+
+0x4F, 0x39, 0x4F, 0xBF,
+0x57, 0x39, 0x57, 0xBF,
+
+0x5C, 0x80, 0x07, 0xEA,
+0x24, 0x41, 0x20, 0xE9,
+
+0x42, 0x73, 0xF8, 0xEC,
+0x00, 0xE0,
+0x2D, 0x73,
+
+0x33, 0x72,
+0x0C, 0xE3,
+0xA5, 0x2F, 0x1E, 0xBD,
+
+0x43, 0x43, 0x2D, 0xDF,
+0x4B, 0x4B, 0x2D, 0xDF,
+
+0xAE, 0x1E, 0x26, 0xBD,
+0x58, 0xE3,
+0x33, 0x66,
+
+0x53, 0x53, 0x2D, 0xDF,
+0x00, 0x80, 0x00, 0xE8,
+
+0xB8, 0x38, 0x33, 0xBF,
+0x00, 0xE0,
+0x59, 0xE3,
+
+0x1E, 0x12, 0x41, 0xE9,
+0x1A, 0x22, 0x41, 0xE9,
+
+0x2B, 0x40, 0x3D, 0xE9,
+0x3F, 0x4B, 0xA0, 0xE8,
+
+0x2D, 0x73,
+0x30, 0x76,
+0x05, 0x80, 0x3D, 0xEA,
+
+0x37, 0x43, 0xA0, 0xE8,
+0x3D, 0x53, 0xA0, 0xE8,
+
+0x48, 0x70, 0xF8, 0xEC,
+0x2B, 0x48, 0x3C, 0xE9,
+
+0x1F, 0x27, 0xBC, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x00, 0x80, 0x00, 0xE8,
+0x00, 0x80, 0x00, 0xE8,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x15, 0xC0, 0x20, 0xE9,
+0x15, 0xC0, 0x20, 0xE9,
+
+0x18, 0x3A, 0x41, 0xE9,
+0x1D, 0x32, 0x41, 0xE9,
+
+0x2A, 0x40, 0x20, 0xE9,
+0x56, 0x3D, 0x56, 0xDF,
+
+0x46, 0x37, 0x46, 0xDF,
+0x4E, 0x3F, 0x4E, 0xDF,
+
+0x16, 0x30, 0x20, 0xE9,
+0x4F, 0x3F, 0x4F, 0xDF,
+
+0x47, 0x37, 0x47, 0xDF,
+0x57, 0x3D, 0x57, 0xDF,
+
+0x32, 0x32, 0x2D, 0xDF,
+0x22, 0x22, 0x2D, 0xDF,
+
+0x12, 0x12, 0x2D, 0xDF,
+0x3A, 0x3A, 0x2D, 0xDF,
+
+0x27, 0xCF, 0x74, 0xC2,
+0x37, 0xCF, 0x74, 0xC4,
+
+0x0A, 0x44, 0x4C, 0xB0,
+0x02, 0x44, 0x54, 0xB0,
+
+0x3D, 0xCF, 0x74, 0xC0,
+0x34, 0x37, 0x20, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x38, 0x27, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3C, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x4C, 0xB2,
+0x1A, 0x44, 0x54, 0xB2,
+
+0x2E, 0x80, 0x3A, 0xEA,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x27, 0xCF, 0x75, 0xC0,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x32, 0x31, 0x5F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x33, 0x39, 0x5F, 0xE9,
+
+0x3D, 0xCF, 0x75, 0xC2,
+0x37, 0xCF, 0x75, 0xC4,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA6, 0x27, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA3, 0x3D, 0x20, 0xE9,
+
+0x2A, 0x44, 0x4C, 0xB4,
+0x1A, 0x44, 0x54, 0xB4,
+
+0x0A, 0x45, 0x4D, 0xB0,
+0x02, 0x45, 0x55, 0xB0,
+
+0x88, 0x73, 0x5E, 0xE9,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA0, 0x37, 0x20, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x3E, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x3F, 0x38, 0x4F, 0xE9,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x3A, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x3B, 0x39, 0x4F, 0xE9,
+
+0x2A, 0x45, 0x4D, 0xB2,
+0x1A, 0x45, 0x55, 0xB2,
+
+0x0A, 0x45, 0x4D, 0xB4,
+0x02, 0x45, 0x55, 0xB4,
+
+0x27, 0xCF, 0x75, 0xC6,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0xA7, 0x30, 0x4F, 0xE9,
+0x0A, 0x20,
+0x02, 0x20,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x31, 0x27, 0x20, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA8, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x45, 0x4D, 0xB6,
+0x1A, 0x45, 0x55, 0xB6,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x36, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x37, 0x39, 0x4F, 0xE9,
+
+0x00, 0x80, 0x00, 0xE8,
+0x2A, 0x20,
+0x1A, 0x20,
+
+0x2A, 0x46, 0x4E, 0xBF,
+0x1A, 0x46, 0x56, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA4, 0x31, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA5, 0x39, 0x4F, 0xE9,
+
+0x0A, 0x47, 0x4F, 0xBF,
+0x02, 0x47, 0x57, 0xBF,
+
+0x31, 0x53, 0x2F, 0x9F,
+0xA1, 0x30, 0x4F, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0xA2, 0x38, 0x4F, 0xE9,
+
+0x2A, 0x43, 0x4B, 0xBF,
+0x1A, 0x43, 0x53, 0xBF,
+
+0x30, 0x50, 0x2E, 0x9F,
+0x35, 0x31, 0x4F, 0xE9,
+
+0x38, 0x21, 0x2C, 0x9F,
+0x39, 0x39, 0x4F, 0xE9,
+
+0x31, 0x53, 0x2F, 0x9F,
+0x80, 0x31, 0x57, 0xE9,
+
+0x39, 0xE5, 0x2C, 0x9F,
+0x81, 0x39, 0x57, 0xE9,
+
+0x37, 0x48, 0x50, 0xBD,
+0x8A, 0x36, 0x20, 0xE9,
+
+0x86, 0x76, 0x57, 0xE9,
+0x8B, 0x3E, 0x20, 0xE9,
+
+0x82, 0x30, 0x57, 0xE9,
+0x87, 0x77, 0x57, 0xE9,
+
+0x83, 0x38, 0x57, 0xE9,
+0x35, 0x49, 0x51, 0xBD,
+
+0x84, 0x31, 0x5E, 0xE9,
+0x30, 0x1F, 0x5F, 0xE9,
+
+0x85, 0x39, 0x5E, 0xE9,
+0x57, 0x25, 0x20, 0xE9,
+
+0x2B, 0x48, 0x20, 0xE9,
+0x1D, 0x37, 0xE1, 0xEA,
+
+0x1E, 0x35, 0xE1, 0xEA,
+0x00, 0xE0,
+0x26, 0x77,
+
+0x24, 0x49, 0x20, 0xE9,
+0x9D, 0xFF, 0x20, 0xEA,
+
+0x16, 0x26, 0x20, 0xE9,
+0x57, 0x2E, 0xBF, 0xEA,
+
+0x1C, 0x46, 0xA0, 0xE8,
+0x23, 0x4E, 0xA0, 0xE8,
+
+0x2B, 0x56, 0xA0, 0xE8,
+0x1D, 0x47, 0xA0, 0xE8,
+
+0x24, 0x4F, 0xA0, 0xE8,
+0x2C, 0x57, 0xA0, 0xE8,
+
+0x1C, 0x00,
+0x23, 0x00,
+0x2B, 0x00,
+0x00, 0xE0,
+
+0x1D, 0x00,
+0x24, 0x00,
+0x2C, 0x00,
+0x00, 0xE0,
+
+0x1C, 0x65,
+0x23, 0x65,
+0x2B, 0x65,
+0x00, 0xE0,
+
+0x1D, 0x65,
+0x24, 0x65,
+0x2C, 0x65,
+0x00, 0xE0,
+
+0x1C, 0x23, 0x60, 0xEC,
+0x36, 0xD7, 0x36, 0xAD,
+
+0x2B, 0x80, 0x60, 0xEC,
+0x1D, 0x24, 0x60, 0xEC,
+
+0x3E, 0xD7, 0x3E, 0xAD,
+0x2C, 0x80, 0x60, 0xEC,
+
+0x1C, 0x2B, 0xDE, 0xE8,
+0x23, 0x80, 0xDE, 0xE8,
+
+0x36, 0x80, 0x36, 0xBD,
+0x3E, 0x80, 0x3E, 0xBD,
+
+0x33, 0xD7, 0x1C, 0xBD,
+0x3B, 0xD7, 0x23, 0xBD,
+
+0x46, 0x80, 0x46, 0xCF,
+0x4F, 0x80, 0x4F, 0xCF,
+
+0x56, 0x33, 0x56, 0xCF,
+0x47, 0x3B, 0x47, 0xCF,
+
+0xC5, 0xFF, 0x20, 0xEA,
+0x00, 0x80, 0x00, 0xE8,
+
+0x4E, 0x33, 0x4E, 0xCF,
+0x57, 0x3B, 0x57, 0xCF,
+
+0x8B, 0xFF, 0x20, 0xEA,
+0x57, 0xC0, 0xBF, 0xEA,
+
+0x00, 0x80, 0xA0, 0xE9,
+0x00, 0x00, 0xD8, 0xEC,
+
+};
diff --git a/src/mga_video.c b/src/mga_video.c
new file mode 100644
index 0000000..d2e98a3
--- /dev/null
+++ b/src/mga_video.c
@@ -0,0 +1,1280 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_video.c,v 1.29 2001/12/26 14:54:04 dawes Exp $ */
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86_ansic.h"
+#include "compiler.h"
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+#include "xf86fbman.h"
+#include "regionstr.h"
+
+#include "mga_bios.h"
+#include "mga_reg.h"
+#include "mga.h"
+#include "mga_macros.h"
+#include "xf86xv.h"
+#include "Xv.h"
+#include "xaa.h"
+#include "xaalocal.h"
+#include "dixstruct.h"
+#include "fourcc.h"
+
+#define OFF_DELAY 250 /* milliseconds */
+#define FREE_DELAY 15000
+
+#define OFF_TIMER 0x01
+#define FREE_TIMER 0x02
+#define CLIENT_VIDEO_ON 0x04
+
+#define TIMER_MASK (OFF_TIMER | FREE_TIMER)
+
+#define MGA_MAX_PORTS 32
+
+#ifndef XvExtension
+void MGAInitVideo(ScreenPtr pScreen) {}
+#else
+
+static void MGAInitOffscreenImages(ScreenPtr);
+
+static XF86VideoAdaptorPtr MGASetupImageVideoOverlay(ScreenPtr);
+static int MGASetPortAttributeOverlay(ScrnInfoPtr, Atom, INT32, pointer);
+static int MGAGetPortAttributeOverlay(ScrnInfoPtr, Atom ,INT32 *, pointer);
+
+static XF86VideoAdaptorPtr MGASetupImageVideoTexture(ScreenPtr);
+static int MGASetPortAttributeTexture(ScrnInfoPtr, Atom, INT32, pointer);
+static int MGAGetPortAttributeTexture(ScrnInfoPtr, Atom ,INT32 *, pointer);
+
+static void MGAStopVideo(ScrnInfoPtr, pointer, Bool);
+static void MGAQueryBestSize(ScrnInfoPtr, Bool, short, short, short, short,
+ unsigned int *, unsigned int *, pointer);
+static int MGAPutImage(ScrnInfoPtr, short, short, short, short, short,
+ short, short, short, int, unsigned char*, short,
+ short, Bool, RegionPtr, pointer);
+static int MGAQueryImageAttributes(ScrnInfoPtr, int, unsigned short *,
+ unsigned short *, int *, int *);
+
+
+static void MGAResetVideoOverlay(ScrnInfoPtr);
+
+static void MGAVideoTimerCallback(ScrnInfoPtr pScrn, Time time);
+
+
+#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)
+
+static Atom xvBrightness, xvContrast, xvColorKey, xvDoubleBuffer;
+
+void MGAInitVideo(ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ XF86VideoAdaptorPtr *adaptors, *newAdaptors = NULL;
+ XF86VideoAdaptorPtr newAdaptor = NULL;
+ MGAPtr pMga = MGAPTR(pScrn);
+ int num_adaptors;
+
+ if((pScrn->bitsPerPixel != 8) && !pMga->NoAccel &&
+ (pMga->SecondCrtc == FALSE) &&
+ ((pMga->Chipset == PCI_CHIP_MGAG200) ||
+ (pMga->Chipset == PCI_CHIP_MGAG200_PCI) ||
+ (pMga->Chipset == PCI_CHIP_MGAG400) ||
+ (pMga->Chipset == PCI_CHIP_MGAG550)))
+ {
+ if((pMga->Overlay8Plus24 || pMga->TexturedVideo) &&
+ (pScrn->bitsPerPixel != 24))
+ {
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Using texture video\n");
+ newAdaptor = MGASetupImageVideoTexture(pScreen);
+ pMga->TexturedVideo = TRUE;
+ } else {
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Using overlay video\n");
+ newAdaptor = MGASetupImageVideoOverlay(pScreen);
+ pMga->TexturedVideo = FALSE;
+ }
+ if(!pMga->Overlay8Plus24)
+ MGAInitOffscreenImages(pScreen);
+ }
+
+ num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);
+
+ if(newAdaptor) {
+ if(!num_adaptors) {
+ num_adaptors = 1;
+ adaptors = &newAdaptor;
+ } else {
+ newAdaptors = /* need to free this someplace */
+ xalloc((num_adaptors + 1) * sizeof(XF86VideoAdaptorPtr*));
+ if(newAdaptors) {
+ memcpy(newAdaptors, adaptors, num_adaptors *
+ sizeof(XF86VideoAdaptorPtr));
+ newAdaptors[num_adaptors] = newAdaptor;
+ adaptors = newAdaptors;
+ num_adaptors++;
+ }
+ }
+ }
+
+ if(num_adaptors)
+ xf86XVScreenInit(pScreen, adaptors, num_adaptors);
+
+ if(newAdaptors)
+ xfree(newAdaptors);
+}
+
+/* client libraries expect an encoding */
+static XF86VideoEncodingRec DummyEncoding[2] =
+{
+ { /* overlay limit */
+ 0,
+ "XV_IMAGE",
+ 1024, 1024,
+ {1, 1}
+ },
+ { /* texture limit */
+ 0,
+ "XV_IMAGE",
+ 2046, 2046,
+ {1, 1}
+ }
+};
+
+#define NUM_FORMATS 6
+
+static XF86VideoFormatRec Formats[NUM_FORMATS] =
+{
+ {15, TrueColor}, {16, TrueColor}, {24, TrueColor},
+ {15, DirectColor}, {16, DirectColor}, {24, DirectColor}
+};
+
+#define NUM_ATTRIBUTES_OVERLAY 4
+
+static XF86AttributeRec Attributes[NUM_ATTRIBUTES_OVERLAY] =
+{
+ {XvSettable | XvGettable, 0, (1 << 24) - 1, "XV_COLORKEY"},
+ {XvSettable | XvGettable, -128, 127, "XV_BRIGHTNESS"},
+ {XvSettable | XvGettable, 0, 255, "XV_CONTRAST"},
+ {XvSettable | XvGettable, 0, 1, "XV_DOUBLE_BUFFER"}
+};
+
+#define NUM_IMAGES 4
+
+static XF86ImageRec Images[NUM_IMAGES] =
+{
+ XVIMAGE_YUY2,
+ XVIMAGE_YV12,
+ XVIMAGE_I420,
+ XVIMAGE_UYVY
+};
+
+static void
+MGAResetVideoOverlay(ScrnInfoPtr pScrn)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAPortPrivPtr pPriv = pMga->portPrivate;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ outMGAdac(0x51, 0x01); /* keying on */
+ outMGAdac(0x52, 0xff); /* full mask */
+ outMGAdac(0x53, 0xff);
+ outMGAdac(0x54, 0xff);
+
+ outMGAdac(0x55, (pPriv->colorKey & pScrn->mask.red) >>
+ pScrn->offset.red);
+ outMGAdac(0x56, (pPriv->colorKey & pScrn->mask.green) >>
+ pScrn->offset.green);
+ outMGAdac(0x57, (pPriv->colorKey & pScrn->mask.blue) >>
+ pScrn->offset.blue);
+
+ OUTREG(MGAREG_BESLUMACTL, ((pPriv->brightness & 0xff) << 16) |
+ (pPriv->contrast & 0xff));
+}
+
+
+static XF86VideoAdaptorPtr
+MGAAllocAdaptor(ScrnInfoPtr pScrn, Bool doublebuffer)
+{
+ XF86VideoAdaptorPtr adapt;
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAPortPrivPtr pPriv;
+ int i;
+
+ if(!(adapt = xf86XVAllocateVideoAdaptorRec(pScrn)))
+ return NULL;
+
+ if(!(pPriv = xcalloc(1, sizeof(MGAPortPrivRec) +
+ (sizeof(DevUnion) * MGA_MAX_PORTS))))
+ {
+ xfree(adapt);
+ return NULL;
+ }
+
+ adapt->pPortPrivates = (DevUnion*)(&pPriv[1]);
+
+ for(i = 0; i < MGA_MAX_PORTS; i++)
+ adapt->pPortPrivates[i].val = i;
+
+ xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");
+ xvContrast = MAKE_ATOM("XV_CONTRAST");
+ xvColorKey = MAKE_ATOM("XV_COLORKEY");
+ xvDoubleBuffer = MAKE_ATOM("XV_DOUBLE_BUFFER");
+
+ pPriv->colorKey = pMga->videoKey;
+ pPriv->videoStatus = 0;
+ pPriv->brightness = 0;
+ pPriv->contrast = 128;
+ pPriv->lastPort = -1;
+ pPriv->doubleBuffer = doublebuffer;
+ pPriv->currentBuffer = 0;
+
+ pMga->adaptor = adapt;
+ pMga->portPrivate = pPriv;
+
+ return adapt;
+}
+
+static XF86VideoAdaptorPtr
+MGASetupImageVideoOverlay(ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ XF86VideoAdaptorPtr adapt;
+
+ adapt = MGAAllocAdaptor(pScrn, TRUE);
+
+ adapt->type = XvWindowMask | XvInputMask | XvImageMask;
+ adapt->flags = VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT;
+ adapt->name = "Matrox G-Series Backend Scaler";
+ adapt->nEncodings = 1;
+ adapt->pEncodings = &DummyEncoding[0];
+ adapt->nFormats = NUM_FORMATS;
+ adapt->pFormats = Formats;
+ adapt->nPorts = 1;
+ adapt->pAttributes = Attributes;
+ if (pMga->Chipset == PCI_CHIP_MGAG400 ||
+ pMga->Chipset == PCI_CHIP_MGAG550) {
+ adapt->nImages = 4;
+ adapt->nAttributes = 4;
+ } else {
+ adapt->nImages = 3;
+ adapt->nAttributes = 1;
+ }
+ adapt->pImages = Images;
+ adapt->PutVideo = NULL;
+ adapt->PutStill = NULL;
+ adapt->GetVideo = NULL;
+ adapt->GetStill = NULL;
+ adapt->StopVideo = MGAStopVideo;
+ adapt->SetPortAttribute = MGASetPortAttributeOverlay;
+ adapt->GetPortAttribute = MGAGetPortAttributeOverlay;
+ adapt->QueryBestSize = MGAQueryBestSize;
+ adapt->PutImage = MGAPutImage;
+ adapt->QueryImageAttributes = MGAQueryImageAttributes;
+
+ /* gotta uninit this someplace */
+ REGION_INIT(pScreen, &(pMga->portPrivate->clip), NullBox, 0);
+
+ MGAResetVideoOverlay(pScrn);
+
+ return adapt;
+}
+
+
+static XF86VideoAdaptorPtr
+MGASetupImageVideoTexture(ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ XF86VideoAdaptorPtr adapt;
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ adapt = MGAAllocAdaptor(pScrn, FALSE);
+
+ adapt->type = XvWindowMask | XvInputMask | XvImageMask;
+ adapt->flags = 0;
+ adapt->name = "Matrox G-Series Texture Engine";
+ adapt->nEncodings = 1;
+ adapt->pEncodings = &DummyEncoding[1];
+ adapt->nFormats = NUM_FORMATS;
+ adapt->pFormats = Formats;
+ adapt->nPorts = MGA_MAX_PORTS;
+ adapt->pAttributes = NULL;
+ adapt->nAttributes = 0;
+ adapt->pImages = Images;
+ if (pMga->Chipset == PCI_CHIP_MGAG400 ||
+ pMga->Chipset == PCI_CHIP_MGAG550)
+ adapt->nImages = 4;
+ else
+ adapt->nImages = 3;
+ adapt->PutVideo = NULL;
+ adapt->PutStill = NULL;
+ adapt->GetVideo = NULL;
+ adapt->GetStill = NULL;
+ adapt->StopVideo = MGAStopVideo;
+ adapt->SetPortAttribute = MGASetPortAttributeTexture;
+ adapt->GetPortAttribute = MGAGetPortAttributeTexture;
+ adapt->QueryBestSize = MGAQueryBestSize;
+ adapt->PutImage = MGAPutImage;
+ adapt->QueryImageAttributes = MGAQueryImageAttributes;
+
+ return adapt;
+}
+
+
+
+static Bool
+RegionsEqual(RegionPtr A, RegionPtr B)
+{
+ int *dataA, *dataB;
+ int num;
+
+ num = REGION_NUM_RECTS(A);
+ if(num != REGION_NUM_RECTS(B))
+ return FALSE;
+
+ if((A->extents.x1 != B->extents.x1) ||
+ (A->extents.x2 != B->extents.x2) ||
+ (A->extents.y1 != B->extents.y1) ||
+ (A->extents.y2 != B->extents.y2))
+ return FALSE;
+
+ dataA = (int*)REGION_RECTS(A);
+ dataB = (int*)REGION_RECTS(B);
+
+ while(num--) {
+ if((dataA[0] != dataB[0]) || (dataA[1] != dataB[1]))
+ return FALSE;
+ dataA += 2;
+ dataB += 2;
+ }
+
+ return TRUE;
+}
+
+
+/* MGAClipVideo -
+
+ Takes the dst box in standard X BoxRec form (top and left
+ edges inclusive, bottom and right exclusive). The new dst
+ box is returned. The source boundaries are given (x1, y1
+ inclusive, x2, y2 exclusive) and returned are the new source
+ boundaries in 16.16 fixed point.
+*/
+
+#define DummyScreen screenInfo.screens[0]
+
+static Bool
+MGAClipVideo(
+ BoxPtr dst,
+ INT32 *x1,
+ INT32 *x2,
+ INT32 *y1,
+ INT32 *y2,
+ RegionPtr reg,
+ INT32 width,
+ INT32 height
+){
+ INT32 vscale, hscale, delta;
+ BoxPtr extents = REGION_EXTENTS(DummyScreen, reg);
+ int diff;
+
+ hscale = ((*x2 - *x1) << 16) / (dst->x2 - dst->x1);
+ vscale = ((*y2 - *y1) << 16) / (dst->y2 - dst->y1);
+
+ *x1 <<= 16; *x2 <<= 16;
+ *y1 <<= 16; *y2 <<= 16;
+
+ diff = extents->x1 - dst->x1;
+ if(diff > 0) {
+ dst->x1 = extents->x1;
+ *x1 += diff * hscale;
+ }
+ diff = dst->x2 - extents->x2;
+ if(diff > 0) {
+ dst->x2 = extents->x2;
+ *x2 -= diff * hscale;
+ }
+ diff = extents->y1 - dst->y1;
+ if(diff > 0) {
+ dst->y1 = extents->y1;
+ *y1 += diff * vscale;
+ }
+ diff = dst->y2 - extents->y2;
+ if(diff > 0) {
+ dst->y2 = extents->y2;
+ *y2 -= diff * vscale;
+ }
+
+ if(*x1 < 0) {
+ diff = (- *x1 + hscale - 1)/ hscale;
+ dst->x1 += diff;
+ *x1 += diff * hscale;
+ }
+ delta = *x2 - (width << 16);
+ if(delta > 0) {
+ diff = (delta + hscale - 1)/ hscale;
+ dst->x2 -= diff;
+ *x2 -= diff * hscale;
+ }
+ if(*x1 >= *x2) return FALSE;
+
+ if(*y1 < 0) {
+ diff = (- *y1 + vscale - 1)/ vscale;
+ dst->y1 += diff;
+ *y1 += diff * vscale;
+ }
+ delta = *y2 - (height << 16);
+ if(delta > 0) {
+ diff = (delta + vscale - 1)/ vscale;
+ dst->y2 -= diff;
+ *y2 -= diff * vscale;
+ }
+ if(*y1 >= *y2) return FALSE;
+
+ if((dst->x1 != extents->x1) || (dst->x2 != extents->x2) ||
+ (dst->y1 != extents->y1) || (dst->y2 != extents->y2))
+ {
+ RegionRec clipReg;
+ REGION_INIT(DummyScreen, &clipReg, dst, 1);
+ REGION_INTERSECT(DummyScreen, reg, reg, &clipReg);
+ REGION_UNINIT(DummyScreen, &clipReg);
+ }
+ return TRUE;
+}
+
+static void
+MGAStopVideo(ScrnInfoPtr pScrn, pointer data, Bool shutdown)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAPortPrivPtr pPriv = pMga->portPrivate;
+
+ if(pMga->TexturedVideo) return;
+
+ REGION_EMPTY(pScrn->pScreen, &pPriv->clip);
+
+ if(shutdown) {
+ if(pPriv->videoStatus & CLIENT_VIDEO_ON)
+ OUTREG(MGAREG_BESCTL, 0);
+ if(pPriv->linear) {
+ xf86FreeOffscreenLinear(pPriv->linear);
+ pPriv->linear = NULL;
+ }
+ pPriv->videoStatus = 0;
+ } else {
+ if(pPriv->videoStatus & CLIENT_VIDEO_ON) {
+ pPriv->videoStatus |= OFF_TIMER;
+ pPriv->offTime = currentTime.milliseconds + OFF_DELAY;
+ }
+ }
+}
+
+static int
+MGASetPortAttributeOverlay(
+ ScrnInfoPtr pScrn,
+ Atom attribute,
+ INT32 value,
+ pointer data
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAPortPrivPtr pPriv = pMga->portPrivate;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ if(attribute == xvBrightness) {
+ if((value < -128) || (value > 127))
+ return BadValue;
+ pPriv->brightness = value;
+ OUTREG(MGAREG_BESLUMACTL, ((pPriv->brightness & 0xff) << 16) |
+ (pPriv->contrast & 0xff));
+ } else
+ if(attribute == xvContrast) {
+ if((value < 0) || (value > 255))
+ return BadValue;
+ pPriv->contrast = value;
+ OUTREG(MGAREG_BESLUMACTL, ((pPriv->brightness & 0xff) << 16) |
+ (pPriv->contrast & 0xff));
+ } else
+ if(attribute == xvColorKey) {
+ pPriv->colorKey = value;
+ outMGAdac(0x55, (pPriv->colorKey & pScrn->mask.red) >>
+ pScrn->offset.red);
+ outMGAdac(0x56, (pPriv->colorKey & pScrn->mask.green) >>
+ pScrn->offset.green);
+ outMGAdac(0x57, (pPriv->colorKey & pScrn->mask.blue) >>
+ pScrn->offset.blue);
+ REGION_EMPTY(pScrn->pScreen, &pPriv->clip);
+ } else
+ if(attribute == xvDoubleBuffer) {
+ if((value < 0) || (value > 1))
+ return BadValue;
+ pPriv->doubleBuffer = value;
+ } else return BadMatch;
+
+ return Success;
+}
+
+static int
+MGAGetPortAttributeOverlay(
+ ScrnInfoPtr pScrn,
+ Atom attribute,
+ INT32 *value,
+ pointer data
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAPortPrivPtr pPriv = pMga->portPrivate;
+
+ if(attribute == xvBrightness) {
+ *value = pPriv->brightness;
+ } else
+ if(attribute == xvContrast) {
+ *value = pPriv->contrast;
+ } else
+ if(attribute == xvDoubleBuffer) {
+ *value = pPriv->doubleBuffer ? 1 : 0;
+ } else
+ if(attribute == xvColorKey) {
+ *value = pPriv->colorKey;
+ } else return BadMatch;
+
+ return Success;
+}
+
+
+static int
+MGASetPortAttributeTexture(
+ ScrnInfoPtr pScrn,
+ Atom attribute,
+ INT32 value,
+ pointer data
+) {
+ return BadMatch;
+}
+
+
+static int
+MGAGetPortAttributeTexture(
+ ScrnInfoPtr pScrn,
+ Atom attribute,
+ INT32 *value,
+ pointer data
+){
+ return BadMatch;
+}
+
+static void
+MGAQueryBestSize(
+ 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
+){
+ *p_w = drw_w;
+ *p_h = drw_h;
+}
+
+
+static void
+MGACopyData(
+ unsigned char *src,
+ unsigned char *dst,
+ int srcPitch,
+ int dstPitch,
+ int h,
+ int w
+){
+ w <<= 1;
+ while(h--) {
+ memcpy(dst, src, w);
+ src += srcPitch;
+ dst += dstPitch;
+ }
+}
+
+static void
+MGACopyMungedData(
+ unsigned char *src1,
+ unsigned char *src2,
+ unsigned char *src3,
+ unsigned char *dst1,
+ int srcPitch,
+ int srcPitch2,
+ int dstPitch,
+ int h,
+ int w
+){
+ CARD32 *dst;
+ CARD8 *s1, *s2, *s3;
+ int i, j;
+
+ w >>= 1;
+
+ for(j = 0; j < h; j++) {
+ dst = (CARD32*)dst1;
+ s1 = src1; s2 = src2; s3 = src3;
+ i = w;
+ while(i > 4) {
+ dst[0] = s1[0] | (s1[1] << 16) | (s3[0] << 8) | (s2[0] << 24);
+ dst[1] = s1[2] | (s1[3] << 16) | (s3[1] << 8) | (s2[1] << 24);
+ dst[2] = s1[4] | (s1[5] << 16) | (s3[2] << 8) | (s2[2] << 24);
+ dst[3] = s1[6] | (s1[7] << 16) | (s3[3] << 8) | (s2[3] << 24);
+ dst += 4; s2 += 4; s3 += 4; s1 += 8;
+ i -= 4;
+ }
+
+ while(i--) {
+ dst[0] = s1[0] | (s1[1] << 16) | (s3[0] << 8) | (s2[0] << 24);
+ dst++; s2++; s3++;
+ s1 += 2;
+ }
+
+ dst1 += dstPitch;
+ src1 += srcPitch;
+ if(j & 1) {
+ src2 += srcPitch2;
+ src3 += srcPitch2;
+ }
+ }
+}
+
+
+static FBLinearPtr
+MGAAllocateMemory(
+ ScrnInfoPtr pScrn,
+ FBLinearPtr linear,
+ int size
+){
+ ScreenPtr pScreen;
+ FBLinearPtr new_linear;
+
+ if(linear) {
+ if(linear->size >= size)
+ return linear;
+
+ if(xf86ResizeOffscreenLinear(linear, size))
+ return linear;
+
+ xf86FreeOffscreenLinear(linear);
+ }
+
+ pScreen = screenInfo.screens[pScrn->scrnIndex];
+
+ new_linear = xf86AllocateOffscreenLinear(pScreen, size, 16,
+ NULL, NULL, NULL);
+
+ if(!new_linear) {
+ int max_size;
+
+ xf86QueryLargestOffscreenLinear(pScreen, &max_size, 16,
+ PRIORITY_EXTREME);
+
+ if(max_size < size)
+ return NULL;
+
+ xf86PurgeUnlockedOffscreenAreas(pScreen);
+ new_linear = xf86AllocateOffscreenLinear(pScreen, size, 16,
+ NULL, NULL, NULL);
+ }
+
+ return new_linear;
+}
+
+static void
+MGADisplayVideoOverlay(
+ ScrnInfoPtr pScrn,
+ int id,
+ int offset,
+ short width, short height,
+ int pitch,
+ int x1, int y1, int x2, int y2,
+ BoxPtr dstBox,
+ short src_w, short src_h,
+ short drw_w, short drw_h
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ int tmp, hzoom, intrep;
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ /* got 48 scanlines to do it in */
+ tmp = INREG(MGAREG_VCOUNT) + 48;
+ /* FIXME always change it in vertical retrace use CrtcV ?*/
+ if(tmp > pScrn->currentMode->CrtcVTotal)
+ tmp -= 49; /* too bad */
+ else
+ tmp = pScrn->currentMode->CrtcVTotal -1;
+
+ tmp = pScrn->currentMode->VDisplay +1;
+ /* enable accelerated 2x horizontal zoom when pixelclock >135MHz */
+ hzoom = (pScrn->currentMode->Clock > 135000) ? 1 : 0;
+
+ switch(id) {
+ case FOURCC_UYVY:
+ OUTREG(MGAREG_BESGLOBCTL, 0x000000c0 | (3 * hzoom) | (tmp << 16));
+ break;
+ case FOURCC_YUY2:
+ default:
+ OUTREG(MGAREG_BESGLOBCTL, 0x00000080 | (3 * hzoom) | (tmp << 16));
+ break;
+ }
+
+ OUTREG(MGAREG_BESA1ORG, offset);
+
+ if(y1 & 0x00010000)
+ OUTREG(MGAREG_BESCTL, 0x00040c41);
+ else
+ OUTREG(MGAREG_BESCTL, 0x00040c01);
+
+ OUTREG(MGAREG_BESHCOORD, (dstBox->x1 << 16) | (dstBox->x2 - 1));
+ OUTREG(MGAREG_BESVCOORD, (dstBox->y1 << 16) | (dstBox->y2 - 1));
+
+ OUTREG(MGAREG_BESHSRCST, x1 & 0x03fffffc);
+ OUTREG(MGAREG_BESHSRCEND, (x2 - 0x00010000) & 0x03fffffc);
+ OUTREG(MGAREG_BESHSRCLST, (width - 1) << 16);
+
+ OUTREG(MGAREG_BESPITCH, pitch >> 1);
+
+ OUTREG(MGAREG_BESV1WGHT, y1 & 0x0000fffc);
+ OUTREG(MGAREG_BESV1SRCLST, height - 1 - (y1 >> 16));
+
+ intrep = ((drw_h == src_h) || (drw_h < 2)) ? 0 : 1;
+ tmp = ((src_h - intrep) << 16)/(drw_h - intrep);
+ if(tmp >= (32 << 16))
+ tmp = (32 << 16) - 1;
+ OUTREG(MGAREG_BESVISCAL, tmp & 0x001ffffc);
+
+ intrep = ((drw_w == src_w) || (drw_w < 2)) ? 0 : 1;
+ tmp = (((src_w - intrep) << 16)/(drw_w - intrep)) << hzoom;
+ if(tmp >= (32 << 16))
+ tmp = (32 << 16) - 1;
+ OUTREG(MGAREG_BESHISCAL, tmp & 0x001ffffc);
+
+}
+
+static void
+MGADisplayVideoTexture(
+ ScrnInfoPtr pScrn,
+ int id, int offset,
+ int nbox, BoxPtr pbox,
+ int width, int height, int pitch,
+ short src_x, short src_y,
+ short src_w, short src_h,
+ short drw_x, short drw_y,
+ short drw_w, short drw_h
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ int log2w = 0, log2h = 0, i, incx, incy, padw, padh;
+
+ pitch >>= 1;
+
+ i = 12;
+ while(--i) {
+ if(width & (1 << i)) {
+ log2w = i;
+ if(width & ((1 << i) - 1))
+ log2w++;
+ break;
+ }
+ }
+
+ i = 12;
+ while(--i) {
+ if(height & (1 << i)) {
+ log2h = i;
+ if(height & ((1 << i) - 1))
+ log2h++;
+ break;
+ }
+ }
+
+ padw = 1 << log2w;
+ padh = 1 << log2h;
+ incx = (src_w << 20)/(drw_w * padw);
+ incy = (src_h << 20)/(drw_h * padh);
+
+ CHECK_DMA_QUIESCENT(pMga, pScrn);
+
+ if(pMga->Overlay8Plus24) {
+ i = 0x00ffffff;
+ WAITFIFO(1);
+ SET_PLANEMASK(i);
+ }
+
+ WAITFIFO(15);
+ OUTREG(MGAREG_TMR0, incx); /* sx inc */
+ OUTREG(MGAREG_TMR1, 0); /* sy inc */
+ OUTREG(MGAREG_TMR2, 0); /* tx inc */
+ OUTREG(MGAREG_TMR3, incy); /* ty inc */
+ OUTREG(MGAREG_TMR4, 0x00000000);
+ OUTREG(MGAREG_TMR5, 0x00000000);
+ OUTREG(MGAREG_TMR8, 0x00010000);
+ OUTREG(MGAREG_TEXORG, offset);
+ OUTREG(MGAREG_TEXWIDTH, log2w | (((8 - log2w) & 63) << 9) |
+ ((width - 1) << 18));
+ OUTREG(MGAREG_TEXHEIGHT, log2h | (((8 - log2h) & 63) << 9) |
+ ((height - 1) << 18));
+ if(id == FOURCC_UYVY)
+ OUTREG(MGAREG_TEXCTL, 0x1A00010b | ((pitch & 0x07FF) << 9));
+ else
+ OUTREG(MGAREG_TEXCTL, 0x1A00010a | ((pitch & 0x07FF) << 9));
+ OUTREG(MGAREG_TEXCTL2, 0x00000014);
+ OUTREG(MGAREG_DWGCTL, 0x000c7076);
+ OUTREG(MGAREG_TEXFILTER, 0x01e00020);
+ OUTREG(MGAREG_ALPHACTRL, 0x00000001);
+
+ padw = (src_x << 20)/padw;
+ padh = (src_y << 20)/padh;
+
+ while(nbox--) {
+ WAITFIFO(4);
+ OUTREG(MGAREG_TMR6, (incx * (pbox->x1 - drw_x)) + padw);
+ OUTREG(MGAREG_TMR7, (incy * (pbox->y1 - drw_y)) + padh);
+ OUTREG(MGAREG_FXBNDRY, (pbox->x2 << 16) | (pbox->x1 & 0xffff));
+ OUTREG(MGAREG_YDSTLEN + MGAREG_EXEC,
+ (pbox->y1 << 16) | (pbox->y2 - pbox->y1));
+ pbox++;
+ }
+
+ pMga->AccelInfoRec->NeedToSync = TRUE;
+}
+
+static int
+MGAPutImage(
+ 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
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAPortPrivPtr pPriv = pMga->portPrivate;
+ INT32 x1, x2, y1, y2;
+ unsigned char *dst_start;
+ int pitch, new_size, offset, offset2 = 0, offset3 = 0;
+ int srcPitch, srcPitch2 = 0, dstPitch;
+ int top, left, npixels, nlines, bpp;
+ BoxRec dstBox;
+ CARD32 tmp;
+
+ /* Clip */
+ x1 = src_x;
+ x2 = src_x + src_w;
+ y1 = src_y;
+ y2 = src_y + src_h;
+
+ dstBox.x1 = drw_x;
+ dstBox.x2 = drw_x + drw_w;
+ dstBox.y1 = drw_y;
+ dstBox.y2 = drw_y + drw_h;
+
+ if(!MGAClipVideo(&dstBox, &x1, &x2, &y1, &y2, clipBoxes, width, height))
+ return Success;
+
+ if(!pMga->TexturedVideo) {
+ dstBox.x1 -= pScrn->frameX0;
+ dstBox.x2 -= pScrn->frameX0;
+ dstBox.y1 -= pScrn->frameY0;
+ dstBox.y2 -= pScrn->frameY0;
+ }
+
+ bpp = pScrn->bitsPerPixel >> 3;
+ pitch = bpp * pScrn->displayWidth;
+
+ dstPitch = ((width << 1) + 15) & ~15;
+ new_size = ((dstPitch * height) + bpp - 1) / bpp;
+
+ switch(id) {
+ case FOURCC_YV12:
+ case FOURCC_I420:
+ srcPitch = (width + 3) & ~3;
+ offset2 = srcPitch * height;
+ srcPitch2 = ((width >> 1) + 3) & ~3;
+ offset3 = (srcPitch2 * (height >> 1)) + offset2;
+ break;
+ case FOURCC_UYVY:
+ case FOURCC_YUY2:
+ default:
+ srcPitch = (width << 1);
+ break;
+ }
+
+ if(!(pPriv->linear = MGAAllocateMemory(pScrn, pPriv->linear,
+ pPriv->doubleBuffer ? (new_size << 1) : new_size)))
+ {
+ return BadAlloc;
+ }
+ pPriv->currentBuffer ^= 1;
+
+ /* copy data */
+ top = y1 >> 16;
+ left = (x1 >> 16) & ~1;
+ npixels = ((((x2 + 0xffff) >> 16) + 1) & ~1) - left;
+ left <<= 1;
+
+ offset = pPriv->linear->offset * bpp;
+ if(pPriv->doubleBuffer)
+ offset += pPriv->currentBuffer * new_size * bpp;
+ dst_start = pMga->FbStart + offset + left + (top * dstPitch);
+
+ if(pMga->TexturedVideo && pMga->AccelInfoRec->NeedToSync &&
+ ((long)data != pPriv->lastPort))
+ {
+ MGAStormSync(pScrn);
+ }
+
+ switch(id) {
+ case FOURCC_YV12:
+ case FOURCC_I420:
+ top &= ~1;
+ tmp = ((top >> 1) * srcPitch2) + (left >> 2);
+ offset2 += tmp;
+ offset3 += tmp;
+ if(id == FOURCC_I420) {
+ tmp = offset2;
+ offset2 = offset3;
+ offset3 = tmp;
+ }
+ nlines = ((((y2 + 0xffff) >> 16) + 1) & ~1) - top;
+ MGACopyMungedData(buf + (top * srcPitch) + (left >> 1),
+ buf + offset2, buf + offset3, dst_start,
+ srcPitch, srcPitch2, dstPitch, nlines, npixels);
+ break;
+ case FOURCC_UYVY:
+ case FOURCC_YUY2:
+ default:
+ buf += (top * srcPitch) + left;
+ nlines = ((y2 + 0xffff) >> 16) - top;
+ MGACopyData(buf, dst_start, srcPitch, dstPitch, nlines, npixels);
+ break;
+ }
+
+ if(pMga->TexturedVideo) {
+ pPriv->lastPort = (long)data;
+ MGADisplayVideoTexture(pScrn, id, offset,
+ REGION_NUM_RECTS(clipBoxes), REGION_RECTS(clipBoxes),
+ width, height, dstPitch, src_x, src_y, src_w, src_h,
+ drw_x, drw_y, drw_w, drw_h);
+ pPriv->videoStatus = FREE_TIMER;
+ pPriv->freeTime = currentTime.milliseconds + FREE_DELAY;
+ } else {
+ /* update cliplist */
+ if(!RegionsEqual(&pPriv->clip, clipBoxes)) {
+ REGION_COPY(pScreen, &pPriv->clip, clipBoxes);
+ /* draw these */
+ XAAFillSolidRects(pScrn, pPriv->colorKey, GXcopy, ~0,
+ REGION_NUM_RECTS(clipBoxes),
+ REGION_RECTS(clipBoxes));
+ }
+
+ offset += top * dstPitch;
+ MGADisplayVideoOverlay(pScrn, id, offset, width, height, dstPitch,
+ x1, y1, x2, y2, &dstBox, src_w, src_h, drw_w, drw_h);
+
+ pPriv->videoStatus = CLIENT_VIDEO_ON;
+ }
+ pMga->VideoTimerCallback = MGAVideoTimerCallback;
+
+ return Success;
+}
+
+
+static int
+MGAQueryImageAttributes(
+ ScrnInfoPtr pScrn,
+ int id,
+ unsigned short *w, unsigned short *h,
+ int *pitches, int *offsets
+){
+ MGAPtr pMga = MGAPTR(pScrn);
+ int size, tmp;
+
+ if(pMga->TexturedVideo) {
+ if(*w > 2046) *w = 2046;
+ if(*h > 2046) *h = 2046;
+ } else {
+ if(*w > 1024) *w = 1024;
+ if(*h > 1024) *h = 1024;
+ }
+
+ *w = (*w + 1) & ~1;
+ if(offsets) offsets[0] = 0;
+
+ switch(id) {
+ case FOURCC_YV12:
+ case FOURCC_I420:
+ *h = (*h + 1) & ~1;
+ size = (*w + 3) & ~3;
+ if(pitches) pitches[0] = size;
+ size *= *h;
+ if(offsets) offsets[1] = size;
+ tmp = ((*w >> 1) + 3) & ~3;
+ if(pitches) pitches[1] = pitches[2] = tmp;
+ tmp *= (*h >> 1);
+ size += tmp;
+ if(offsets) offsets[2] = size;
+ size += tmp;
+ break;
+ case FOURCC_UYVY:
+ case FOURCC_YUY2:
+ default:
+ size = *w << 1;
+ if(pitches) pitches[0] = size;
+ size *= *h;
+ break;
+ }
+
+ return size;
+}
+
+static void
+MGAVideoTimerCallback(ScrnInfoPtr pScrn, Time time)
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAPortPrivPtr pPriv = pMga->portPrivate;
+
+ if(pPriv->videoStatus & TIMER_MASK) {
+ if(pPriv->videoStatus & OFF_TIMER) {
+ if(pPriv->offTime < time) {
+ OUTREG(MGAREG_BESCTL, 0);
+ pPriv->videoStatus = FREE_TIMER;
+ pPriv->freeTime = time + FREE_DELAY;
+ }
+ } else { /* FREE_TIMER */
+ if(pPriv->freeTime < time) {
+ if(pPriv->linear) {
+ xf86FreeOffscreenLinear(pPriv->linear);
+ pPriv->linear = NULL;
+ }
+ pPriv->videoStatus = 0;
+ pMga->VideoTimerCallback = NULL;
+ }
+ }
+ } else /* shouldn't get here */
+ pMga->VideoTimerCallback = NULL;
+}
+
+
+/****************** Offscreen stuff ***************/
+
+typedef struct {
+ FBLinearPtr linear;
+ Bool isOn;
+} OffscreenPrivRec, * OffscreenPrivPtr;
+
+static int
+MGAAllocateSurface(
+ ScrnInfoPtr pScrn,
+ int id,
+ unsigned short w,
+ unsigned short h,
+ XF86SurfacePtr surface
+){
+ FBLinearPtr linear;
+ int pitch, fbpitch, size, bpp;
+ OffscreenPrivPtr pPriv;
+
+ if((w > 1024) || (h > 1024))
+ return BadAlloc;
+
+ w = (w + 1) & ~1;
+ pitch = ((w << 1) + 15) & ~15;
+ bpp = pScrn->bitsPerPixel >> 3;
+ fbpitch = bpp * pScrn->displayWidth;
+ size = ((pitch * h) + bpp - 1) / bpp;
+
+ if(!(linear = MGAAllocateMemory(pScrn, NULL, size)))
+ return BadAlloc;
+
+ surface->width = w;
+ surface->height = h;
+
+ if(!(surface->pitches = xalloc(sizeof(int)))) {
+ xf86FreeOffscreenLinear(linear);
+ return BadAlloc;
+ }
+ if(!(surface->offsets = xalloc(sizeof(int)))) {
+ xfree(surface->pitches);
+ xf86FreeOffscreenLinear(linear);
+ return BadAlloc;
+ }
+ if(!(pPriv = xalloc(sizeof(OffscreenPrivRec)))) {
+ xfree(surface->pitches);
+ xfree(surface->offsets);
+ xf86FreeOffscreenLinear(linear);
+ return BadAlloc;
+ }
+
+ pPriv->linear = linear;
+ pPriv->isOn = FALSE;
+
+ surface->pScrn = pScrn;
+ surface->id = id;
+ surface->pitches[0] = pitch;
+ surface->offsets[0] = linear->offset * bpp;
+ surface->devPrivate.ptr = (pointer)pPriv;
+
+ return Success;
+}
+
+static int
+MGAStopSurface(
+ XF86SurfacePtr surface
+){
+ OffscreenPrivPtr pPriv = (OffscreenPrivPtr)surface->devPrivate.ptr;
+
+ if(pPriv->isOn) {
+ MGAPtr pMga = MGAPTR(surface->pScrn);
+ OUTREG(MGAREG_BESCTL, 0);
+ pPriv->isOn = FALSE;
+ }
+
+ return Success;
+}
+
+
+static int
+MGAFreeSurface(
+ XF86SurfacePtr surface
+){
+ OffscreenPrivPtr pPriv = (OffscreenPrivPtr)surface->devPrivate.ptr;
+
+ if(pPriv->isOn)
+ MGAStopSurface(surface);
+ xf86FreeOffscreenLinear(pPriv->linear);
+ xfree(surface->pitches);
+ xfree(surface->offsets);
+ xfree(surface->devPrivate.ptr);
+
+ return Success;
+}
+
+static int
+MGAGetSurfaceAttribute(
+ ScrnInfoPtr pScrn,
+ Atom attribute,
+ INT32 *value
+){
+ return MGAGetPortAttributeOverlay(pScrn, attribute, value, 0);
+}
+
+static int
+MGASetSurfaceAttribute(
+ ScrnInfoPtr pScrn,
+ Atom attribute,
+ INT32 value
+){
+ return MGASetPortAttributeOverlay(pScrn, attribute, value, 0);
+}
+
+
+static int
+MGADisplaySurface(
+ XF86SurfacePtr surface,
+ short src_x, short src_y,
+ short drw_x, short drw_y,
+ short src_w, short src_h,
+ short drw_w, short drw_h,
+ RegionPtr clipBoxes
+){
+ OffscreenPrivPtr pPriv = (OffscreenPrivPtr)surface->devPrivate.ptr;
+ ScrnInfoPtr pScrn = surface->pScrn;
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAPortPrivPtr portPriv = pMga->portPrivate;
+ INT32 x1, y1, x2, y2;
+ BoxRec dstBox;
+
+ x1 = src_x;
+ x2 = src_x + src_w;
+ y1 = src_y;
+ y2 = src_y + src_h;
+
+ dstBox.x1 = drw_x;
+ dstBox.x2 = drw_x + drw_w;
+ dstBox.y1 = drw_y;
+ dstBox.y2 = drw_y + drw_h;
+
+ if(!MGAClipVideo(&dstBox, &x1, &x2, &y1, &y2, clipBoxes,
+ surface->width, surface->height))
+ {
+ return Success;
+ }
+
+ dstBox.x1 -= pScrn->frameX0;
+ dstBox.x2 -= pScrn->frameX0;
+ dstBox.y1 -= pScrn->frameY0;
+ dstBox.y2 -= pScrn->frameY0;
+
+ MGAResetVideoOverlay(pScrn);
+
+ MGADisplayVideoOverlay(pScrn, surface->id, surface->offsets[0],
+ surface->width, surface->height, surface->pitches[0],
+ x1, y1, x2, y2, &dstBox, src_w, src_h, drw_w, drw_h);
+
+ XAAFillSolidRects(pScrn, portPriv->colorKey, GXcopy, ~0,
+ REGION_NUM_RECTS(clipBoxes),
+ REGION_RECTS(clipBoxes));
+
+ pPriv->isOn = TRUE;
+ /* we've prempted the XvImage stream so set its free timer */
+ if(portPriv->videoStatus & CLIENT_VIDEO_ON) {
+ REGION_EMPTY(pScrn->pScreen, &portPriv->clip);
+ UpdateCurrentTime();
+ portPriv->videoStatus = FREE_TIMER;
+ portPriv->freeTime = currentTime.milliseconds + FREE_DELAY;
+ pMga->VideoTimerCallback = MGAVideoTimerCallback;
+ }
+
+ return Success;
+}
+
+
+static void
+MGAInitOffscreenImages(ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ int num = (pMga->Chipset == PCI_CHIP_MGAG400 || pMga->Chipset == PCI_CHIP_MGAG550) ? 2 : 1;
+ XF86OffscreenImagePtr offscreenImages;
+
+ /* need to free this someplace */
+ if(!(offscreenImages = xalloc(num * sizeof(XF86OffscreenImageRec))))
+ return;
+
+ offscreenImages[0].image = &Images[0];
+ offscreenImages[0].flags = VIDEO_OVERLAID_IMAGES |
+ VIDEO_CLIP_TO_VIEWPORT;
+ offscreenImages[0].alloc_surface = MGAAllocateSurface;
+ offscreenImages[0].free_surface = MGAFreeSurface;
+ offscreenImages[0].display = MGADisplaySurface;
+ offscreenImages[0].stop = MGAStopSurface;
+ offscreenImages[0].setAttribute = MGASetSurfaceAttribute;
+ offscreenImages[0].getAttribute = MGAGetSurfaceAttribute;
+ offscreenImages[0].max_width = 1024;
+ offscreenImages[0].max_height = 1024;
+ offscreenImages[0].num_attributes = (num == 1) ? 1 : 4;
+ offscreenImages[0].attributes = Attributes;
+
+ if(num == 2) {
+ offscreenImages[1].image = &Images[3];
+ offscreenImages[1].flags = VIDEO_OVERLAID_IMAGES |
+ VIDEO_CLIP_TO_VIEWPORT;
+ offscreenImages[1].alloc_surface = MGAAllocateSurface;
+ offscreenImages[1].free_surface = MGAFreeSurface;
+ offscreenImages[1].display = MGADisplaySurface;
+ offscreenImages[1].stop = MGAStopSurface;
+ offscreenImages[1].setAttribute = MGASetSurfaceAttribute;
+ offscreenImages[1].getAttribute = MGAGetSurfaceAttribute;
+ offscreenImages[1].max_width = 1024;
+ offscreenImages[1].max_height = 1024;
+ offscreenImages[1].num_attributes = 4;
+ offscreenImages[1].attributes = Attributes;
+ }
+
+ xf86XVRegisterOffscreenImages(pScreen, offscreenImages, num);
+}
+
+#endif /* !XvExtension */
diff --git a/src/mgareg_flags.h b/src/mgareg_flags.h
new file mode 100644
index 0000000..69050fc
--- /dev/null
+++ b/src/mgareg_flags.h
@@ -0,0 +1,931 @@
+/* author: stephen crowley, crow@debian.org */
+
+/*
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * STEPHEN CROWLEY, OR ANY OTHER CONTRIBUTORS 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.
+ */
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mgareg_flags.h,v 1.2 2003/01/12 03:55:47 tsi Exp $ */
+
+#ifndef _MGAREGS_H_
+#define _MGAREGS_H_
+
+/*************** (START) AUTOMATICLY GENERATED REGISTER FILE *****************/
+/*
+ * Generated on Sat Nov 20 21:25:36 CST 1999
+ */
+
+
+
+/*
+ * Power Graphic Mode Memory Space Registers
+ */
+
+# define AGP_PLL_agp2xpllen_MASK 0xfffffffe /* bit 0 */
+# define AGP_PLL_agp2xpllen_disable 0x0
+# define AGP_PLL_agp2xpllen_enable 0x1
+
+# define AC_src_MASK 0xfffffff0 /* bits 0-3 */
+# define AC_src_zero 0x0 /* val 0, shift 0 */
+# define AC_src_one 0x1 /* val 1, shift 0 */
+# define AC_src_dst_color 0x2 /* val 2, shift 0 */
+# define AC_src_om_dst_color 0x3 /* val 3, shift 0 */
+# define AC_src_src_alpha 0x4 /* val 4, shift 0 */
+# define AC_src_om_src_alpha 0x5 /* val 5, shift 0 */
+# define AC_src_dst_alpha 0x6 /* val 6, shift 0 */
+# define AC_src_om_dst_alpha 0x7 /* val 7, shift 0 */
+# define AC_src_src_alpha_sat 0x8 /* val 8, shift 0 */
+# define AC_dst_MASK 0xffffff0f /* bits 4-7 */
+# define AC_dst_zero 0x0 /* val 0, shift 4 */
+# define AC_dst_one 0x10 /* val 1, shift 4 */
+# define AC_dst_src_color 0x20 /* val 2, shift 4 */
+# define AC_dst_om_src_color 0x30 /* val 3, shift 4 */
+# define AC_dst_src_alpha 0x40 /* val 4, shift 4 */
+# define AC_dst_om_src_alpha 0x50 /* val 5, shift 4 */
+# define AC_dst_dst_alpha 0x60 /* val 6, shift 4 */
+# define AC_dst_om_dst_alpha 0x70 /* val 7, shift 4 */
+# define AC_amode_MASK 0xfffffcff /* bits 8-9 */
+# define AC_amode_FCOL 0x0 /* val 0, shift 8 */
+# define AC_amode_alpha_channel 0x100 /* val 1, shift 8 */
+# define AC_amode_video_alpha 0x200 /* val 2, shift 8 */
+# define AC_amode_RSVD 0x300 /* val 3, shift 8 */
+# define AC_astipple_MASK 0xfffff7ff /* bit 11 */
+# define AC_astipple_disable 0x0
+# define AC_astipple_enable 0x800
+# define AC_aten_MASK 0xffffefff /* bit 12 */
+# define AC_aten_disable 0x0
+# define AC_aten_enable 0x1000
+# define AC_atmode_MASK 0xffff1fff /* bits 13-15 */
+# define AC_atmode_noacmp 0x0 /* val 0, shift 13 */
+# define AC_atmode_ae 0x4000 /* val 2, shift 13 */
+# define AC_atmode_ane 0x6000 /* val 3, shift 13 */
+# define AC_atmode_alt 0x8000 /* val 4, shift 13 */
+# define AC_atmode_alte 0xa000 /* val 5, shift 13 */
+# define AC_atmode_agt 0xc000 /* val 6, shift 13 */
+# define AC_atmode_agte 0xe000 /* val 7, shift 13 */
+# define AC_atref_MASK 0xff00ffff /* bits 16-23 */
+# define AC_atref_SHIFT 16
+# define AC_alphasel_MASK 0xfcffffff /* bits 24-25 */
+# define AC_alphasel_fromtex 0x0 /* val 0, shift 24 */
+# define AC_alphasel_diffused 0x1000000 /* val 1, shift 24 */
+# define AC_alphasel_modulated 0x2000000 /* val 2, shift 24 */
+# define AC_alphasel_trans 0x3000000 /* val 3, shift 24 */
+
+# define AR0_ar0_MASK 0xfffc0000 /* bits 0-17 */
+# define AR0_ar0_SHIFT 0
+
+# define AR1_ar1_MASK 0xff000000 /* bits 0-23 */
+# define AR1_ar1_SHIFT 0
+
+# define AR2_ar2_MASK 0xfffc0000 /* bits 0-17 */
+# define AR2_ar2_SHIFT 0
+
+# define AR3_ar3_MASK 0xff000000 /* bits 0-23 */
+# define AR3_ar3_SHIFT 0
+# define AR3_spage_MASK 0xf8ffffff /* bits 24-26 */
+# define AR3_spage_SHIFT 24
+
+# define AR4_ar4_MASK 0xfffc0000 /* bits 0-17 */
+# define AR4_ar4_SHIFT 0
+
+# define AR5_ar5_MASK 0xfffc0000 /* bits 0-17 */
+# define AR5_ar5_SHIFT 0
+
+# define AR6_ar6_MASK 0xfffc0000 /* bits 0-17 */
+# define AR6_ar6_SHIFT 0
+
+# define BC_besen_MASK 0xfffffffe /* bit 0 */
+# define BC_besen_disable 0x0
+# define BC_besen_enable 0x1
+# define BC_besv1srcstp_MASK 0xffffffbf /* bit 6 */
+# define BC_besv1srcstp_even 0x0
+# define BC_besv1srcstp_odd 0x40
+# define BC_besv2srcstp_MASK 0xfffffeff /* bit 8 */
+# define BC_besv2srcstp_disable 0x0
+# define BC_besv2srcstp_enable 0x100
+# define BC_beshfen_MASK 0xfffffbff /* bit 10 */
+# define BC_beshfen_disable 0x0
+# define BC_beshfen_enable 0x400
+# define BC_besvfen_MASK 0xfffff7ff /* bit 11 */
+# define BC_besvfen_disable 0x0
+# define BC_besvfen_enable 0x800
+# define BC_beshfixc_MASK 0xffffefff /* bit 12 */
+# define BC_beshfixc_weight 0x0
+# define BC_beshfixc_coeff 0x1000
+# define BC_bescups_MASK 0xfffeffff /* bit 16 */
+# define BC_bescups_disable 0x0
+# define BC_bescups_enable 0x10000
+# define BC_bes420pl_MASK 0xfffdffff /* bit 17 */
+# define BC_bes420pl_422 0x0
+# define BC_bes420pl_420 0x20000
+# define BC_besdith_MASK 0xfffbffff /* bit 18 */
+# define BC_besdith_disable 0x0
+# define BC_besdith_enable 0x40000
+# define BC_beshmir_MASK 0xfff7ffff /* bit 19 */
+# define BC_beshmir_disable 0x0
+# define BC_beshmir_enable 0x80000
+# define BC_besbwen_MASK 0xffefffff /* bit 20 */
+# define BC_besbwen_color 0x0
+# define BC_besbwen_bw 0x100000
+# define BC_besblank_MASK 0xffdfffff /* bit 21 */
+# define BC_besblank_disable 0x0
+# define BC_besblank_enable 0x200000
+# define BC_besfselm_MASK 0xfeffffff /* bit 24 */
+# define BC_besfselm_soft 0x0
+# define BC_besfselm_hard 0x1000000
+# define BC_besfsel_MASK 0xf9ffffff /* bits 25-26 */
+# define BC_besfsel_a1 0x0 /* val 0, shift 25 */
+# define BC_besfsel_a2 0x2000000 /* val 1, shift 25 */
+# define BC_besfsel_b1 0x4000000 /* val 2, shift 25 */
+# define BC_besfsel_b2 0x6000000 /* val 3, shift 25 */
+
+# define BGC_beshzoom_MASK 0xfffffffe /* bit 0 */
+# define BGC_beshzoom_disable 0x0
+# define BGC_beshzoom_enable 0x1
+# define BGC_beshzoomf_MASK 0xfffffffd /* bit 1 */
+# define BGC_beshzoomf_disable 0x0
+# define BGC_beshzoomf_enable 0x2
+# define BGC_bescorder_MASK 0xfffffff7 /* bit 3 */
+# define BGC_bescorder_even 0x0
+# define BGC_bescorder_odd 0x8
+# define BGC_besreghup_MASK 0xffffffef /* bit 4 */
+# define BGC_besreghup_disable 0x0
+# define BGC_besreghup_enable 0x10
+# define BGC_besvcnt_MASK 0xf000ffff /* bits 16-27 */
+# define BGC_besvcnt_SHIFT 16
+
+# define BHC_besright_MASK 0xfffff800 /* bits 0-10 */
+# define BHC_besright_SHIFT 0
+# define BHC_besleft_MASK 0xf800ffff /* bits 16-26 */
+# define BHC_besleft_SHIFT 16
+
+# define BHISF_beshiscal_MASK 0xffe00003 /* bits 2-20 */
+# define BHISF_beshiscal_SHIFT 2
+
+# define BHSE_beshsrcend_MASK 0xfc000003 /* bits 2-25 */
+# define BHSE_beshsrcend_SHIFT 2
+
+# define BHSL_beshsrclst_MASK 0xfc00ffff /* bits 16-25 */
+# define BHSL_beshsrclst_SHIFT 16
+
+# define BHSS_beshsrcst_MASK 0xfc000003 /* bits 2-25 */
+# define BHSS_beshsrcst_SHIFT 2
+
+# define BP_bespitch_MASK 0xfffff000 /* bits 0-11 */
+# define BP_bespitch_SHIFT 0
+
+# define BS_besstat_MASK 0xfffffffc /* bits 0-1 */
+# define BS_besstat_a1 0x0 /* val 0, shift 0 */
+# define BS_besstat_a2 0x1 /* val 1, shift 0 */
+# define BS_besstat_b1 0x2 /* val 2, shift 0 */
+# define BS_besstat_b2 0x3 /* val 3, shift 0 */
+
+# define BSF_besv1srclast_MASK 0xfffffc00 /* bits 0-9 */
+# define BSF_besv1srclast_SHIFT 0
+
+# define BSF_besv2srclst_MASK 0xfffffc00 /* bits 0-9 */
+# define BSF_besv2srclst_SHIFT 0
+
+# define BSF_besv1wght_MASK 0xffff0003 /* bits 2-15 */
+# define BSF_besv1wght_SHIFT 2
+# define BSF_besv1wghts_MASK 0xfffeffff /* bit 16 */
+# define BSF_besv1wghts_disable 0x0
+# define BSF_besv1wghts_enable 0x10000
+
+# define BSF_besv2wght_MASK 0xffff0003 /* bits 2-15 */
+# define BSF_besv2wght_SHIFT 2
+# define BSF_besv2wghts_MASK 0xfffeffff /* bit 16 */
+# define BSF_besv2wghts_disable 0x0
+# define BSF_besv2wghts_enable 0x10000
+
+# define BVC_besbot_MASK 0xfffff800 /* bits 0-10 */
+# define BVC_besbot_SHIFT 0
+# define BVC_bestop_MASK 0xf800ffff /* bits 16-26 */
+# define BVC_bestop_SHIFT 16
+
+# define BVISF_besviscal_MASK 0xffe00003 /* bits 2-20 */
+# define BVISF_besviscal_SHIFT 2
+
+# define CXB_cxleft_MASK 0xfffff000 /* bits 0-11 */
+# define CXB_cxleft_SHIFT 0
+# define CXB_cxright_MASK 0xf000ffff /* bits 16-27 */
+# define CXB_cxright_SHIFT 16
+
+# define DO_dstmap_MASK 0xfffffffe /* bit 0 */
+# define DO_dstmap_fb 0x0
+# define DO_dstmap_sys 0x1
+# define DO_dstacc_MASK 0xfffffffd /* bit 1 */
+# define DO_dstacc_pci 0x0
+# define DO_dstacc_agp 0x2
+# define DO_dstorg_MASK 0x7 /* bits 3-31 */
+# define DO_dstorg_SHIFT 3
+
+# define DC_opcod_MASK 0xfffffff0 /* bits 0-3 */
+# define DC_opcod_line_open 0x0 /* val 0, shift 0 */
+# define DC_opcod_autoline_open 0x1 /* val 1, shift 0 */
+# define DC_opcod_line_close 0x2 /* val 2, shift 0 */
+# define DC_opcod_autoline_close 0x3 /* val 3, shift 0 */
+# define DC_opcod_trap 0x4 /* val 4, shift 0 */
+# define DC_opcod_texture_trap 0x6 /* val 6, shift 0 */
+# define DC_opcod_bitblt 0x8 /* val 8, shift 0 */
+# define DC_opcod_iload 0x9 /* val 9, shift 0 */
+# define DC_atype_MASK 0xffffff8f /* bits 4-6 */
+# define DC_atype_rpl 0x0 /* val 0, shift 4 */
+# define DC_atype_rstr 0x10 /* val 1, shift 4 */
+# define DC_atype_zi 0x30 /* val 3, shift 4 */
+# define DC_atype_blk 0x40 /* val 4, shift 4 */
+# define DC_atype_i 0x70 /* val 7, shift 4 */
+# define DC_linear_MASK 0xffffff7f /* bit 7 */
+# define DC_linear_xy 0x0
+# define DC_linear_linear 0x80
+# define DC_zmode_MASK 0xfffff8ff /* bits 8-10 */
+# define DC_zmode_nozcmp 0x0 /* val 0, shift 8 */
+# define DC_zmode_ze 0x200 /* val 2, shift 8 */
+# define DC_zmode_zne 0x300 /* val 3, shift 8 */
+# define DC_zmode_zlt 0x400 /* val 4, shift 8 */
+# define DC_zmode_zlte 0x500 /* val 5, shift 8 */
+# define DC_zmode_zgt 0x600 /* val 6, shift 8 */
+# define DC_zmode_zgte 0x700 /* val 7, shift 8 */
+# define DC_solid_MASK 0xfffff7ff /* bit 11 */
+# define DC_solid_disable 0x0
+# define DC_solid_enable 0x800
+# define DC_arzero_MASK 0xffffefff /* bit 12 */
+# define DC_arzero_disable 0x0
+# define DC_arzero_enable 0x1000
+# define DC_sgnzero_MASK 0xffffdfff /* bit 13 */
+# define DC_sgnzero_disable 0x0
+# define DC_sgnzero_enable 0x2000
+# define DC_shftzero_MASK 0xffffbfff /* bit 14 */
+# define DC_shftzero_disable 0x0
+# define DC_shftzero_enable 0x4000
+# define DC_bop_MASK 0xfff0ffff /* bits 16-19 */
+# define DC_bop_SHIFT 16
+# define DC_trans_MASK 0xff0fffff /* bits 20-23 */
+# define DC_trans_SHIFT 20
+# define DC_bltmod_MASK 0xe1ffffff /* bits 25-28 */
+# define DC_bltmod_bmonolef 0x0 /* val 0, shift 25 */
+# define DC_bltmod_bmonowf 0x8000000 /* val 4, shift 25 */
+# define DC_bltmod_bplan 0x2000000 /* val 1, shift 25 */
+# define DC_bltmod_bfcol 0x4000000 /* val 2, shift 25 */
+# define DC_bltmod_bu32bgr 0x6000000 /* val 3, shift 25 */
+# define DC_bltmod_bu32rgb 0xe000000 /* val 7, shift 25 */
+# define DC_bltmod_bu24bgr 0x16000000 /* val 11, shift 25 */
+# define DC_bltmod_bu24rgb 0x1e000000 /* val 15, shift 25 */
+# define DC_pattern_MASK 0xdfffffff /* bit 29 */
+# define DC_pattern_disable 0x0
+# define DC_pattern_enable 0x20000000
+# define DC_transc_MASK 0xbfffffff /* bit 30 */
+# define DC_transc_disable 0x0
+# define DC_transc_enable 0x40000000
+# define DC_clipdis_MASK 0x7fffffff /* bit 31 */
+# define DC_clipdis_disable 0x0
+# define DC_clipdis_enable 0x80000000
+
+# define DS_dwgsyncaddr_MASK 0x3 /* bits 2-31 */
+# define DS_dwgsyncaddr_SHIFT 2
+
+# define FS_fifocount_MASK 0xffffff80 /* bits 0-6 */
+# define FS_fifocount_SHIFT 0
+# define FS_bfull_MASK 0xfffffeff /* bit 8 */
+# define FS_bfull_disable 0x0
+# define FS_bfull_enable 0x100
+# define FS_bempty_MASK 0xfffffdff /* bit 9 */
+# define FS_bempty_disable 0x0
+# define FS_bempty_enable 0x200
+
+# define XA_fxleft_MASK 0xffff0000 /* bits 0-15 */
+# define XA_fxleft_SHIFT 0
+# define XA_fxright_MASK 0xffff /* bits 16-31 */
+# define XA_fxright_SHIFT 16
+
+# define IC_softrapiclr_MASK 0xfffffffe /* bit 0 */
+# define IC_softrapiclr_disable 0x0
+# define IC_softrapiclr_enable 0x1
+# define IC_pickiclr_MASK 0xfffffffb /* bit 2 */
+# define IC_pickiclr_disable 0x0
+# define IC_pickiclr_enable 0x4
+# define IC_vlineiclr_MASK 0xffffffdf /* bit 5 */
+# define IC_vlineiclr_disable 0x0
+# define IC_vlineiclr_enable 0x20
+# define IC_wiclr_MASK 0xffffff7f /* bit 7 */
+# define IC_wiclr_disable 0x0
+# define IC_wiclr_enable 0x80
+# define IC_wciclr_MASK 0xfffffeff /* bit 8 */
+# define IC_wciclr_disable 0x0
+# define IC_wciclr_enable 0x100
+
+# define IE_softrapien_MASK 0xfffffffe /* bit 0 */
+# define IE_softrapien_disable 0x0
+# define IE_softrapien_enable 0x1
+# define IE_pickien_MASK 0xfffffffb /* bit 2 */
+# define IE_pickien_disable 0x0
+# define IE_pickien_enable 0x4
+# define IE_vlineien_MASK 0xffffffdf /* bit 5 */
+# define IE_vlineien_disable 0x0
+# define IE_vlineien_enable 0x20
+# define IE_extien_MASK 0xffffffbf /* bit 6 */
+# define IE_extien_disable 0x0
+# define IE_extien_enable 0x40
+# define IE_wien_MASK 0xffffff7f /* bit 7 */
+# define IE_wien_disable 0x0
+# define IE_wien_enable 0x80
+# define IE_wcien_MASK 0xfffffeff /* bit 8 */
+# define IE_wcien_disable 0x0
+# define IE_wcien_enable 0x100
+
+# define MA_pwidth_MASK 0xfffffffc /* bits 0-1 */
+# define MA_pwidth_8 0x0 /* val 0, shift 0 */
+# define MA_pwidth_16 0x1 /* val 1, shift 0 */
+# define MA_pwidth_32 0x2 /* val 2, shift 0 */
+# define MA_pwidth_24 0x3 /* val 3, shift 0 */
+# define MA_zwidth_MASK 0xffffffe7 /* bits 3-4 */
+# define MA_zwidth_16 0x0 /* val 0, shift 3 */
+# define MA_zwidth_32 0x8 /* val 1, shift 3 */
+# define MA_zwidth_15 0x10 /* val 2, shift 3 */
+# define MA_zwidth_24 0x18 /* val 3, shift 3 */
+# define MA_memreset_MASK 0xffff7fff /* bit 15 */
+# define MA_memreset_disable 0x0
+# define MA_memreset_enable 0x8000
+# define MA_fogen_MASK 0xfbffffff /* bit 26 */
+# define MA_fogen_disable 0x0
+# define MA_fogen_enable 0x4000000
+# define MA_tlutload_MASK 0xdfffffff /* bit 29 */
+# define MA_tlutload_disable 0x0
+# define MA_tlutload_enable 0x20000000
+# define MA_nodither_MASK 0xbfffffff /* bit 30 */
+# define MA_nodither_disable 0x0
+# define MA_nodither_enable 0x40000000
+# define MA_dit555_MASK 0x7fffffff /* bit 31 */
+# define MA_dit555_disable 0x0
+# define MA_dit555_enable 0x80000000
+
+# define MCWS_casltncy_MASK 0xfffffff8 /* bits 0-2 */
+# define MCWS_casltncy_SHIFT 0
+# define MCWS_rrddelay_MASK 0xffffffcf /* bits 4-5 */
+# define MCWS_rcddelay_MASK 0xfffffe7f /* bits 7-8 */
+# define MCWS_rasmin_MASK 0xffffe3ff /* bits 10-12 */
+# define MCWS_rasmin_SHIFT 10
+# define MCWS_rpdelay_MASK 0xffff3fff /* bits 14-15 */
+# define MCWS_wrdelay_MASK 0xfff3ffff /* bits 18-19 */
+# define MCWS_rddelay_MASK 0xffdfffff /* bit 21 */
+# define MCWS_rddelay_disable 0x0
+# define MCWS_rddelay_enable 0x200000
+# define MCWS_smrdelay_MASK 0xfe7fffff /* bits 23-24 */
+# define MCWS_bwcdelay_MASK 0xf3ffffff /* bits 26-27 */
+# define MCWS_bpldelay_MASK 0x1fffffff /* bits 29-31 */
+# define MCWS_bpldelay_SHIFT 29
+
+# define MRB_mclkbrd0_MASK 0xfffffff0 /* bits 0-3 */
+# define MRB_mclkbrd0_SHIFT 0
+# define MRB_mclkbrd1_MASK 0xfffffe1f /* bits 5-8 */
+# define MRB_mclkbrd1_SHIFT 5
+# define MRB_strmfctl_MASK 0xff3fffff /* bits 22-23 */
+# define MRB_mrsopcod_MASK 0xe1ffffff /* bits 25-28 */
+# define MRB_mrsopcod_SHIFT 25
+
+# define OM_dmamod_MASK 0xfffffff3 /* bits 2-3 */
+# define OM_dmamod_general 0x0 /* val 0, shift 2 */
+# define OM_dmamod_blit 0x4 /* val 1, shift 2 */
+# define OM_dmamod_vector 0x8 /* val 2, shift 2 */
+# define OM_dmamod_vertex 0xc /* val 3, shift 2 */
+# define OM_dmadatasiz_MASK 0xfffffcff /* bits 8-9 */
+# define OM_dmadatasiz_8 0x0 /* val 0, shift 8 */
+# define OM_dmadatasiz_16 0x100 /* val 1, shift 8 */
+# define OM_dmadatasiz_32 0x200 /* val 2, shift 8 */
+# define OM_dirdatasiz_MASK 0xfffcffff /* bits 16-17 */
+# define OM_dirdatasiz_8 0x0 /* val 0, shift 16 */
+# define OM_dirdatasiz_16 0x10000 /* val 1, shift 16 */
+# define OM_dirdatasiz_32 0x20000 /* val 2, shift 16 */
+
+# define P_iy_MASK 0xffffe000 /* bits 0-12 */
+# define P_iy_SHIFT 0
+# define P_ylin_MASK 0xffff7fff /* bit 15 */
+# define P_ylin_disable 0x0
+# define P_ylin_enable 0x8000
+
+# define PDCA_primod_MASK 0xfffffffc /* bits 0-1 */
+# define PDCA_primod_general 0x0 /* val 0, shift 0 */
+# define PDCA_primod_blit 0x1 /* val 1, shift 0 */
+# define PDCA_primod_vector 0x2 /* val 2, shift 0 */
+# define PDCA_primod_vertex 0x3 /* val 3, shift 0 */
+# define PDCA_primaddress_MASK 0x3 /* bits 2-31 */
+# define PDCA_primaddress_SHIFT 2
+
+# define PDEA_primnostart_MASK 0xfffffffe /* bit 0 */
+# define PDEA_primnostart_disable 0x0
+# define PDEA_primnostart_enable 0x1
+# define PDEA_pagpxfer_MASK 0xfffffffd /* bit 1 */
+# define PDEA_pagpxfer_disable 0x0
+# define PDEA_pagpxfer_enable 0x2
+# define PDEA_primend_MASK 0x3 /* bits 2-31 */
+# define PDEA_primend_SHIFT 2
+
+# define PLS_primptren0_MASK 0xfffffffe /* bit 0 */
+# define PLS_primptren0_disable 0x0
+# define PLS_primptren0_enable 0x1
+# define PLS_primptren1_MASK 0xfffffffd /* bit 1 */
+# define PLS_primptren1_disable 0x0
+# define PLS_primptren1_enable 0x2
+# define PLS_primptr_MASK 0x7 /* bits 3-31 */
+# define PLS_primptr_SHIFT 3
+
+# define R_softreset_MASK 0xfffffffe /* bit 0 */
+# define R_softreset_disable 0x0
+# define R_softreset_enable 0x1
+# define R_softextrst_MASK 0xfffffffd /* bit 1 */
+# define R_softextrst_disable 0x0
+# define R_softextrst_enable 0x2
+
+# define SDCA_secmod_MASK 0xfffffffc /* bits 0-1 */
+# define SDCA_secmod_general 0x0 /* val 0, shift 0 */
+# define SDCA_secmod_blit 0x1 /* val 1, shift 0 */
+# define SDCA_secmod_vector 0x2 /* val 2, shift 0 */
+# define SDCA_secmod_vertex 0x3 /* val 3, shift 0 */
+# define SDCA_secaddress_MASK 0x3 /* bits 2-31 */
+# define SDCA_secaddress_SHIFT 2
+
+# define SDEA_sagpxfer_MASK 0xfffffffd /* bit 1 */
+# define SDEA_sagpxfer_disable 0x0
+# define SDEA_sagpxfer_enable 0x2
+# define SDEA_secend_MASK 0x3 /* bits 2-31 */
+# define SDEA_secend_SHIFT 2
+
+# define SETDCA_setupmod_MASK 0xfffffffc /* bits 0-1 */
+# define SETDCA_setupmod_vertlist 0x0 /* val 0, shift 0 */
+# define SETDCA_setupaddress_MASK 0x3 /* bits 2-31 */
+# define SETDCA_setupaddress_SHIFT 2
+
+# define SETDEA_setupagpxfer_MASK 0xfffffffd /* bit 1 */
+# define SETDEA_setupagpxfer_disable 0x0
+# define SETDEA_setupagpxfer_enable 0x2
+# define SETDEA_setupend_MASK 0x3 /* bits 2-31 */
+# define SETDEA_setupend_SHIFT 2
+
+# define S_sdydxl_MASK 0xfffffffe /* bit 0 */
+# define S_sdydxl_y 0x0
+# define S_sdydxl_x 0x1
+# define S_scanleft_MASK 0xfffffffe /* bit 0 */
+# define S_scanleft_disable 0x0
+# define S_scanleft_enable 0x1
+# define S_sdxl_MASK 0xfffffffd /* bit 1 */
+# define S_sdxl_pos 0x0
+# define S_sdxl_neg 0x2
+# define S_sdy_MASK 0xfffffffb /* bit 2 */
+# define S_sdy_pos 0x0
+# define S_sdy_neg 0x4
+# define S_sdxr_MASK 0xffffffdf /* bit 5 */
+# define S_sdxr_pos 0x0
+# define S_sdxr_neg 0x20
+# define S_brkleft_MASK 0xfffffeff /* bit 8 */
+# define S_brkleft_disable 0x0
+# define S_brkleft_enable 0x100
+# define S_errorinit_MASK 0x7fffffff /* bit 31 */
+# define S_errorinit_disable 0x0
+# define S_errorinit_enable 0x80000000
+
+# define FSC_x_off_MASK 0xfffffff0 /* bits 0-3 */
+# define FSC_x_off_SHIFT 0
+# define FSC_funcnt_MASK 0xffffff80 /* bits 0-6 */
+# define FSC_funcnt_SHIFT 0
+# define FSC_y_off_MASK 0xffffff8f /* bits 4-6 */
+# define FSC_y_off_SHIFT 4
+# define FSC_funoff_MASK 0xffc0ffff /* bits 16-21 */
+# define FSC_funoff_SHIFT 16
+# define FSC_stylelen_MASK 0xffc0ffff /* bits 16-21 */
+# define FSC_stylelen_SHIFT 16
+
+
+# define STH_softraphand_MASK 0x3 /* bits 2-31 */
+# define STH_softraphand_SHIFT 2
+
+# define SO_srcmap_MASK 0xfffffffe /* bit 0 */
+# define SO_srcmap_fb 0x0
+# define SO_srcmap_sys 0x1
+# define SO_srcacc_MASK 0xfffffffd /* bit 1 */
+# define SO_srcacc_pci 0x0
+# define SO_srcacc_agp 0x2
+# define SO_srcorg_MASK 0x7 /* bits 3-31 */
+# define SO_srcorg_SHIFT 3
+
+# define STAT_softrapen_MASK 0xfffffffe /* bit 0 */
+# define STAT_softrapen_disable 0x0
+# define STAT_softrapen_enable 0x1
+# define STAT_pickpen_MASK 0xfffffffb /* bit 2 */
+# define STAT_pickpen_disable 0x0
+# define STAT_pickpen_enable 0x4
+# define STAT_vsyncsts_MASK 0xfffffff7 /* bit 3 */
+# define STAT_vsyncsts_disable 0x0
+# define STAT_vsyncsts_enable 0x8
+# define STAT_vsyncpen_MASK 0xffffffef /* bit 4 */
+# define STAT_vsyncpen_disable 0x0
+# define STAT_vsyncpen_enable 0x10
+# define STAT_vlinepen_MASK 0xffffffdf /* bit 5 */
+# define STAT_vlinepen_disable 0x0
+# define STAT_vlinepen_enable 0x20
+# define STAT_extpen_MASK 0xffffffbf /* bit 6 */
+# define STAT_extpen_disable 0x0
+# define STAT_extpen_enable 0x40
+# define STAT_wpen_MASK 0xffffff7f /* bit 7 */
+# define STAT_wpen_disable 0x0
+# define STAT_wpen_enable 0x80
+# define STAT_wcpen_MASK 0xfffffeff /* bit 8 */
+# define STAT_wcpen_disable 0x0
+# define STAT_wcpen_enable 0x100
+# define STAT_dwgengsts_MASK 0xfffeffff /* bit 16 */
+# define STAT_dwgengsts_disable 0x0
+# define STAT_dwgengsts_enable 0x10000
+# define STAT_endprdmasts_MASK 0xfffdffff /* bit 17 */
+# define STAT_endprdmasts_disable 0x0
+# define STAT_endprdmasts_enable 0x20000
+# define STAT_wbusy_MASK 0xfffbffff /* bit 18 */
+# define STAT_wbusy_disable 0x0
+# define STAT_wbusy_enable 0x40000
+# define STAT_swflag_MASK 0xfffffff /* bits 28-31 */
+# define STAT_swflag_SHIFT 28
+
+# define S_sref_MASK 0xffffff00 /* bits 0-7 */
+# define S_sref_SHIFT 0
+# define S_smsk_MASK 0xffff00ff /* bits 8-15 */
+# define S_smsk_SHIFT 8
+# define S_swtmsk_MASK 0xff00ffff /* bits 16-23 */
+# define S_swtmsk_SHIFT 16
+
+# define SC_smode_MASK 0xfffffff8 /* bits 0-2 */
+# define SC_smode_salways 0x0 /* val 0, shift 0 */
+# define SC_smode_snever 0x1 /* val 1, shift 0 */
+# define SC_smode_se 0x2 /* val 2, shift 0 */
+# define SC_smode_sne 0x3 /* val 3, shift 0 */
+# define SC_smode_slt 0x4 /* val 4, shift 0 */
+# define SC_smode_slte 0x5 /* val 5, shift 0 */
+# define SC_smode_sgt 0x6 /* val 6, shift 0 */
+# define SC_smode_sgte 0x7 /* val 7, shift 0 */
+# define SC_sfailop_MASK 0xffffffc7 /* bits 3-5 */
+# define SC_sfailop_keep 0x0 /* val 0, shift 3 */
+# define SC_sfailop_zero 0x8 /* val 1, shift 3 */
+# define SC_sfailop_replace 0x10 /* val 2, shift 3 */
+# define SC_sfailop_incrsat 0x18 /* val 3, shift 3 */
+# define SC_sfailop_decrsat 0x20 /* val 4, shift 3 */
+# define SC_sfailop_invert 0x28 /* val 5, shift 3 */
+# define SC_sfailop_incr 0x30 /* val 6, shift 3 */
+# define SC_sfailop_decr 0x38 /* val 7, shift 3 */
+# define SC_szfailop_MASK 0xfffffe3f /* bits 6-8 */
+# define SC_szfailop_keep 0x0 /* val 0, shift 6 */
+# define SC_szfailop_zero 0x40 /* val 1, shift 6 */
+# define SC_szfailop_replace 0x80 /* val 2, shift 6 */
+# define SC_szfailop_incrsat 0xc0 /* val 3, shift 6 */
+# define SC_szfailop_decrsat 0x100 /* val 4, shift 6 */
+# define SC_szfailop_invert 0x140 /* val 5, shift 6 */
+# define SC_szfailop_incr 0x180 /* val 6, shift 6 */
+# define SC_szfailop_decr 0x1c0 /* val 7, shift 6 */
+# define SC_szpassop_MASK 0xfffff1ff /* bits 9-11 */
+# define SC_szpassop_keep 0x0 /* val 0, shift 9 */
+# define SC_szpassop_zero 0x200 /* val 1, shift 9 */
+# define SC_szpassop_replace 0x400 /* val 2, shift 9 */
+# define SC_szpassop_incrsat 0x600 /* val 3, shift 9 */
+# define SC_szpassop_decrsat 0x800 /* val 4, shift 9 */
+# define SC_szpassop_invert 0xa00 /* val 5, shift 9 */
+# define SC_szpassop_incr 0xc00 /* val 6, shift 9 */
+# define SC_szpassop_decr 0xe00 /* val 7, shift 9 */
+
+# define TD1_color1arg2selMASK 0xfffffffc /* bits 0-1 */
+# define TD1_color1alphaselMASK 0xffffffe3 /* bits 2-4 */
+# define TD1_color1alphaselSHIFT 2
+# define TD1_color1arg1alphaMASK 0xffffffdf /* bit 5 */
+# define TD1_color1arg1alphadisable 0x0
+# define TD1_color1arg1alphaenable 0x20
+# define TD1_color1arg1invMASK 0xffffffbf /* bit 6 */
+# define TD1_color1arg1invdisable 0x0
+# define TD1_color1arg1invenable 0x40
+# define TD1_color1arg2alphaMASK 0xffffff7f /* bit 7 */
+# define TD1_color1arg2alphadisable 0x0
+# define TD1_color1arg2alphaenable 0x80
+# define TD1_color1arg2invMASK 0xfffffeff /* bit 8 */
+# define TD1_color1arg2invdisable 0x0
+# define TD1_color1arg2invenable 0x100
+# define TD1_color1alpha1invMASK 0xfffffdff /* bit 9 */
+# define TD1_color1alpha1invdisable 0x0
+# define TD1_color1alpha1invenable 0x200
+# define TD1_color1alpha2invMASK 0xfffffbff /* bit 10 */
+# define TD1_color1alpha2invdisable 0x0
+# define TD1_color1alpha2invenable 0x400
+# define TD1_color1selMASK 0xff9fffff /* bits 21-22 */
+# define TD1_color1selarg1 0x0 /* val 0, shift 21 */
+# define TD1_color1selarg2 0x200000 /* val 1, shift 21 */
+# define TD1_color1seladd 0x400000 /* val 2, shift 21 */
+# define TD1_color1selmul 0x600000 /* val 3, shift 21 */
+# define TD1_alpha1selMASK 0x3fffffff /* bits 30-31 */
+# define TD1_alpha1selarg1 0x0 /* val 0, shift 30 */
+# define TD1_alpha1selarg2 0x40000000 /* val 1, shift 30 */
+# define TD1_alpha1seladd 0x80000000 /* val 2, shift 30 */
+# define TD1_alpha1selmul 0xc0000000 /* val 3, shift 30 */
+
+# define TST_ramtsten_MASK 0xfffffffe /* bit 0 */
+# define TST_ramtsten_disable 0x0
+# define TST_ramtsten_enable 0x1
+# define TST_ramtstdone_MASK 0xfffffffd /* bit 1 */
+# define TST_ramtstdone_disable 0x0
+# define TST_ramtstdone_enable 0x2
+# define TST_wramtstpass_MASK 0xfffffffb /* bit 2 */
+# define TST_wramtstpass_disable 0x0
+# define TST_wramtstpass_enable 0x4
+# define TST_tcachetstpass_MASK 0xfffffff7 /* bit 3 */
+# define TST_tcachetstpass_disable 0x0
+# define TST_tcachetstpass_enable 0x8
+# define TST_tluttstpass_MASK 0xffffffef /* bit 4 */
+# define TST_tluttstpass_disable 0x0
+# define TST_tluttstpass_enable 0x10
+# define TST_luttstpass_MASK 0xffffffdf /* bit 5 */
+# define TST_luttstpass_disable 0x0
+# define TST_luttstpass_enable 0x20
+# define TST_besramtstpass_MASK 0xffffffbf /* bit 6 */
+# define TST_besramtstpass_disable 0x0
+# define TST_besramtstpass_enable 0x40
+# define TST_ringen_MASK 0xfffffeff /* bit 8 */
+# define TST_ringen_disable 0x0
+# define TST_ringen_enable 0x100
+# define TST_apllbyp_MASK 0xfffffdff /* bit 9 */
+# define TST_apllbyp_disable 0x0
+# define TST_apllbyp_enable 0x200
+# define TST_hiten_MASK 0xfffffbff /* bit 10 */
+# define TST_hiten_disable 0x0
+# define TST_hiten_enable 0x400
+# define TST_tmode_MASK 0xffffc7ff /* bits 11-13 */
+# define TST_tmode_SHIFT 11
+# define TST_tclksel_MASK 0xfffe3fff /* bits 14-16 */
+# define TST_tclksel_SHIFT 14
+# define TST_ringcnten_MASK 0xfffdffff /* bit 17 */
+# define TST_ringcnten_disable 0x0
+# define TST_ringcnten_enable 0x20000
+# define TST_ringcnt_MASK 0xc003ffff /* bits 18-29 */
+# define TST_ringcnt_SHIFT 18
+# define TST_ringcntclksl_MASK 0xbfffffff /* bit 30 */
+# define TST_ringcntclksl_disable 0x0
+# define TST_ringcntclksl_enable 0x40000000
+# define TST_biosboot_MASK 0x7fffffff /* bit 31 */
+# define TST_biosboot_disable 0x0
+# define TST_biosboot_enable 0x80000000
+
+# define TMC_tformat_MASK 0xfffffff0 /* bits 0-3 */
+# define TMC_tformat_tw4 0x0 /* val 0, shift 0 */
+# define TMC_tformat_tw8 0x1 /* val 1, shift 0 */
+# define TMC_tformat_tw15 0x2 /* val 2, shift 0 */
+# define TMC_tformat_tw16 0x3 /* val 3, shift 0 */
+# define TMC_tformat_tw12 0x4 /* val 4, shift 0 */
+# define TMC_tformat_tw32 0x6 /* val 6, shift 0 */
+# define TMC_tformat_tw422 0xa /* val 10, shift 0 */
+# define TMC_tpitchlin_MASK 0xfffffeff /* bit 8 */
+# define TMC_tpitchlin_disable 0x0
+# define TMC_tpitchlin_enable 0x100
+# define TMC_tpitchext_MASK 0xfff001ff /* bits 9-19 */
+# define TMC_tpitchext_SHIFT 9
+# define TMC_tpitch_MASK 0xfff8ffff /* bits 16-18 */
+# define TMC_tpitch_SHIFT 16
+# define TMC_owalpha_MASK 0xffbfffff /* bit 22 */
+# define TMC_owalpha_disable 0x0
+# define TMC_owalpha_enable 0x400000
+# define TMC_azeroextend_MASK 0xff7fffff /* bit 23 */
+# define TMC_azeroextend_disable 0x0
+# define TMC_azeroextend_enable 0x800000
+# define TMC_decalckey_MASK 0xfeffffff /* bit 24 */
+# define TMC_decalckey_disable 0x0
+# define TMC_decalckey_enable 0x1000000
+# define TMC_takey_MASK 0xfdffffff /* bit 25 */
+# define TMC_takey_0 0x0
+# define TMC_takey_1 0x2000000
+# define TMC_tamask_MASK 0xfbffffff /* bit 26 */
+# define TMC_tamask_0 0x0
+# define TMC_tamask_1 0x4000000
+# define TMC_clampv_MASK 0xf7ffffff /* bit 27 */
+# define TMC_clampv_disable 0x0
+# define TMC_clampv_enable 0x8000000
+# define TMC_clampu_MASK 0xefffffff /* bit 28 */
+# define TMC_clampu_disable 0x0
+# define TMC_clampu_enable 0x10000000
+# define TMC_tmodulate_MASK 0xdfffffff /* bit 29 */
+# define TMC_tmodulate_disable 0x0
+# define TMC_tmodulate_enable 0x20000000
+# define TMC_strans_MASK 0xbfffffff /* bit 30 */
+# define TMC_strans_disable 0x0
+# define TMC_strans_enable 0x40000000
+# define TMC_itrans_MASK 0x7fffffff /* bit 31 */
+# define TMC_itrans_disable 0x0
+# define TMC_itrans_enable 0x80000000
+
+# define TMC_decalblend_MASK 0xfffffffe /* bit 0 */
+# define TMC_decalblend_disable 0x0
+# define TMC_decalblend_enable 0x1
+# define TMC_idecal_MASK 0xfffffffd /* bit 1 */
+# define TMC_idecal_disable 0x0
+# define TMC_idecal_enable 0x2
+# define TMC_decaldis_MASK 0xfffffffb /* bit 2 */
+# define TMC_decaldis_disable 0x0
+# define TMC_decaldis_enable 0x4
+# define TMC_ckstransdis_MASK 0xffffffef /* bit 4 */
+# define TMC_ckstransdis_disable 0x0
+# define TMC_ckstransdis_enable 0x10
+# define TMC_borderen_MASK 0xffffffdf /* bit 5 */
+# define TMC_borderen_disable 0x0
+# define TMC_borderen_enable 0x20
+# define TMC_specen_MASK 0xffffffbf /* bit 6 */
+# define TMC_specen_disable 0x0
+# define TMC_specen_enable 0x40
+
+# define TF_minfilter_MASK 0xfffffff0 /* bits 0-3 */
+# define TF_minfilter_nrst 0x0 /* val 0, shift 0 */
+# define TF_minfilter_bilin 0x2 /* val 2, shift 0 */
+# define TF_minfilter_cnst 0x3 /* val 3, shift 0 */
+# define TF_minfilter_mm1s 0x8 /* val 8, shift 0 */
+# define TF_minfilter_mm2s 0x9 /* val 9, shift 0 */
+# define TF_minfilter_mm4s 0xa /* val 10, shift 0 */
+# define TF_minfilter_mm8s 0xc /* val 12, shift 0 */
+# define TF_magfilter_MASK 0xffffff0f /* bits 4-7 */
+# define TF_magfilter_nrst 0x0 /* val 0, shift 4 */
+# define TF_magfilter_bilin 0x20 /* val 2, shift 4 */
+# define TF_magfilter_cnst 0x30 /* val 3, shift 4 */
+# define TF_avgstride_MASK 0xfff7ffff /* bit 19 */
+# define TF_avgstride_disable 0x0
+# define TF_avgstride_enable 0x80000
+# define TF_filteralpha_MASK 0xffefffff /* bit 20 */
+# define TF_filteralpha_disable 0x0
+# define TF_filteralpha_enable 0x100000
+# define TF_fthres_MASK 0xe01fffff /* bits 21-28 */
+# define TF_fthres_SHIFT 21
+# define TF_mapnb_MASK 0x1fffffff /* bits 29-31 */
+# define TF_mapnb_SHIFT 29
+
+# define TH_th_MASK 0xffffffc0 /* bits 0-5 */
+# define TH_th_SHIFT 0
+# define TH_rfh_MASK 0xffff81ff /* bits 9-14 */
+# define TH_rfh_SHIFT 9
+# define TH_thmask_MASK 0xe003ffff /* bits 18-28 */
+# define TH_thmask_SHIFT 18
+
+# define TO_texorgmap_MASK 0xfffffffe /* bit 0 */
+# define TO_texorgmap_fb 0x0
+# define TO_texorgmap_sys 0x1
+# define TO_texorgacc_MASK 0xfffffffd /* bit 1 */
+# define TO_texorgacc_pci 0x0
+# define TO_texorgacc_agp 0x2
+# define TO_texorg_MASK 0x1f /* bits 5-31 */
+# define TO_texorg_SHIFT 5
+
+# define TT_tckey_MASK 0xffff0000 /* bits 0-15 */
+# define TT_tckey_SHIFT 0
+# define TT_tkmask_MASK 0xffff /* bits 16-31 */
+# define TT_tkmask_SHIFT 16
+
+# define TT_tckeyh_MASK 0xffff0000 /* bits 0-15 */
+# define TT_tckeyh_SHIFT 0
+# define TT_tkmaskh_MASK 0xffff /* bits 16-31 */
+# define TT_tkmaskh_SHIFT 16
+
+# define TW_tw_MASK 0xffffffc0 /* bits 0-5 */
+# define TW_tw_SHIFT 0
+# define TW_rfw_MASK 0xffff81ff /* bits 9-14 */
+# define TW_rfw_SHIFT 9
+# define TW_twmask_MASK 0xe003ffff /* bits 18-28 */
+# define TW_twmask_SHIFT 18
+
+# define WAS_seqdst0_MASK 0xffffffc0 /* bits 0-5 */
+# define WAS_seqdst0_SHIFT 0
+# define WAS_seqdst1_MASK 0xfffff03f /* bits 6-11 */
+# define WAS_seqdst1_SHIFT 6
+# define WAS_seqdst2_MASK 0xfffc0fff /* bits 12-17 */
+# define WAS_seqdst2_SHIFT 12
+# define WAS_seqdst3_MASK 0xff03ffff /* bits 18-23 */
+# define WAS_seqdst3_SHIFT 18
+# define WAS_seqlen_MASK 0xfcffffff /* bits 24-25 */
+# define WAS_wfirsttag_MASK 0xfbffffff /* bit 26 */
+# define WAS_wfirsttag_disable 0x0
+# define WAS_wfirsttag_enable 0x4000000
+# define WAS_wsametag_MASK 0xf7ffffff /* bit 27 */
+# define WAS_wsametag_disable 0x0
+# define WAS_wsametag_enable 0x8000000
+# define WAS_seqoff_MASK 0xefffffff /* bit 28 */
+# define WAS_seqoff_disable 0x0
+# define WAS_seqoff_enable 0x10000000
+
+# define WMA_wcodeaddr_MASK 0xff /* bits 8-31 */
+# define WMA_wcodeaddr_SHIFT 8
+
+# define WF_walustsflag_MASK 0xffffff00 /* bits 0-7 */
+# define WF_walustsflag_SHIFT 0
+# define WF_walucfgflag_MASK 0xffff00ff /* bits 8-15 */
+# define WF_walucfgflag_SHIFT 8
+# define WF_wprgflag_MASK 0xffff /* bits 16-31 */
+# define WF_wprgflag_SHIFT 16
+
+# define WF1_walustsflag1_MASK 0xffffff00 /* bits 0-7 */
+# define WF1_walustsflag1_SHIFT 0
+# define WF1_walucfgflag1_MASK 0xffff00ff /* bits 8-15 */
+# define WF1_walucfgflag1_SHIFT 8
+# define WF1_wprgflag1_MASK 0xffff /* bits 16-31 */
+# define WF1_wprgflag1_SHIFT 16
+
+# define WGV_wgetmsbmin_MASK 0xffffffe0 /* bits 0-4 */
+# define WGV_wgetmsbmin_SHIFT 0
+# define WGV_wgetmsbmax_MASK 0xffffe0ff /* bits 8-12 */
+# define WGV_wgetmsbmax_SHIFT 8
+# define WGV_wbrklefttop_MASK 0xfffeffff /* bit 16 */
+# define WGV_wbrklefttop_disable 0x0
+# define WGV_wbrklefttop_enable 0x10000
+# define WGV_wfastcrop_MASK 0xfffdffff /* bit 17 */
+# define WGV_wfastcrop_disable 0x0
+# define WGV_wfastcrop_enable 0x20000
+# define WGV_wcentersnap_MASK 0xfffbffff /* bit 18 */
+# define WGV_wcentersnap_disable 0x0
+# define WGV_wcentersnap_enable 0x40000
+# define WGV_wbrkrighttop_MASK 0xfff7ffff /* bit 19 */
+# define WGV_wbrkrighttop_disable 0x0
+# define WGV_wbrkrighttop_enable 0x80000
+
+# define WIA_wmode_MASK 0xfffffffc /* bits 0-1 */
+# define WIA_wmode_suspend 0x0 /* val 0, shift 0 */
+# define WIA_wmode_resume 0x1 /* val 1, shift 0 */
+# define WIA_wmode_jump 0x2 /* val 2, shift 0 */
+# define WIA_wmode_start 0x3 /* val 3, shift 0 */
+# define WIA_wagp_MASK 0xfffffffb /* bit 2 */
+# define WIA_wagp_pci 0x0
+# define WIA_wagp_agp 0x4
+# define WIA_wiaddr_MASK 0x7 /* bits 3-31 */
+# define WIA_wiaddr_SHIFT 3
+
+# define WIA2_wmode_MASK 0xfffffffc /* bits 0-1 */
+# define WIA2_wmode_suspend 0x0 /* val 0, shift 0 */
+# define WIA2_wmode_resume 0x1 /* val 1, shift 0 */
+# define WIA2_wmode_jump 0x2 /* val 2, shift 0 */
+# define WIA2_wmode_start 0x3 /* val 3, shift 0 */
+# define WIA2_wagp_MASK 0xfffffffb /* bit 2 */
+# define WIA2_wagp_pci 0x0
+# define WIA2_wagp_agp 0x4
+# define WIA2_wiaddr_MASK 0x7 /* bits 3-31 */
+# define WIA2_wiaddr_SHIFT 3
+
+# define WIMA_wimemaddr_MASK 0xffffff00 /* bits 0-7 */
+# define WIMA_wimemaddr_SHIFT 0
+
+# define WM_wucodecache_MASK 0xfffffffe /* bit 0 */
+# define WM_wucodecache_disable 0x0
+# define WM_wucodecache_enable 0x1
+# define WM_wmaster_MASK 0xfffffffd /* bit 1 */
+# define WM_wmaster_disable 0x0
+# define WM_wmaster_enable 0x2
+# define WM_wcacheflush_MASK 0xfffffff7 /* bit 3 */
+# define WM_wcacheflush_disable 0x0
+# define WM_wcacheflush_enable 0x8
+
+# define WVS_wvrtxsz_MASK 0xffffffc0 /* bits 0-5 */
+# define WVS_wvrtxsz_SHIFT 0
+# define WVS_primsz_MASK 0xffffc0ff /* bits 8-13 */
+# define WVS_primsz_SHIFT 8
+
+# define XYEA_x_end_MASK 0xffff0000 /* bits 0-15 */
+# define XYEA_x_end_SHIFT 0
+# define XYEA_y_end_MASK 0xffff /* bits 16-31 */
+# define XYEA_y_end_SHIFT 16
+
+# define XYSA_x_start_MASK 0xffff0000 /* bits 0-15 */
+# define XYSA_x_start_SHIFT 0
+# define XYSA_y_start_MASK 0xffff /* bits 16-31 */
+# define XYSA_y_start_SHIFT 16
+
+# define YA_ydst_MASK 0xff800000 /* bits 0-22 */
+# define YA_ydst_SHIFT 0
+# define YA_sellin_MASK 0x1fffffff /* bits 29-31 */
+# define YA_sellin_SHIFT 29
+
+# define YDL_length_MASK 0xffff0000 /* bits 0-15 */
+# define YDL_length_SHIFT 0
+# define YDL_yval_MASK 0xffff /* bits 16-31 */
+# define YDL_yval_SHIFT 16
+
+# define ZO_zorgmap_MASK 0xfffffffe /* bit 0 */
+# define ZO_zorgmap_fb 0x0
+# define ZO_zorgmap_sys 0x1
+# define ZO_zorgacc_MASK 0xfffffffd /* bit 1 */
+# define ZO_zorgacc_pci 0x0
+# define ZO_zorgacc_agp 0x2
+# define ZO_zorg_MASK 0x3 /* bits 2-31 */
+# define ZO_zorg_SHIFT 2
+
+
+
+
+/**************** (END) AUTOMATICLY GENERATED REGISTER FILE ******************/
+
+#endif /* _MGAREGS_H_ */
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 21:07:52 +0000