From 7ce3a2ba6d211aeaa19a6841935bc50205788d62 Mon Sep 17 00:00:00 2001 From: Alan Coopersmith Date: Tue, 14 Mar 2006 23:18:18 +0000 Subject: Initial code release from ASPEED Technology Inc. Bugzilla #4937 Attachment 3686 --- src/ast.h | 167 +++++++ src/ast_2dtool.c | 795 +++++++++++++++++++++++++++++++ src/ast_2dtool.h | 419 +++++++++++++++++ src/ast_accel.c | 1358 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/ast_cursor.c | 376 +++++++++++++++ src/ast_cursor.h | 30 ++ src/ast_driver.c | 1220 +++++++++++++++++++++++++++++++++++++++++++++++ src/ast_mode.c | 712 ++++++++++++++++++++++++++++ src/ast_mode.h | 115 +++++ src/ast_tool.c | 124 +++++ src/ast_vgatool.c | 240 ++++++++++ src/ast_vgatool.h | 70 +++ 12 files changed, 5626 insertions(+) create mode 100644 src/ast.h create mode 100644 src/ast_2dtool.c create mode 100644 src/ast_2dtool.h create mode 100644 src/ast_accel.c create mode 100644 src/ast_cursor.c create mode 100644 src/ast_cursor.h create mode 100644 src/ast_driver.c create mode 100644 src/ast_mode.c create mode 100644 src/ast_mode.h create mode 100644 src/ast_tool.c create mode 100644 src/ast_vgatool.c create mode 100644 src/ast_vgatool.h (limited to 'src') diff --git a/src/ast.h b/src/ast.h new file mode 100644 index 0000000..bbffa11 --- /dev/null +++ b/src/ast.h @@ -0,0 +1,167 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/* Compiler Options */ +#define Accel_2D +/* #define MMIO_2D */ +#define HWC + +/* Vendor & Device Info */ +#ifndef PCI_VENDOR_AST +#define PCI_VENDOR_AST 0x1A03 +#endif + +#ifndef PCI_CHIP_AST2000 +#define PCI_CHIP_AST2000 0x2000 +#endif + +/* AST REC Info */ +#define AST_NAME "AST" +#define AST_DRIVER_NAME "ast" +#define AST_MAJOR_VERSION 0 +#define AST_MINOR_VERSION 51 +#define AST_PATCH_VERSION 0 +#define AST_VERSION \ + ((AST_MAJOR_VERSION << 20) | (AST_MINOR_VERSION << 10) | AST_PATCH_VERSION) + +/* Customized Info */ +#define DEFAULT_VIDEOMEM_SIZE 0x00800000 +#define DEFAULT_MMIO_SIZE 0x00020000 +#define DEFAULT_CMDQ_SIZE 0x00100000 +#define CMD_QUEUE_GUARD_BAND 0x00000020 +#define DEFAULT_HWC_NUM 0x00000002 + +/* Data Type Definition */ +typedef INT32 LONG; +typedef CARD8 UCHAR; +typedef CARD16 USHORT; +typedef CARD32 ULONG; + +/* Data Structure Definition */ +typedef struct _ASTRegRec { + UCHAR ExtCRTC[0x50]; + +} ASTRegRec, *ASTRegPtr; + +typedef struct _VIDEOMODE { + + int ScreenWidth; + int ScreenHeight; + int bitsPerPixel; + int ScreenPitch; + +} VIDEOMODE, *PVIDEOMODE; + +typedef struct { + + ULONG ulCMDQSize; + ULONG ulCMDQType; + + ULONG ulCMDQOffsetAddr; + UCHAR *pjCMDQVirtualAddr; + + UCHAR *pjCmdQBasePort; + UCHAR *pjWritePort; + UCHAR *pjReadPort; + UCHAR *pjEngStatePort; + + ULONG ulCMDQMask; + ULONG ulCurCMDQueueLen; + + ULONG ulWritePointer; + ULONG ulReadPointer; + + ULONG ulReadPointer_OK; /* for Eng_DBGChk */ + +} CMDQINFO, *PCMDQINFO; + +typedef struct { + + int HWC_NUM; + int HWC_NUM_Next; + + ULONG ulHWCOffsetAddr; + UCHAR *pjHWCVirtualAddr; + + USHORT cursortype; + USHORT width; + USHORT height; + USHORT offset_x; + USHORT offset_y; + ULONG fg; + ULONG bg; + + +} HWCINFO, *PHWCINFO; + +typedef struct _ASTRec { + + EntityInfoPtr pEnt; + pciVideoPtr PciInfo; + PCITAG PciTag; + + OptionInfoPtr Options; + DisplayModePtr ModePtr; + FBLinearPtr pCMDQPtr; + XAAInfoRecPtr AccelInfoPtr; + xf86CursorInfoPtr HWCInfoPtr; + FBLinearPtr pHWCPtr; + + CloseScreenProcPtr CloseScreen; + ScreenBlockHandlerProcPtr BlockHandler; + + Bool noAccel; + Bool noHWC; + Bool MMIO2D; + int ENGCaps; + int DBGSelect; + + ULONG FBPhysAddr; /* Frame buffer physical address */ + ULONG MMIOPhysAddr; /* MMIO region physical address */ + ULONG BIOSPhysAddr; /* BIOS physical address */ + + UCHAR *FBVirtualAddr; /* Map of frame buffer */ + UCHAR *MMIOVirtualAddr; /* Map of MMIO region */ + + unsigned long FbMapSize; + unsigned long MMIOMapSize; + + IOADDRESS IODBase; /* Base of PIO memory area */ + IOADDRESS PIOOffset; + IOADDRESS RelocateIO; + + VIDEOMODE VideoModeInfo; + ASTRegRec SavedReg; + CMDQINFO CMDQInfo; + HWCINFO HWCInfo; + ULONG ulCMDReg; + Bool EnableClip; + +} ASTRec, *ASTRecPtr; + +#define ASTPTR(p) ((ASTRecPtr)((p)->driverPrivate)) + +/* Include Files */ +#include "ast_mode.h" +#include "ast_vgatool.h" +#include "ast_2dtool.h" +#include "ast_cursor.h" diff --git a/src/ast_2dtool.c b/src/ast_2dtool.c new file mode 100644 index 0000000..b539ea5 --- /dev/null +++ b/src/ast_2dtool.c @@ -0,0 +1,795 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xf86.h" +#include "xf86_ansic.h" +#include "xf86_OSproc.h" +#include "xf86Resources.h" +#include "xf86RAC.h" +#include "xf86cmap.h" +#include "compiler.h" +#include "mibstore.h" +#include "vgaHW.h" +#include "mipointer.h" +#include "micmap.h" + +#include "fb.h" +#include "regionstr.h" +#include "xf86xv.h" +#include "Xv.h" +#include "vbe.h" + +#include "xf86PciInfo.h" +#include "xf86Pci.h" + +/* framebuffer offscreen manager */ +#include "xf86fbman.h" + +/* include xaa includes */ +#include "xaa.h" +#include "xaarop.h" + +/* H/W cursor support */ +#include "xf86Cursor.h" + +/* Driver specific headers */ +#include "ast.h" + +#ifdef Accel_2D + +/* Prototype type declaration */ +Bool bInitCMDQInfo(ScrnInfoPtr pScrn, ASTRecPtr pAST); +Bool bEnableCMDQ(ScrnInfoPtr pScrn, ASTRecPtr pAST); +Bool bEnable2D(ScrnInfoPtr pScrn, ASTRecPtr pAST); +void vDisable2D(ScrnInfoPtr pScrn, ASTRecPtr pAST); +void vWaitEngIdle(ScrnInfoPtr pScrn, ASTRecPtr pAST); +UCHAR *pjRequestCMDQ(ASTRecPtr pAST, ULONG ulDataLen); +Bool bGetLineTerm(_LINEInfo *LineInfo, LINEPARAM *dsLineParam); +LONG lGetDiaRg(LONG GFracX, LONG GFracY); + +Bool +bInitCMDQInfo(ScrnInfoPtr pScrn, ASTRecPtr pAST) +{ + + pAST->CMDQInfo.pjCmdQBasePort = pAST->MMIOVirtualAddr+ 0x8044; + pAST->CMDQInfo.pjWritePort = pAST->MMIOVirtualAddr+ 0x8048; + pAST->CMDQInfo.pjReadPort = pAST->MMIOVirtualAddr+ 0x804C; + pAST->CMDQInfo.pjEngStatePort = pAST->MMIOVirtualAddr+ 0x804C; + + /* CMDQ mode Init */ + if (!pAST->MMIO2D) { + pAST->CMDQInfo.ulCMDQType = VM_CMD_QUEUE; + + ScreenPtr pScreen; + + pScreen = screenInfo.screens[pScrn->scrnIndex]; + + pAST->pCMDQPtr = xf86AllocateOffscreenLinear (pScreen, 1024*1024, 8, NULL, NULL, NULL); + + if (!pAST->pCMDQPtr) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR,"Allocate CMDQ failed \n"); + pAST->MMIO2D = TRUE; /* set to MMIO mode if CMDQ allocate failed */ + } + + pAST->CMDQInfo.ulCMDQOffsetAddr = pAST->pCMDQPtr->offset*((pScrn->bitsPerPixel + 1) / 8); + pAST->CMDQInfo.pjCMDQVirtualAddr = pAST->FBVirtualAddr + pAST->CMDQInfo.ulCMDQOffsetAddr; + + pAST->CMDQInfo.ulCurCMDQueueLen = pAST->CMDQInfo.ulCMDQSize - CMD_QUEUE_GUARD_BAND; + pAST->CMDQInfo.ulCMDQMask = pAST->CMDQInfo.ulCMDQSize - 1 ; + } + + /* MMIO mode init */ + if (pAST->MMIO2D) { + pAST->CMDQInfo.ulCMDQType = VM_CMD_MMIO; + } + + return (TRUE); +} + +Bool +bEnableCMDQ(ScrnInfoPtr pScrn, ASTRecPtr pAST) +{ + ULONG ulVMCmdQBasePort = 0; + + vWaitEngIdle(pScrn, pAST); + + /* set DBG Select Info */ + if (pAST->DBGSelect) + { + *(ULONG *) (pAST->MMIOVirtualAddr + 0x804C) = (ULONG) (pAST->DBGSelect); + } + + /* set CMDQ base */ + switch (pAST->CMDQInfo.ulCMDQType) + { + case VM_CMD_QUEUE: + ulVMCmdQBasePort = (pAST->CMDQInfo.ulCMDQOffsetAddr - 0) >> 3; + + /* set CMDQ Threshold */ + ulVMCmdQBasePort |= 0xF0000000; + + /* set CMDQ Size */ + switch (pAST->CMDQInfo.ulCMDQSize) + { + case CMD_QUEUE_SIZE_256K: + ulVMCmdQBasePort |= 0x00000000; + break; + + case CMD_QUEUE_SIZE_512K: + ulVMCmdQBasePort |= 0x04000000; + break; + + case CMD_QUEUE_SIZE_1M: + ulVMCmdQBasePort |= 0x08000000; + break; + + case CMD_QUEUE_SIZE_2M: + ulVMCmdQBasePort |= 0x0C000000; + break; + + default: + return(FALSE); + break; + } + + *(ULONG *) (pAST->CMDQInfo.pjCmdQBasePort) = ulVMCmdQBasePort; + pAST->CMDQInfo.ulWritePointer = *(ULONG *) (pAST->CMDQInfo.pjWritePort); + break; + + case VM_CMD_MMIO: + /* set CMDQ Threshold */ + ulVMCmdQBasePort |= 0xF0000000; + + ulVMCmdQBasePort |= 0x02000000; /* MMIO mode */ + *(ULONG *) (pAST->CMDQInfo.pjCmdQBasePort) = ulVMCmdQBasePort; + break; + + default: + return (FALSE); + break; + } + + return (TRUE); +} + +Bool +bEnable2D(ScrnInfoPtr pScrn, ASTRecPtr pAST) +{ + SetIndexRegMask(CRTC_PORT, 0xA4, 0xFE, 0x01); /* enable 2D */ + + if (!bInitCMDQInfo(pScrn, pAST)) + { + vDisable2D(pScrn, pAST); + return (FALSE); + } + + if (!bEnableCMDQ(pScrn, pAST)) + { + vDisable2D(pScrn, pAST); + return (FALSE); + } + + return (TRUE); +} + +void +vDisable2D(ScrnInfoPtr pScrn, ASTRecPtr pAST) +{ + + vWaitEngIdle(pScrn, pAST); + vWaitEngIdle(pScrn, pAST); + + SetIndexRegMask(CRTC_PORT, 0xA4, 0xFE, 0x00); + +} + + +void +vWaitEngIdle(ScrnInfoPtr pScrn, ASTRecPtr pAST) +{ + ULONG ulEngState, ulEngState2; + UCHAR jReg; + ULONG ulEngCheckSetting; + + if (pAST->MMIO2D) + ulEngCheckSetting = 0x10000000; + else + ulEngCheckSetting = 0x80000000; + + /* 2D disable if 0xA4 D[0] = 1 */ + GetIndexRegMask(CRTC_PORT, 0xA4, 0x01, jReg); + if (!jReg) goto Exit_vWaitEngIdle; + + /* 2D not work if in std. mode */ + GetIndexRegMask(CRTC_PORT, 0xA3, 0x0F, jReg); + if (!jReg) goto Exit_vWaitEngIdle; + + do + { + ulEngState = (*(volatile ULONG *)(pAST->CMDQInfo.pjEngStatePort)) & 0xFFFC0000; + ulEngState2 = (*(volatile ULONG *)(pAST->CMDQInfo.pjEngStatePort)) & 0xFFFC0000; + ulEngState2 = (*(volatile ULONG *)(pAST->CMDQInfo.pjEngStatePort)) & 0xFFFC0000; + ulEngState2 = (*(volatile ULONG *)(pAST->CMDQInfo.pjEngStatePort)) & 0xFFFC0000; + ulEngState2 = (*(volatile ULONG *)(pAST->CMDQInfo.pjEngStatePort)) & 0xFFFC0000; + ulEngState2 = (*(volatile ULONG *)(pAST->CMDQInfo.pjEngStatePort)) & 0xFFFC0000; + + } while ((ulEngState & ulEngCheckSetting) || (ulEngState != ulEngState2)); + +Exit_vWaitEngIdle: + ; +} + +/* ULONG ulGetCMDQLength() */ +__inline ULONG ulGetCMDQLength(ASTRecPtr pAST, ULONG ulWritePointer, ULONG ulCMDQMask) +{ + ULONG ulReadPointer, ulReadPointer2; + + do { + ulReadPointer = *((volatile ULONG *)(pAST->CMDQInfo.pjReadPort)) & 0x0003FFFF; + ulReadPointer2 = *((volatile ULONG *)(pAST->CMDQInfo.pjReadPort)) & 0x0003FFFF; + ulReadPointer2 = *((volatile ULONG *)(pAST->CMDQInfo.pjReadPort)) & 0x0003FFFF; + ulReadPointer2 = *((volatile ULONG *)(pAST->CMDQInfo.pjReadPort)) & 0x0003FFFF; + ulReadPointer2 = *((volatile ULONG *)(pAST->CMDQInfo.pjReadPort)) & 0x0003FFFF; + ulReadPointer2 = *((volatile ULONG *)(pAST->CMDQInfo.pjReadPort)) & 0x0003FFFF; + } while (ulReadPointer != ulReadPointer2); + + return ((ulReadPointer << 3) - ulWritePointer - CMD_QUEUE_GUARD_BAND) & ulCMDQMask; +} + +UCHAR *pjRequestCMDQ( +ASTRecPtr pAST, ULONG ulDataLen) +{ + UCHAR *pjBuffer; + ULONG i, ulWritePointer, ulCMDQMask, ulCurCMDQLen, ulContinueCMDQLen; + + ulWritePointer = pAST->CMDQInfo.ulWritePointer; + ulContinueCMDQLen = pAST->CMDQInfo.ulCMDQSize - ulWritePointer; + ulCMDQMask = pAST->CMDQInfo.ulCMDQMask; + + if (ulContinueCMDQLen >= ulDataLen) + { + /* Get CMDQ Buffer */ + if (pAST->CMDQInfo.ulCurCMDQueueLen >= ulDataLen) + { + ; + } + else + { + + do + { + ulCurCMDQLen = ulGetCMDQLength(pAST, ulWritePointer, ulCMDQMask); + } while (ulCurCMDQLen < ulDataLen); + + pAST->CMDQInfo.ulCurCMDQueueLen = ulCurCMDQLen; + + } + + pjBuffer = pAST->CMDQInfo.pjCMDQVirtualAddr + ulWritePointer; + pAST->CMDQInfo.ulCurCMDQueueLen -= ulDataLen; + pAST->CMDQInfo.ulWritePointer = (ulWritePointer + ulDataLen) & ulCMDQMask; + return pjBuffer; + } + else + { + + /* Fill NULL CMD to the last of the CMDQ */ + if (pAST->CMDQInfo.ulCurCMDQueueLen >= ulContinueCMDQLen) + { + ; + } + else + { + + do + { + ulCurCMDQLen = ulGetCMDQLength(pAST, ulWritePointer, ulCMDQMask); + } while (ulCurCMDQLen < ulContinueCMDQLen); + + pAST->CMDQInfo.ulCurCMDQueueLen = ulCurCMDQLen; + + } + + pjBuffer = pAST->CMDQInfo.pjCMDQVirtualAddr + ulWritePointer; + for (i = 0; iCMDQInfo.ulCurCMDQueueLen -= ulContinueCMDQLen; + pAST->CMDQInfo.ulWritePointer = ulWritePointer = 0; + + /* Get CMDQ Buffer */ + if (pAST->CMDQInfo.ulCurCMDQueueLen >= ulDataLen) + { + ; + } + else + { + + do + { + ulCurCMDQLen = ulGetCMDQLength(pAST, ulWritePointer, ulCMDQMask); + } while (ulCurCMDQLen < ulDataLen); + + pAST->CMDQInfo.ulCurCMDQueueLen = ulCurCMDQLen; + + } + + pAST->CMDQInfo.ulCurCMDQueueLen -= ulDataLen; + pjBuffer = pAST->CMDQInfo.pjCMDQVirtualAddr + ulWritePointer; + pAST->CMDQInfo.ulWritePointer = (ulWritePointer + ulDataLen) & ulCMDQMask; + return pjBuffer; + + } + +} /* end of pjRequestCmdQ() */ + +Bool bGetLineTerm(_LINEInfo *LineInfo, LINEPARAM *dsLineParam) +{ + LONG GAbsX, GAbsY, GXInc, GYInc, GSlopeOne, GXMajor; + Bool tmpFlipH=0, tmpFlipV=0, tmpFlipD=0; + LONG tmpStartX, tmpStartY, tmpFStartX, tmpFStartY; + LONG GFAbsX, GFAbsY, GFStartX, GFStartY, GFFracX[2], GFFracY[2]; + LONG flag, GXRoundDown, GYRoundDown, GFlipH, GFlipV, GFlipD; + LONG tmpx, tmpy, GFGamma; + LONG i, region, tmpDiaRg[2], tmpGFX1, GFAdd, GNTWidth; + LONG tmp1GFX, tmp1GFY, tmp2GFX, tmp2GFY, tmpGK1Term, tmpGK2Term, tmpGNTErr; + LONG GFX, GFY, GK1Term, GK2Term, GNTErr; + + /*Init Calucate */ +#ifdef LONG64 + GAbsX = abs (LineInfo->X1 - LineInfo->X2); + GAbsY = abs (LineInfo->Y1 - LineInfo->Y2); +#else + GAbsX = labs (LineInfo->X1 - LineInfo->X2); + GAbsY = labs (LineInfo->Y1 - LineInfo->Y2); +#endif + + GXInc = (LineInfo->X1 < LineInfo->X2) ? 1:0; + GYInc = (LineInfo->Y1 < LineInfo->Y2) ? 1:0; + GSlopeOne = (GAbsX ==GAbsY) ? 1:0; + GXMajor = (GAbsX >= GAbsY) ? 1:0; + + /*Flip */ + tmpStartX = LineInfo->X1; + tmpStartY = LineInfo->Y1; + if (!GXInc) + { + tmpStartX = ~LineInfo->X1+ 1; + tmpFlipH = 1; + } + + if (!GYInc) + { + tmpStartY = ~LineInfo->Y1 + 1; + tmpFlipV = 1; + } + + if (GXMajor ==0) + { + tmpFlipD = 1; + tmpFStartX = tmpStartY; + tmpFStartY = tmpStartX; + GFAbsX = GAbsY; + GFAbsY = GAbsX; + } + else + { + tmpFlipD = 0; + tmpFStartX = tmpStartX; + tmpFStartY = tmpStartY; + GFAbsX = GAbsX; + GFAbsY = GAbsY; + } + + GFStartX = tmpFStartX >> 4; + GFStartY = tmpFStartY >> 4; + GFFracX[0] = tmpFStartX & 0xF; + GFFracY[0] = tmpFStartY & 0xF; + + /* Flag = GSlopeOne & tmpFlipH & tmpFlipV & tmpFlipD */ + flag = (GSlopeOne<<3) + (tmpFlipH<<2) + (tmpFlipV<<1) + tmpFlipD; + switch(flag) /* GSlopeOne tmpFlipH tmpFlipV tmpFlipD */ + { + case 0: /* 0 0 0 0 */ + case 1: /* 0 0 0 1 */ + GXRoundDown = 1; + GYRoundDown = 1; + GFlipH = tmpFlipH; + GFlipV = tmpFlipV; + GFlipD = tmpFlipD; + break; + case 2: /* 0 0 1 0 */ + case 5: /* 0 1 0 1 */ + case 10: /* 1 0 1 0 */ + case 14: /* 1 1 1 0 */ + GXRoundDown = 1; + GYRoundDown = 0; + GFlipH = tmpFlipH; + GFlipV = tmpFlipV; + GFlipD = tmpFlipD; + break; + case 3: /* 0 0 1 1 */ + case 4: /* 0 1 0 0 */ + case 8: /* 1 0 0 0 */ + case 12: /* 1 1 0 0 */ + GXRoundDown = 0; + GYRoundDown = 1; + GFlipH = tmpFlipH; + GFlipV = tmpFlipV; + GFlipD = tmpFlipD; + break; + case 6: /* 0 1 1 0 */ + case 7: /* 0 1 1 1 */ + GXRoundDown = 0; + GYRoundDown = 0; + GFlipH = tmpFlipH; + GFlipV = tmpFlipV; + GFlipD = tmpFlipD; + break; + /* case 9, 11, 13, 15 */ + default: + GXRoundDown = 1; /* 1 0 0 1 */ + GYRoundDown = 1; /* 1 0 1 1 */ + GFlipH = 1; /* 1 1 0 1 */ + GFlipV = 1; /* 1 1 1 1 */ + GFlipD = 1; + } + + /*Err */ + tmpx = (GFFracY[0] +8) * GFAbsX; + tmpy = GFFracX[0] * GFAbsY; + if(GYRoundDown==1) + GFGamma=(signed)(tmpx - tmpy - 1) >> 4; + else + GFGamma=(signed)(tmpx - tmpy) >> 4; + + /*GIQ */ + GFFracX[1] = (GFFracX[0] + GFAbsX) & 0xF; + GFFracY[1] = (GFFracY[0] + GFAbsY) & 0xF; + + for (i=0; i<2; i++) + { + tmpDiaRg[i] = 0; + region = lGetDiaRg(GFFracX[i], GFFracY[i]); + + if(region==1 && GXRoundDown==0) + tmpDiaRg[i] |= 1; + + if(region==2 && (GSlopeOne==0 || GXRoundDown==0)) + tmpDiaRg[i] |= 1; + + if(region==3) + tmpDiaRg[i] |= 1; + + } + + tmpGFX1 =((signed)(GFFracX[0]+GFAbsX)>>4)-1+tmpDiaRg[1]; /* signed left shifter!! */ + GFAdd = tmpDiaRg[0]; + GNTWidth = tmpGFX1 - tmpDiaRg[0] + 1; + + /* FXY */ + tmpGK1Term = GFAbsY; + tmpGK2Term = GFAbsY - GFAbsX; + + if(GFAdd==1){ + tmpGNTErr = GFGamma - GFAbsX + GFAbsY; + }else{ + tmpGNTErr = GFGamma - GFAbsX; + } + + tmp1GFX = GFStartX + GFAdd; + if((signed)tmpGNTErr >= 0){ + tmp1GFY = GFStartY+1; + GNTErr = tmpGNTErr + tmpGK2Term; + }else{ + tmp1GFY = GFStartY; + GNTErr = tmpGNTErr + tmpGK1Term; + } + + if(GFlipD == 1){ + tmp2GFX = tmp1GFY; + tmp2GFY = tmp1GFX; + }else{ + tmp2GFX = tmp1GFX; + tmp2GFY = tmp1GFY; + } + + if(GFlipV == 1){ + GFY = ~tmp2GFY+1; + }else{ + GFY = tmp2GFY; + } + + if(GFlipH == 1){ + GFX = ~tmp2GFX+1; + }else{ + GFX = tmp2GFX; + } + + GK1Term = tmpGK1Term; + GK2Term = tmpGK2Term; + + /*save the Param to dsLineParam */ + dsLineParam->dsLineX = (USHORT) GFX; + dsLineParam->dsLineY = (USHORT) GFY; + dsLineParam->dsLineWidth = (USHORT) GNTWidth; + dsLineParam->dwErrorTerm = (ULONG) GNTErr; + dsLineParam->dwK1Term = GK1Term; + dsLineParam->dwK2Term = GK2Term; + + dsLineParam->dwLineAttributes = 0; + if (GXMajor) dsLineParam->dwLineAttributes |= LINEPARAM_XM; + if (!GXInc) dsLineParam->dwLineAttributes |= LINEPARAM_X_DEC; + if (!GYInc) dsLineParam->dwLineAttributes |= LINEPARAM_Y_DEC; + + return(TRUE); + +} + +LONG lGetDiaRg(LONG GFracX, LONG GFracY) +{ + LONG region; + + switch(GFracY) + { + case 0x0: + switch(GFracX) + { + case 0x0: + case 0x1: + case 0x2: + case 0x3: + case 0x4: + case 0x5: + case 0x6: + case 0x7: + region=0; + break; + case 0x8: + region=1; + break; + default: + region=3; + } + break; + case 0x1: + switch(GFracX) + { + case 0x0: + case 0x1: + case 0x2: + case 0x3: + case 0x4: + case 0x5: + case 0x6: + region=0; + break; + default: + region=3; + } + break; + case 0x2: + switch(GFracX) + { + case 0x0: + case 0x1: + case 0x2: + case 0x3: + case 0x4: + case 0x5: + region=0; break; + default: + region=3; + } + break; + case 0x3: + switch(GFracX) + { + case 0x0: + case 0x1: + case 0x2: + case 0x3: + case 0x4: + region=0; + break; + default: + region=3; + } + break; + case 0x4: + switch(GFracX) + { + case 0x0: + case 0x1: + case 0x2: + case 0x3: + region=0; + break; + default: + region=3; + } + break; + case 0x5: + switch(GFracX) + { + case 0x0: + case 0x1: + case 0x2: + region=0; break; + default: + region=3; + } + break; + case 0x6: + switch(GFracX) + { + case 0x0: + case 0x1: + region=0; + break; + default: + region=3; + } + break; + case 0x7: + switch(GFracX) + { + case 0x0: + region=0; + break; + default: + region=3; + } + break; + case 0x8: + switch(GFracX) + { + case 0x0: + region=0; + break; + default: + region=3; + } + break; + case 0x9: + switch(GFracX) + { + case 0x0: + region=0; + break; + case 0x1: + region=2; + break; + default: + region=3; + } + break; + case 0xa: + switch(GFracX) + { + case 0x0: + case 0x1: + region=0; + break; + case 0x2: + region=2; + break; + default: + region=3; + } + break; + case 0xb: + switch(GFracX) + { + case 0x0: + case 0x1: + case 0x2: + region=0; + break; + case 0x3: + region=2; + break; + default: + region=3; + } + break; + case 0xc: + switch(GFracX) + { + case 0x0: + case 0x1: + case 0x2: + case 0x3: + region=0; + break; + case 0x4: + region=2; + break; + default: + region=3; + } + break; + case 0xd: + switch(GFracX) + { + case 0x0: + case 0x1: + case 0x2: + case 0x3: + case 0x4: + region=0; + break; + case 0x5: + region=2; + break; + default: + region=3; + } + break; + case 0xe: + switch(GFracX) + { + case 0x0: + case 0x1: + case 0x2: + case 0x3: + case 0x4: + case 0x5: + region=0; + break; + case 0x6: + region=2; + break; + default: + region=3; + } + break; + default: + switch(GFracX) + { + case 0x0: + case 0x1: + case 0x2: + case 0x3: + case 0x4: + case 0x5: + case 0x6: + region=0; + break; + case 0x7: + region=2; + break; + default: + region=3; + } + } + + return (region); + +} + +#endif /* end of Accel_2D */ + + diff --git a/src/ast_2dtool.h b/src/ast_2dtool.h new file mode 100644 index 0000000..2539705 --- /dev/null +++ b/src/ast_2dtool.h @@ -0,0 +1,419 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/* Eng Capability Definition */ +#define ENG_CAP_Sync 0x0001 +#define ENG_CAP_ScreenToScreenCopy 0x0002 +#define ENG_CAP_SolidFill 0x0004 +#define ENG_CAP_SolidLine 0x0008 +#define ENG_CAP_DashedLine 0x0010 +#define ENG_CAP_Mono8x8PatternFill 0x0020 +#define ENG_CAP_Color8x8PatternFill 0x0040 +#define ENG_CAP_CPUToScreenColorExpand 0x0080 +#define ENG_CAP_ScreenToScreenColorExpand 0x0100 +#define ENG_CAP_Clipping 0x0200 +#define ENG_CAP_ALL (ENG_CAP_Sync | ENG_CAP_ScreenToScreenCopy | ENG_CAP_SolidFill | \ + ENG_CAP_SolidLine | ENG_CAP_DashedLine | \ + ENG_CAP_Mono8x8PatternFill | ENG_CAP_Color8x8PatternFill | \ + ENG_CAP_Clipping); + +/* CMDQ Definition */ +#define AGP_CMD_QUEUE 1 +#define VM_CMD_QUEUE 0 +#define VM_CMD_MMIO 2 + +#define CMD_QUEUE_SIZE_256K 0x00040000 +#define CMD_QUEUE_SIZE_512K 0x00080000 +#define CMD_QUEUE_SIZE_1M 0x00100000 +#define CMD_QUEUE_SIZE_2M 0x00200000 +#define CMD_QUEUE_SIZE_4M 0x00400000 + +/* CMD Type Info */ +#define PKT_NULL_CMD 0x00009561 + +#define PKT_SINGLE_LENGTH 8 +#define PKT_SINGLE_CMD_HEADER 0x00009562 + +typedef struct _PKT_SC +{ + ULONG PKT_SC_dwHeader; + ULONG PKT_SC_dwData[1]; + +} PKT_SC, *PPKT_SC; + +/* Eng Reg. Limitation */ +#define MAX_SRC_PITCH 0x1FFF +#define MAX_DST_PITCH 0x1FFF +#define MAX_DST_HEIGHT 0x7FF +#define MAX_SRC_X 0x7FF +#define MAX_SRC_Y 0x7FF +#define MAX_DST_X 0x7FF +#define MAX_DST_Y 0x7FF +#define MAX_RECT_WIDTH 0x7FF +#define MAX_RECT_HEIGHT 0x7FF +#define MAX_CLIP 0xFFF + +#define MAX_LINE_X 0x7FF +#define MAX_LINE_Y 0x7FF +#define MAX_LINE_ERR 0x3FFFFF +#define MAX_LINE_WIDTH 0x7FF +#define MAX_LINE_K1 0x3FFFFF +#define MAX_LINE_K2 0x3FFFFF + +#define MAX_PATReg_Size 256 + +/* Eng Reg. Definition */ +/* MMIO Reg */ +#define MMIOREG_SRC_BASE (pAST->MMIOVirtualAddr + 0x8000) +#define MMIOREG_SRC_PITCH (pAST->MMIOVirtualAddr + 0x8004) +#define MMIOREG_DST_BASE (pAST->MMIOVirtualAddr + 0x8008) +#define MMIOREG_DST_PITCH (pAST->MMIOVirtualAddr + 0x800C) +#define MMIOREG_DST_XY (pAST->MMIOVirtualAddr + 0x8010) +#define MMIOREG_SRC_XY (pAST->MMIOVirtualAddr + 0x8014) +#define MMIOREG_RECT_XY (pAST->MMIOVirtualAddr + 0x8018) +#define MMIOREG_FG (pAST->MMIOVirtualAddr + 0x801C) +#define MMIOREG_BG (pAST->MMIOVirtualAddr + 0x8020) +#define MMIOREG_FG_SRC (pAST->MMIOVirtualAddr + 0x8024) +#define MMIOREG_BG_SRC (pAST->MMIOVirtualAddr + 0x8028) +#define MMIOREG_MONO1 (pAST->MMIOVirtualAddr + 0x802C) +#define MMIOREG_MONO2 (pAST->MMIOVirtualAddr + 0x8030) +#define MMIOREG_CLIP1 (pAST->MMIOVirtualAddr + 0x8034) +#define MMIOREG_CLIP2 (pAST->MMIOVirtualAddr + 0x8038) +#define MMIOREG_CMD (pAST->MMIOVirtualAddr + 0x803C) +#define MMIOREG_PAT (pAST->MMIOVirtualAddr + 0x8100) + +#define MMIOREG_LINE_XY (pAST->MMIOVirtualAddr + 0x8010) +#define MMIOREG_LINE_Err (pAST->MMIOVirtualAddr + 0x8014) +#define MMIOREG_LINE_WIDTH (pAST->MMIOVirtualAddr + 0x8018) +#define MMIOREG_LINE_K1 (pAST->MMIOVirtualAddr + 0x8024) +#define MMIOREG_LINE_K2 (pAST->MMIOVirtualAddr + 0x8028) +#define MMIOREG_LINE_STYLE1 (pAST->MMIOVirtualAddr + 0x802C) +#define MMIOREG_LINE_STYLE2 (pAST->MMIOVirtualAddr + 0x8030) + +/* CMDQ Reg */ +#define CMDQREG_SRC_BASE (0x00 << 24) +#define CMDQREG_SRC_PITCH (0x01 << 24) +#define CMDQREG_DST_BASE (0x02 << 24) +#define CMDQREG_DST_PITCH (0x03 << 24) +#define CMDQREG_DST_XY (0x04 << 24) +#define CMDQREG_SRC_XY (0x05 << 24) +#define CMDQREG_RECT_XY (0x06 << 24) +#define CMDQREG_FG (0x07 << 24) +#define CMDQREG_BG (0x08 << 24) +#define CMDQREG_FG_SRC (0x09 << 24) +#define CMDQREG_BG_SRC (0x0A << 24) +#define CMDQREG_MONO1 (0x0B << 24) +#define CMDQREG_MONO2 (0x0C << 24) +#define CMDQREG_CLIP1 (0x0D << 24) +#define CMDQREG_CLIP2 (0x0E << 24) +#define CMDQREG_CMD (0x0F << 24) +#define CMDQREG_PAT (0x40 << 24) + +#define CMDQREG_LINE_XY (0x04 << 24) +#define CMDQREG_LINE_Err (0x05 << 24) +#define CMDQREG_LINE_WIDTH (0x06 << 24) +#define CMDQREG_LINE_K1 (0x09 << 24) +#define CMDQREG_LINE_K2 (0x0A << 24) +#define CMDQREG_LINE_STYLE1 (0x0B << 24) +#define CMDQREG_LINE_STYLE2 (0x0C << 24) + +/* CMD Reg. Definition */ +#define CMD_BITBLT 0x00000000 +#define CMD_LINEDRAW 0x00000001 +#define CMD_COLOREXP 0x00000002 +#define CMD_ENHCOLOREXP 0x00000003 +#define CMD_MASK 0x00000007 + +#define CMD_DISABLE_CLIP 0x00000000 +#define CMD_ENABLE_CLIP 0x00000008 + +#define CMD_COLOR_08 0x00000000 +#define CMD_COLOR_16 0x00000010 +#define CMD_COLOR_32 0x00000020 + +#define CMD_SRC_SIQ 0x00000040 + +#define CMD_TRANSPARENT 0x00000080 + +#define CMD_PAT_FGCOLOR 0x00000000 +#define CMD_PAT_MONOMASK 0x00010000 +#define CMD_PAT_PATREG 0x00020000 + +#define CMD_OPAQUE 0x00000000 +#define CMD_FONT_TRANSPARENT 0x00040000 + +#define CMD_X_INC 0x00000000 +#define CMD_X_DEC 0x00200000 + +#define CMD_Y_INC 0x00000000 +#define CMD_Y_DEC 0x00100000 + +#define CMD_DRAW_LAST_PIXEL 0x00000000 +#define CMD_NOT_DRAW_LAST_PIXEL 0x00800000 + +#define CMD_DISABLE_LINE_STYLE 0x00000000 +#define CMD_ENABLE_LINE_STYLE 0x40000000 + +#define CMD_RESET_STYLE_COUNTER 0x80000000 +#define CMD_NOT_RESET_STYLE_COUNTER 0x00000000 + +#define BURST_FORCE_CMD 0x80000000 + +/* Line */ +#define LINEPARAM_XM 0x00000001 +#define LINEPARAM_X_DEC 0x00000002 +#define LINEPARAM_Y_DEC 0x00000004 + +typedef struct _LINEPARAM { + USHORT dsLineX; + USHORT dsLineY; + USHORT dsLineWidth; + ULONG dwErrorTerm; + ULONG dwK1Term; + ULONG dwK2Term; + ULONG dwLineAttributes; +} LINEPARAM, *PLINEPARAM; + +typedef struct { + + ULONG X1; + ULONG Y1; + ULONG X2; + ULONG Y2; + +} _LINEInfo; + +/* Macro */ +/* MMIO 2D Macro */ +#define ASTSetupSRCBase_MMIO(base) \ + { \ + *(ULONG *)(MMIOREG_SRC_BASE) = (ULONG) (base); \ + } +#define ASTSetupSRCPitch_MMIO(pitch) \ + { \ + *(ULONG *)(MMIOREG_SRC_PITCH) = (ULONG)(pitch << 16); \ + } +#define ASTSetupDSTBase_MMIO(base) \ + { \ + *(ULONG *)(MMIOREG_DST_BASE) = (ULONG)(base); \ + } +#define ASTSetupDSTPitchHeight_MMIO(pitch, height) \ + { \ + *(ULONG *)(MMIOREG_DST_PITCH) = (ULONG)((pitch << 16) + ((height) & MAX_DST_HEIGHT)); \ + } +#define ASTSetupDSTXY_MMIO(x, y) \ + { \ + *(ULONG *)(MMIOREG_DST_XY) = (ULONG)(((x & MAX_DST_X) << 16) + (y & MAX_DST_Y)); \ + } +#define ASTSetupSRCXY_MMIO(x, y) \ + { \ + *(ULONG *)(MMIOREG_SRC_XY) = (ULONG)(((x & MAX_SRC_X) << 16) + (y & MAX_SRC_Y)); \ + } +#define ASTSetupRECTXY_MMIO(x, y) \ + { \ + *(ULONG *)(MMIOREG_RECT_XY) = (ULONG)(((x & MAX_RECT_WIDTH) << 16) + (y & MAX_RECT_WIDTH)); \ + } +#define ASTSetupFG_MMIO(color) \ + { \ + *(ULONG *)(MMIOREG_FG) = (ULONG)(color); \ + } +#define ASTSetupBG_MMIO(color) \ + { \ + *(ULONG *)(MMIOREG_BG) = (ULONG)(color); \ + } +#define ASTSetupMONO1_MMIO(pat) \ + { \ + *(ULONG *)(MMIOREG_MONO1) = (ULONG)(pat); \ + } +#define ASTSetupMONO2_MMIO(pat) \ + { \ + *(ULONG *)(MMIOREG_MONO2) = (ULONG)(pat); \ + } +#define ASTSetupCLIP1_MMIO(left, top) \ + { \ + *(ULONG *)(MMIOREG_CLIP1) = (ULONG)(((left & MAX_CLIP) << 16) + (top & MAX_CLIP)); \ + } +#define ASTSetupCLIP2_MMIO(right, bottom) \ + { \ + *(ULONG *)(MMIOREG_CLIP2) = (ULONG)(((right & MAX_CLIP) << 16) + (bottom & MAX_CLIP)); \ + } +#define ASTSetupCMDReg_MMIO(reg) \ + { \ + *(ULONG *)(MMIOREG_CMD) = (ULONG)(reg); \ + } +#define ASTSetupPatReg_MMIO(patreg, pat) \ + { \ + *(ULONG *)(MMIOREG_PAT + patreg*4) = (ULONG)(pat); \ + } + +/* Line CMD */ +#define ASTSetupLineXY_MMIO(x, y) \ + { \ + *(ULONG *)(MMIOREG_LINE_XY) = (ULONG)(((x & MAX_LINE_X) << 16) + (y & MAX_LINE_Y)); \ + } +#define ASTSetupLineXMErrTerm_MMIO(xm, err) \ + { \ + *(ULONG *)(MMIOREG_LINE_Err) = (ULONG)((xm << 24) + (err & MAX_LINE_ERR)); \ + } +#define ASTSetupLineWidth_MMIO(width) \ + { \ + *(ULONG *)(MMIOREG_LINE_WIDTH) = (ULONG)((width & MAX_LINE_WIDTH) << 16); \ + } +#define ASTSetupLineK1Term_MMIO(err) \ + { \ + *(ULONG *)(MMIOREG_LINE_K1) = (ULONG)(err & MAX_LINE_K1); \ + } +#define ASTSetupLineK2Term_MMIO(err) \ + { \ + *(ULONG *)(MMIOREG_LINE_K2) = (ULONG)(err & MAX_LINE_K2); \ + } +#define ASTSetupLineStyle1_MMIO(pat) \ + { \ + *(ULONG *)(MMIOREG_LINE_STYLE1) = (ULONG)(pat); \ + } +#define ASTSetupLineStyle2_MMIO(pat) \ + { \ + *(ULONG *)(MMIOREG_LINE_STYLE2) = (ULONG)(pat); \ + } + +/* CMDQ Mode Macro */ +#define mUpdateWritePointer *(ULONG *) (pAST->CMDQInfo.pjWritePort) = (pAST->CMDQInfo.ulWritePointer >>3) + +/* General CMD */ +#define ASTSetupSRCBase(addr, base) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_SRC_BASE); \ + addr->PKT_SC_dwData[0] = (ULONG)(base); \ + } +#define ASTSetupSRCPitch(addr, pitch) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_SRC_PITCH); \ + addr->PKT_SC_dwData[0] = (ULONG)(pitch << 16); \ + } +#define ASTSetupDSTBase(addr, base) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_DST_BASE); \ + addr->PKT_SC_dwData[0] = (ULONG)(base); \ + } +#define ASTSetupDSTPitchHeight(addr, pitch, height) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_DST_PITCH); \ + addr->PKT_SC_dwData[0] = (ULONG)((pitch << 16) + ((height) & MAX_DST_HEIGHT)); \ + } +#define ASTSetupDSTXY(addr, x, y) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_DST_XY); \ + addr->PKT_SC_dwData[0] = (ULONG)(((x & MAX_DST_X) << 16) + (y & MAX_DST_Y)); \ + } +#define ASTSetupSRCXY(addr, x, y) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_SRC_XY); \ + addr->PKT_SC_dwData[0] = (ULONG)(((x & MAX_SRC_X) << 16) + (y & MAX_SRC_Y)); \ + } +#define ASTSetupRECTXY(addr, x, y) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_RECT_XY); \ + addr->PKT_SC_dwData[0] = (ULONG)(((x & MAX_RECT_WIDTH) << 16) + (y & MAX_RECT_WIDTH)); \ + } +#define ASTSetupFG(addr, color) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_FG); \ + addr->PKT_SC_dwData[0] = (ULONG)(color); \ + } +#define ASTSetupBG(addr, color) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_BG); \ + addr->PKT_SC_dwData[0] = (ULONG)(color); \ + } +#define ASTSetupMONO1(addr, pat) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_MONO1); \ + addr->PKT_SC_dwData[0] = (ULONG)(pat); \ + } +#define ASTSetupMONO2(addr, pat) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_MONO2); \ + addr->PKT_SC_dwData[0] = (ULONG)(pat); \ + } +#define ASTSetupCLIP1(addr, left, top) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_CLIP1); \ + addr->PKT_SC_dwData[0] = (ULONG)(((left & MAX_CLIP) << 16) + (top & MAX_CLIP)); \ + } +#define ASTSetupCLIP2(addr, right, bottom) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_CLIP2); \ + addr->PKT_SC_dwData[0] = (ULONG)(((right & MAX_CLIP) << 16) + (bottom & MAX_CLIP)); \ + } +#define ASTSetupCMDReg(addr, reg) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_CMD); \ + addr->PKT_SC_dwData[0] = (ULONG)(reg); \ + } +#define ASTSetupPatReg(addr, patreg, pat) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + (CMDQREG_PAT + (patreg << 24))); \ + addr->PKT_SC_dwData[0] = (ULONG)(pat); \ + } + +/* Line CMD */ +#define ASTSetupLineXY(addr, x, y) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_XY); \ + addr->PKT_SC_dwData[0] = (ULONG)(((x & MAX_LINE_X) << 16) + (y & MAX_LINE_Y)); \ + } +#define ASTSetupLineXMErrTerm(addr, xm, err) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_Err); \ + addr->PKT_SC_dwData[0] = (ULONG)((xm << 24) + (err & MAX_LINE_ERR)); \ + } +#define ASTSetupLineWidth(addr, width) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_WIDTH); \ + addr->PKT_SC_dwData[0] = (ULONG)((width & MAX_LINE_WIDTH) << 16); \ + } +#define ASTSetupLineK1Term(addr, err) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_K1); \ + addr->PKT_SC_dwData[0] = (ULONG)(err & MAX_LINE_K1); \ + } +#define ASTSetupLineK2Term(addr, err) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_K2); \ + addr->PKT_SC_dwData[0] = (ULONG)(err & MAX_LINE_K2); \ + } +#define ASTSetupLineStyle1(addr, pat) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_STYLE1); \ + addr->PKT_SC_dwData[0] = (ULONG)(pat); \ + } +#define ASTSetupLineStyle2(addr, pat) \ + { \ + addr->PKT_SC_dwHeader = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_STYLE2); \ + addr->PKT_SC_dwData[0] = (ULONG)(pat); \ + } + +#define ASTSetupNULLCMD(addr) \ + { \ + addr->PKT_SC_dwHeader = (ULONG) (PKT_NULL_CMD); \ + addr->PKT_SC_dwData[0] = (ULONG) 0; \ + } diff --git a/src/ast_accel.c b/src/ast_accel.c new file mode 100644 index 0000000..69da85f --- /dev/null +++ b/src/ast_accel.c @@ -0,0 +1,1358 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xf86.h" +#include "xf86_ansic.h" +#include "xf86_OSproc.h" +#include "xf86Resources.h" +#include "xf86RAC.h" +#include "xf86cmap.h" +#include "compiler.h" +#include "mibstore.h" +#include "vgaHW.h" +#include "mipointer.h" +#include "micmap.h" + +#include "fb.h" +#include "regionstr.h" +#include "xf86xv.h" +#include "Xv.h" +#include "vbe.h" + +#include "xf86PciInfo.h" +#include "xf86Pci.h" + +/* framebuffer offscreen manager */ +#include "xf86fbman.h" + +/* include xaa includes */ +#include "xaa.h" +#include "xaarop.h" + +/* H/W cursor support */ +#include "xf86Cursor.h" + +/* Driver specific headers */ +#include "ast.h" + +#ifdef Accel_2D + +/* extern function */ +extern void vWaitEngIdle(ScrnInfoPtr pScrn, ASTRecPtr pAST); +extern UCHAR *pjRequestCMDQ(ASTRecPtr pAST, ULONG ulDataLen); +extern Bool bGetLineTerm(_LINEInfo *LineInfo, LINEPARAM *dsLineParam); +extern LONG lGetDiaRg(LONG GFracX, LONG GFracY); + +/* Prototype type declaration */ +Bool ASTAccelInit(ScreenPtr pScreen); +static void ASTSync(ScrnInfoPtr pScrn); +static void ASTSetupForScreenToScreenCopy(ScrnInfoPtr pScrn, + int xdir, int ydir, int rop, + unsigned int planemask, int trans_color); +static void ASTSubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int x1, int y1, int x2, + int y2, int w, int h); +static void ASTSetupForSolidFill(ScrnInfoPtr pScrn, + int color, int rop, unsigned int planemask); +static void ASTSubsequentSolidFillRect(ScrnInfoPtr pScrn, + int dst_x, int dst_y, int width, int height); +static void ASTSetupForSolidLine(ScrnInfoPtr pScrn, + int color, int rop, unsigned int planemask); +static void ASTSubsequentSolidHorVertLine(ScrnInfoPtr pScrn, + int x, int y, int len, int dir); +static void ASTSubsequentSolidTwoPointLine(ScrnInfoPtr pScrn, + int x1, int y1, int x2, int y2, int flags); +static void ASTSetupForDashedLine(ScrnInfoPtr pScrn, + int fg, int bg, int rop, unsigned int planemask, + int length, UCHAR *pattern); +static void ASTSubsequentDashedTwoPointLine(ScrnInfoPtr pScrn, + int x1, int y1, int x2, int y2, + int flags, int phase); +static void ASTSetupForMonoPatternFill(ScrnInfoPtr pScrn, + int patx, int paty, int fg, int bg, + int rop, unsigned int planemask); +static void ASTSubsequentMonoPatternFill(ScrnInfoPtr pScrn, + int patx, int paty, + int x, int y, int w, int h); +static void ASTSetupForColor8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty, + int rop, unsigned int planemask, int trans_col); +static void ASTSubsequentColor8x8PatternFillRect(ScrnInfoPtr pScrn, int patx, int paty, + int x, int y, int w, int h); +static void ASTSetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, + int fg, int bg, + int rop, unsigned int planemask); +static void ASTSubsequentCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, + int x, int y, + int width, int height, int skipleft); +static void ASTSetupForScreenToScreenColorExpandFill(ScrnInfoPtr pScrn, + int fg, int bg, + int rop, unsigned int planemask); +static void ASTSubsequentScreenToScreenColorExpandFill(ScrnInfoPtr pScrn, + int x, int y, int width, int height, + int src_x, int src_y, int offset); +static void ASTSetClippingRectangle(ScrnInfoPtr pScrn, + int left, int top, int right, int bottom); +static void ASTDisableClipping(ScrnInfoPtr pScrn); + +Bool +ASTAccelInit(ScreenPtr pScreen) +{ + XAAInfoRecPtr infoPtr; + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + ASTRecPtr pAST = ASTPTR(pScrn); + + pAST->AccelInfoPtr = infoPtr = XAACreateInfoRec(); + if (!infoPtr) return FALSE; + + infoPtr->Flags = LINEAR_FRAMEBUFFER | + OFFSCREEN_PIXMAPS | + PIXMAP_CACHE; + + /* Sync */ + if (pAST->ENGCaps & ENG_CAP_Sync) + infoPtr->Sync = ASTSync; + + /* Screen To Screen copy */ + if (pAST->ENGCaps & ENG_CAP_ScreenToScreenCopy) + { + infoPtr->SetupForScreenToScreenCopy = ASTSetupForScreenToScreenCopy; + infoPtr->SubsequentScreenToScreenCopy = ASTSubsequentScreenToScreenCopy; + infoPtr->ScreenToScreenCopyFlags = NO_TRANSPARENCY | NO_PLANEMASK; + } + + /* Solid fill */ + if (pAST->ENGCaps & ENG_CAP_SolidFill) + { + infoPtr->SetupForSolidFill = ASTSetupForSolidFill; + infoPtr->SubsequentSolidFillRect = ASTSubsequentSolidFillRect; + infoPtr->SolidFillFlags = NO_PLANEMASK; + } + + /* Solid Lines */ + if (pAST->ENGCaps & ENG_CAP_SolidLine) + { + infoPtr->SetupForSolidLine = ASTSetupForSolidLine; + infoPtr->SubsequentSolidHorVertLine = ASTSubsequentSolidHorVertLine; + infoPtr->SubsequentSolidTwoPointLine = ASTSubsequentSolidTwoPointLine; + infoPtr->SolidLineFlags = NO_PLANEMASK; + } + + /* Dashed Lines */ + if (pAST->ENGCaps & ENG_CAP_DashedLine) + { + infoPtr->SetupForDashedLine = ASTSetupForDashedLine; + infoPtr->SubsequentDashedTwoPointLine = ASTSubsequentDashedTwoPointLine; + infoPtr->DashPatternMaxLength = 64; + infoPtr->DashedLineFlags = NO_PLANEMASK | + LINE_PATTERN_MSBFIRST_LSBJUSTIFIED; + } + + /* 8x8 mono pattern fill */ + if (pAST->ENGCaps & ENG_CAP_Mono8x8PatternFill) + { + infoPtr->SetupForMono8x8PatternFill = ASTSetupForMonoPatternFill; + infoPtr->SubsequentMono8x8PatternFillRect = ASTSubsequentMonoPatternFill; + infoPtr->Mono8x8PatternFillFlags = NO_PLANEMASK | + NO_TRANSPARENCY | + HARDWARE_PATTERN_SCREEN_ORIGIN | + HARDWARE_PATTERN_PROGRAMMED_BITS | + BIT_ORDER_IN_BYTE_MSBFIRST; + } + + /* 8x8 color pattern fill */ + if (pAST->ENGCaps & ENG_CAP_Color8x8PatternFill) + { + infoPtr->SetupForColor8x8PatternFill = ASTSetupForColor8x8PatternFill; + infoPtr->SubsequentColor8x8PatternFillRect = ASTSubsequentColor8x8PatternFillRect; + infoPtr->Color8x8PatternFillFlags = NO_PLANEMASK | + NO_TRANSPARENCY | + HARDWARE_PATTERN_SCREEN_ORIGIN; + } + + /* CPU To Screen Color Expand */ + if (pAST->ENGCaps & ENG_CAP_CPUToScreenColorExpand) + { + infoPtr->SetupForCPUToScreenColorExpandFill = ASTSetupForCPUToScreenColorExpandFill; + infoPtr->SubsequentCPUToScreenColorExpandFill = ASTSubsequentCPUToScreenColorExpandFill; + infoPtr->ColorExpandRange = MAX_PATReg_Size; + infoPtr->ColorExpandBase = MMIOREG_PAT; + infoPtr->CPUToScreenColorExpandFillFlags = NO_PLANEMASK | + BIT_ORDER_IN_BYTE_MSBFIRST; + } + + /* Screen To Screen Color Expand */ + if (pAST->ENGCaps & ENG_CAP_ScreenToScreenColorExpand) + { + infoPtr->SetupForScreenToScreenColorExpandFill = ASTSetupForScreenToScreenColorExpandFill; + infoPtr->SubsequentScreenToScreenColorExpandFill = ASTSubsequentScreenToScreenColorExpandFill; + infoPtr->ScreenToScreenColorExpandFillFlags = NO_PLANEMASK | + BIT_ORDER_IN_BYTE_MSBFIRST; + } + + /* Clipping */ + if (pAST->ENGCaps & ENG_CAP_Clipping) + { + infoPtr->SetClippingRectangle = ASTSetClippingRectangle; + infoPtr->DisableClipping = ASTDisableClipping; + infoPtr->ClippingFlags = HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY | + HARDWARE_CLIP_MONO_8x8_FILL | + HARDWARE_CLIP_COLOR_8x8_FILL | + HARDWARE_CLIP_SOLID_FILL | + HARDWARE_CLIP_SOLID_LINE | + HARDWARE_CLIP_DASHED_LINE | + HARDWARE_CLIP_SOLID_LINE; + } + + return(XAAInit(pScreen, infoPtr)); + +} /* end of ASTAccelInit */ + + +static void +ASTSync(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + + /* wait engle idle */ + vWaitEngIdle(pScrn, pAST); + +} /* end of ASTSync */ + + +static void ASTSetupForScreenToScreenCopy(ScrnInfoPtr pScrn, + int xdir, int ydir, int rop, + unsigned int planemask, int trans_color) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG cmdreg; + +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForScreenToScreenCopy\n"); +*/ + /* Modify Reg. Value */ + cmdreg = CMD_BITBLT; + switch (pAST->VideoModeInfo.bitsPerPixel) + { + case 8: + cmdreg |= CMD_COLOR_08; + break; + case 15: + case 16: + cmdreg |= CMD_COLOR_16; + break; + case 24: + case 32: + cmdreg |= CMD_COLOR_32; + break; + } + cmdreg |= (XAACopyROP[rop] << 8); + pAST->ulCMDReg = cmdreg; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*2); + + ASTSetupSRCPitch(pSingleCMD, pAST->VideoModeInfo.ScreenPitch); + pSingleCMD++; + ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1); + } + else + { + /* Write to MMIO */ + ASTSetupSRCPitch_MMIO(pAST->VideoModeInfo.ScreenPitch); + ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1); + } + +} /* end of ASTSetupForScreenToScreenCopy */ + +static void +ASTSubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int x1, int y1, int x2, + int y2, int width, int height) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + int src_x, src_y, dst_x, dst_y; + ULONG srcbase, dstbase, cmdreg; +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentScreenToScreenCopy\n"); +*/ + + /* Modify Reg. Value */ + cmdreg = pAST->ulCMDReg; + if (pAST->EnableClip) + cmdreg |= CMD_ENABLE_CLIP; + srcbase = dstbase = 0; + + if (y1 >= MAX_SRC_Y) + { + srcbase=pAST->VideoModeInfo.ScreenPitch*y1; + y1=0; + } + + if (y2 >= pScrn->virtualY) + { + dstbase=pAST->VideoModeInfo.ScreenPitch*y2; + y2=0; + } + + if (x1 < x2) + { + src_x = x1 + width - 1; + dst_x = x2 + width - 1; + cmdreg |= CMD_X_DEC; + } + else + { + src_x = x1; + dst_x = x2; + } + + if (y1 < y2) + { + src_y = y1 + height - 1; + dst_y = y2 + height - 1; + cmdreg |= CMD_Y_DEC; + } + else + { + src_y = y1; + dst_y = y2; + } + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*6); + + ASTSetupSRCBase(pSingleCMD, srcbase); + pSingleCMD++; + ASTSetupDSTBase(pSingleCMD, dstbase); + pSingleCMD++; + ASTSetupDSTXY(pSingleCMD, dst_x, dst_y); + pSingleCMD++; + ASTSetupSRCXY(pSingleCMD, src_x, src_y); + pSingleCMD++; + ASTSetupRECTXY(pSingleCMD, width, height); + pSingleCMD++; + ASTSetupCMDReg(pSingleCMD, cmdreg); + + /* Update Write Pointer */ + mUpdateWritePointer; + + } + else + { + ASTSetupSRCBase_MMIO(srcbase); + ASTSetupDSTBase_MMIO(dstbase); + ASTSetupDSTXY_MMIO(dst_x, dst_y); + ASTSetupSRCXY_MMIO(src_x, src_y); + ASTSetupRECTXY_MMIO(width, height); + ASTSetupCMDReg_MMIO(cmdreg); + + vWaitEngIdle(pScrn, pAST); + } + +} /* end of ASTSubsequentScreenToScreenCopy */ + +static void +ASTSetupForSolidFill(ScrnInfoPtr pScrn, + int color, int rop, unsigned int planemask) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG cmdreg; + +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForSolidFill\n"); +*/ + /* Modify Reg. Value */ + cmdreg = CMD_BITBLT | CMD_PAT_FGCOLOR; + switch (pAST->VideoModeInfo.bitsPerPixel) + { + case 8: + cmdreg |= CMD_COLOR_08; + break; + case 15: + case 16: + cmdreg |= CMD_COLOR_16; + break; + case 24: + case 32: + cmdreg |= CMD_COLOR_32; + break; + } + cmdreg |= (XAAPatternROP[rop] << 8); + pAST->ulCMDReg = cmdreg; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*2); + + ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1); + pSingleCMD++; + ASTSetupFG(pSingleCMD, color); + } + else + { + ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1); + ASTSetupFG_MMIO(color); + } + +} /* end of ASTSetupForSolidFill */ + + +static void +ASTSubsequentSolidFillRect(ScrnInfoPtr pScrn, + int dst_x, int dst_y, int width, int height) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG dstbase, cmdreg; +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentSolidFillRect\n"); +*/ + + /* Modify Reg. Value */ + cmdreg = pAST->ulCMDReg; + if (pAST->EnableClip) + cmdreg |= CMD_ENABLE_CLIP; + dstbase = 0; + + if (dst_y >= pScrn->virtualY) + { + dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y; + dst_y=0; + } + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*4); + + ASTSetupDSTBase(pSingleCMD, dstbase); + pSingleCMD++; + ASTSetupDSTXY(pSingleCMD, dst_x, dst_y); + pSingleCMD++; + ASTSetupRECTXY(pSingleCMD, width, height); + pSingleCMD++; + ASTSetupCMDReg(pSingleCMD, cmdreg); + + /* Update Write Pointer */ + mUpdateWritePointer; + + } + else + { + ASTSetupDSTBase_MMIO(dstbase); + ASTSetupDSTXY_MMIO(dst_x, dst_y); + ASTSetupRECTXY_MMIO(width, height); + ASTSetupCMDReg_MMIO(cmdreg); + + vWaitEngIdle(pScrn, pAST); + + } + + +} /* end of ASTSubsequentSolidFillRect */ + +/* Line */ +static void ASTSetupForSolidLine(ScrnInfoPtr pScrn, + int color, int rop, unsigned int planemask) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG cmdreg; +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForSolidLine\n"); +*/ + /* Modify Reg. Value */ + cmdreg = CMD_BITBLT; + switch (pAST->VideoModeInfo.bitsPerPixel) + { + case 8: + cmdreg |= CMD_COLOR_08; + break; + case 15: + case 16: + cmdreg |= CMD_COLOR_16; + break; + case 24: + case 32: + cmdreg |= CMD_COLOR_32; + break; + } + cmdreg |= (XAAPatternROP[rop] << 8); + pAST->ulCMDReg = cmdreg; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*3); + + ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1); + pSingleCMD++; + ASTSetupFG(pSingleCMD, color); + pSingleCMD++; + ASTSetupBG(pSingleCMD, 0); + + } + else + { + /* Write to MMIO */ + ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1); + ASTSetupFG_MMIO(color); + ASTSetupBG_MMIO(0); + } + +} /* end of ASTSetupForSolidLine */ + + +static void ASTSubsequentSolidHorVertLine(ScrnInfoPtr pScrn, + int x, int y, int len, int dir) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG dstbase, cmdreg; + int width, height; +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentSolidHorVertLine\n"); +*/ + + /* Modify Reg. Value */ + cmdreg = (pAST->ulCMDReg & (~CMD_MASK)) | CMD_BITBLT; + if (pAST->EnableClip) + cmdreg |= CMD_ENABLE_CLIP; + dstbase = 0; + + if(dir == DEGREES_0) { /* horizontal */ + width = len; + height = 1; + } else { /* vertical */ + width = 1; + height = len; + } + + if ((y + height) >= pScrn->virtualY) + { + dstbase=pAST->VideoModeInfo.ScreenPitch*y; + y=0; + } + + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*4); + + ASTSetupDSTBase(pSingleCMD, dstbase); + pSingleCMD++; + ASTSetupDSTXY(pSingleCMD, x, y); + pSingleCMD++; + ASTSetupRECTXY(pSingleCMD, width, height); + pSingleCMD++; + ASTSetupCMDReg(pSingleCMD, cmdreg); + + /* Update Write Pointer */ + mUpdateWritePointer; + + } + else + { + ASTSetupDSTBase_MMIO(dstbase); + ASTSetupDSTXY_MMIO(x, y); + ASTSetupRECTXY_MMIO(width, height); + ASTSetupCMDReg_MMIO(cmdreg); + + vWaitEngIdle(pScrn, pAST); + + } + + +} /* end of ASTSubsequentSolidHorVertLine */ + +static void ASTSubsequentSolidTwoPointLine(ScrnInfoPtr pScrn, + int x1, int y1, int x2, int y2, int flags) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + LINEPARAM dsLineParam; + _LINEInfo LineInfo; + ULONG dstbase, ulCommand; + ULONG miny, maxy; + USHORT usXM; +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentSolidTwoPointLine\n"); +*/ + + /* Modify Reg. Value */ + ulCommand = (pAST->ulCMDReg & (~CMD_MASK)) | CMD_LINEDRAW; + if(flags & OMIT_LAST) + ulCommand |= CMD_NOT_DRAW_LAST_PIXEL; + else + ulCommand &= ~CMD_NOT_DRAW_LAST_PIXEL; + if (pAST->EnableClip) + ulCommand |= CMD_ENABLE_CLIP; + dstbase = 0; + miny = (y1 > y2) ? y2 : y1; + maxy = (y1 > y2) ? y1 : y2; + if(maxy >= pScrn->virtualY) { + dstbase = pAST->VideoModeInfo.ScreenPitch * miny; + y1 -= miny; + y2 -= miny; + } + + LineInfo.X1 = x1 << 4; + LineInfo.X2 = x2 << 4; + LineInfo.Y1 = y1 << 4; + LineInfo.Y2 = y2 << 4; + + bGetLineTerm(&LineInfo, &dsLineParam); /* Get Line Parameter */ + + if (dsLineParam.dwLineAttributes & LINEPARAM_X_DEC) + ulCommand |= CMD_X_DEC; + if (dsLineParam.dwLineAttributes & LINEPARAM_Y_DEC) + ulCommand |= CMD_Y_DEC; + + usXM = (dsLineParam.dwLineAttributes & LINEPARAM_XM) ? 1:0; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*7); + + ASTSetupDSTBase(pSingleCMD, dstbase); + pSingleCMD++; + ASTSetupLineXY(pSingleCMD, dsLineParam.dsLineX, dsLineParam.dsLineY); + pSingleCMD++; + ASTSetupLineXMErrTerm(pSingleCMD, usXM , dsLineParam.dwErrorTerm); + pSingleCMD++; + ASTSetupLineWidth(pSingleCMD, dsLineParam.dsLineWidth); + pSingleCMD++; + ASTSetupLineK1Term(pSingleCMD, dsLineParam.dwK1Term); + pSingleCMD++; + ASTSetupLineK2Term(pSingleCMD, dsLineParam.dwK2Term); + pSingleCMD++; + ASTSetupCMDReg(pSingleCMD, ulCommand); + + /* Update Write Pointer */ + mUpdateWritePointer; + + } + else + { + ASTSetupDSTBase_MMIO(dstbase); + ASTSetupLineXY_MMIO(dsLineParam.dsLineX, dsLineParam.dsLineY); + ASTSetupLineXMErrTerm_MMIO( usXM , dsLineParam.dwErrorTerm); + ASTSetupLineWidth_MMIO(dsLineParam.dsLineWidth); + ASTSetupLineK1Term_MMIO(dsLineParam.dwK1Term); + ASTSetupLineK2Term_MMIO(dsLineParam.dwK2Term); + ASTSetupCMDReg_MMIO(ulCommand); + + vWaitEngIdle(pScrn, pAST); + + } + + +} /* end of ASTSubsequentSolidTwoPointLine */ + +/* Dash Line */ +static void +ASTSetupForDashedLine(ScrnInfoPtr pScrn, + int fg, int bg, int rop, unsigned int planemask, + int length, UCHAR *pattern) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG cmdreg; +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForDashedLine\n"); +*/ + /* Modify Reg. Value */ + cmdreg = CMD_LINEDRAW | CMD_RESET_STYLE_COUNTER | CMD_ENABLE_LINE_STYLE; + + switch (pAST->VideoModeInfo.bitsPerPixel) + { + case 8: + cmdreg |= CMD_COLOR_08; + break; + case 15: + case 16: + cmdreg |= CMD_COLOR_16; + break; + case 24: + case 32: + cmdreg |= CMD_COLOR_32; + break; + } + cmdreg |= (XAAPatternROP[rop] << 8); + if(bg == -1) { + cmdreg |= CMD_TRANSPARENT; + bg = 0; + } + cmdreg |= (((length-1) & 0x3F) << 24); /* line period */ + pAST->ulCMDReg = cmdreg; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*5); + + ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1); + pSingleCMD++; + ASTSetupFG(pSingleCMD, fg); + pSingleCMD++; + ASTSetupBG(pSingleCMD, bg); + pSingleCMD++; + ASTSetupLineStyle1(pSingleCMD, *pattern); + pSingleCMD++; + ASTSetupLineStyle2(pSingleCMD, *(pattern+4)); + + } + else + { + /* Write to MMIO */ + ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1); + ASTSetupFG_MMIO(fg); + ASTSetupBG_MMIO(bg); + ASTSetupLineStyle1_MMIO(*pattern); + ASTSetupLineStyle2_MMIO(*(pattern+4)); + + } + +} + +static void +ASTSubsequentDashedTwoPointLine(ScrnInfoPtr pScrn, + int x1, int y1, int x2, int y2, + int flags, int phase) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + LINEPARAM dsLineParam; + _LINEInfo LineInfo; + ULONG dstbase, ulCommand; + ULONG miny, maxy; + USHORT usXM; +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentDashedTwoPointLine\n"); +*/ + + /* Modify Reg. Value */ + ulCommand = pAST->ulCMDReg; + if(flags & OMIT_LAST) + ulCommand |= CMD_NOT_DRAW_LAST_PIXEL; + else + ulCommand &= ~CMD_NOT_DRAW_LAST_PIXEL; + if (pAST->EnableClip) + ulCommand |= CMD_ENABLE_CLIP; + dstbase = 0; + miny = (y1 > y2) ? y2 : y1; + maxy = (y1 > y2) ? y1 : y2; + if(maxy >= pScrn->virtualY) { + dstbase = pAST->VideoModeInfo.ScreenPitch * miny; + y1 -= miny; + y2 -= miny; + } + + LineInfo.X1 = x1 << 4; + LineInfo.X2 = x2 << 4; + LineInfo.Y1 = y1 << 4; + LineInfo.Y2 = y2 << 4; + + bGetLineTerm(&LineInfo, &dsLineParam); /* Get Line Parameter */ + + if (dsLineParam.dwLineAttributes & LINEPARAM_X_DEC) + ulCommand |= CMD_X_DEC; + if (dsLineParam.dwLineAttributes & LINEPARAM_Y_DEC) + ulCommand |= CMD_Y_DEC; + + usXM = (dsLineParam.dwLineAttributes & LINEPARAM_XM) ? 1:0; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*7); + + ASTSetupDSTBase(pSingleCMD, dstbase); + pSingleCMD++; + ASTSetupLineXY(pSingleCMD, dsLineParam.dsLineX, dsLineParam.dsLineY); + pSingleCMD++; + ASTSetupLineXMErrTerm(pSingleCMD, usXM , dsLineParam.dwErrorTerm); + pSingleCMD++; + ASTSetupLineWidth(pSingleCMD, dsLineParam.dsLineWidth); + pSingleCMD++; + ASTSetupLineK1Term(pSingleCMD, dsLineParam.dwK1Term); + pSingleCMD++; + ASTSetupLineK2Term(pSingleCMD, dsLineParam.dwK2Term); + pSingleCMD++; + ASTSetupCMDReg(pSingleCMD, ulCommand); + + /* Update Write Pointer */ + mUpdateWritePointer; + + } + else + { + ASTSetupDSTBase_MMIO(dstbase); + ASTSetupLineXY_MMIO(dsLineParam.dsLineX, dsLineParam.dsLineY); + ASTSetupLineXMErrTerm_MMIO( usXM , dsLineParam.dwErrorTerm); + ASTSetupLineWidth_MMIO(dsLineParam.dsLineWidth); + ASTSetupLineK1Term_MMIO(dsLineParam.dwK1Term); + ASTSetupLineK2Term_MMIO(dsLineParam.dwK2Term); + ASTSetupCMDReg_MMIO(ulCommand); + + vWaitEngIdle(pScrn, pAST); + + } + +} + +/* Mono Pattern Fill */ +static void +ASTSetupForMonoPatternFill(ScrnInfoPtr pScrn, + int patx, int paty, int fg, int bg, + int rop, unsigned int planemask) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG cmdreg; + +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForMonoPatternFill\n"); +*/ + /* Modify Reg. Value */ + cmdreg = CMD_BITBLT | CMD_PAT_MONOMASK; + switch (pAST->VideoModeInfo.bitsPerPixel) + { + case 8: + cmdreg |= CMD_COLOR_08; + break; + case 15: + case 16: + cmdreg |= CMD_COLOR_16; + break; + case 24: + case 32: + cmdreg |= CMD_COLOR_32; + break; + } + cmdreg |= (XAAPatternROP[rop] << 8); + pAST->ulCMDReg = cmdreg; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*5); + + ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1); + pSingleCMD++; + ASTSetupFG(pSingleCMD, fg); + pSingleCMD++; + ASTSetupBG(pSingleCMD, bg); + pSingleCMD++; + ASTSetupMONO1(pSingleCMD, patx); + pSingleCMD++; + ASTSetupMONO2(pSingleCMD, paty); + } + else + { + ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1); + ASTSetupFG_MMIO(fg); + ASTSetupBG_MMIO(bg); + ASTSetupMONO1_MMIO(patx); + ASTSetupMONO2_MMIO(paty); + } + +} /* end of ASTSetupForMonoPatternFill */ + + +static void +ASTSubsequentMonoPatternFill(ScrnInfoPtr pScrn, + int patx, int paty, + int dst_x, int dst_y, int width, int height) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG dstbase, cmdreg; +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentMonoPatternFill\n"); +*/ + + /* Modify Reg. Value */ + cmdreg = pAST->ulCMDReg; + if (pAST->EnableClip) + cmdreg |= CMD_ENABLE_CLIP; + dstbase = 0; + + if (dst_y >= pScrn->virtualY) + { + dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y; + dst_y=0; + } + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*4); + + ASTSetupDSTBase(pSingleCMD, dstbase); + pSingleCMD++; + ASTSetupDSTXY(pSingleCMD, dst_x, dst_y); + pSingleCMD++; + ASTSetupRECTXY(pSingleCMD, width, height); + pSingleCMD++; + ASTSetupCMDReg(pSingleCMD, cmdreg); + + /* Update Write Pointer */ + mUpdateWritePointer; + + } + else + { + ASTSetupDSTBase_MMIO(dstbase); + ASTSetupDSTXY_MMIO(dst_x, dst_y); + ASTSetupRECTXY_MMIO(width, height); + ASTSetupCMDReg_MMIO(cmdreg); + + vWaitEngIdle(pScrn, pAST); + } + +} /* end of ASTSubsequentMonoPatternFill */ + +static void +ASTSetupForColor8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty, + int rop, unsigned int planemask, int trans_col) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG cmdreg; + CARD32 *pataddr; + ULONG ulPatSize; + int i, j, cpp; +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForColor8x8PatternFill\n"); +*/ + /* Modify Reg. Value */ + cmdreg = CMD_BITBLT | CMD_PAT_PATREG; + switch (pAST->VideoModeInfo.bitsPerPixel) + { + case 8: + cmdreg |= CMD_COLOR_08; + break; + case 15: + case 16: + cmdreg |= CMD_COLOR_16; + break; + case 24: + case 32: + cmdreg |= CMD_COLOR_32; + break; + } + cmdreg |= (XAAPatternROP[rop] << 8); + pAST->ulCMDReg = cmdreg; + cpp = (pScrn->bitsPerPixel + 1) / 8; + pataddr = (CARD32 *)(pAST->FBVirtualAddr + + (paty * pAST->VideoModeInfo.ScreenWidth) + (patx * cpp)); + ulPatSize = 8*8*cpp; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*(1 + ulPatSize/4)); + ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1); + pSingleCMD++; + for (i=0; i<8; i++) + { + for (j=0; j<8*cpp/4; j++) + { + ASTSetupPatReg(pSingleCMD, (i*j + j) , (*(CARD32 *) (pataddr++))); + pSingleCMD++; + } + } + } + else + { + ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1); + for (i=0; i<8; i++) + { + for (j=0; j<8*cpp/4; j++) + { + ASTSetupPatReg_MMIO((i*j + j) , (*(CARD32 *) (pataddr++))); + } + } + + } + +} /* end of ASTSetupForColor8x8PatternFill */ + +static void +ASTSubsequentColor8x8PatternFillRect(ScrnInfoPtr pScrn, int patx, int paty, + int dst_x, int dst_y, int width, int height) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG dstbase, cmdreg; +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentColor8x8PatternFillRect\n"); +*/ + + /* Modify Reg. Value */ + cmdreg = pAST->ulCMDReg; + if (pAST->EnableClip) + cmdreg |= CMD_ENABLE_CLIP; + dstbase = 0; + + if (dst_y >= pScrn->virtualY) + { + dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y; + dst_y=0; + } + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*4); + + ASTSetupDSTBase(pSingleCMD, dstbase); + pSingleCMD++; + ASTSetupDSTXY(pSingleCMD, dst_x, dst_y); + pSingleCMD++; + ASTSetupRECTXY(pSingleCMD, width, height); + pSingleCMD++; + ASTSetupCMDReg(pSingleCMD, cmdreg); + + /* Update Write Pointer */ + mUpdateWritePointer; + + } + else + { + ASTSetupDSTBase_MMIO(dstbase); + ASTSetupDSTXY_MMIO(dst_x, dst_y); + ASTSetupRECTXY_MMIO(width, height); + ASTSetupCMDReg_MMIO(cmdreg); + + vWaitEngIdle(pScrn, pAST); + } + +} /* ASTSubsequentColor8x8PatternFillRect */ + +/* CPU to Screen Expand */ +static void +ASTSetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, + int fg, int bg, + int rop, unsigned int planemask) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG cmdreg; + +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForCPUToScreenColorExpandFill\n"); +*/ + /* Modify Reg. Value */ + cmdreg = CMD_COLOREXP; + switch (pAST->VideoModeInfo.bitsPerPixel) + { + case 8: + cmdreg |= CMD_COLOR_08; + break; + case 15: + case 16: + cmdreg |= CMD_COLOR_16; + break; + case 24: + case 32: + cmdreg |= CMD_COLOR_32; + break; + } + cmdreg |= (XAAPatternROP[rop] << 8); + if(bg == -1) { + cmdreg |= CMD_FONT_TRANSPARENT; + bg = 0; + } + pAST->ulCMDReg = cmdreg; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*3); + + ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1); + pSingleCMD++; + ASTSetupFG(pSingleCMD, fg); + pSingleCMD++; + ASTSetupBG(pSingleCMD, bg); + + } + else + { + ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1); + ASTSetupFG_MMIO(fg); + ASTSetupBG_MMIO(bg); + + } + +} + +static void +ASTSubsequentCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, + int dst_x, int dst_y, + int width, int height, int offset) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG dstbase, cmdreg; + +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentCPUToScreenColorExpandFill\n"); +*/ + + /* Modify Reg. Value */ + cmdreg = pAST->ulCMDReg; + if (pAST->EnableClip) + cmdreg |= CMD_ENABLE_CLIP; + dstbase = 0; + + if (dst_y >= pScrn->virtualY) + { + dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y; + dst_y=0; + } + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*5); + + ASTSetupSRCPitch(pSingleCMD, ((width+7)/8)); + pSingleCMD++; + ASTSetupDSTBase(pSingleCMD, dstbase); + pSingleCMD++; + ASTSetupDSTXY(pSingleCMD, dst_x, dst_y); + pSingleCMD++; + ASTSetupRECTXY(pSingleCMD, width, height); + pSingleCMD++; + ASTSetupCMDReg(pSingleCMD, cmdreg); + + /* Update Write Pointer */ + mUpdateWritePointer; + + } + else + { + ASTSetupSRCPitch_MMIO((width+7)/8); + ASTSetupDSTBase_MMIO(dstbase); + ASTSetupDSTXY_MMIO(dst_x, dst_y); + ASTSetupSRCXY_MMIO(0, 0); + + ASTSetupRECTXY_MMIO(width, height); + ASTSetupCMDReg_MMIO(cmdreg); + + vWaitEngIdle(pScrn, pAST); + + } + +} + + +/* Screen to Screen Color Expand */ +static void +ASTSetupForScreenToScreenColorExpandFill(ScrnInfoPtr pScrn, + int fg, int bg, + int rop, unsigned int planemask) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG cmdreg; + +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForScreenToScreenColorExpandFill\n"); +*/ + + /* Modify Reg. Value */ + cmdreg = CMD_ENHCOLOREXP; + switch (pAST->VideoModeInfo.bitsPerPixel) + { + case 8: + cmdreg |= CMD_COLOR_08; + break; + case 15: + case 16: + cmdreg |= CMD_COLOR_16; + break; + case 24: + case 32: + cmdreg |= CMD_COLOR_32; + break; + } + cmdreg |= (XAAPatternROP[rop] << 8); + if(bg == -1) { + cmdreg |= CMD_FONT_TRANSPARENT; + bg = 0; + } + pAST->ulCMDReg = cmdreg; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*3); + + ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1); + pSingleCMD++; + ASTSetupFG(pSingleCMD, fg); + pSingleCMD++; + ASTSetupBG(pSingleCMD, bg); + + } + else + { + ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1); + ASTSetupFG_MMIO(fg); + ASTSetupBG_MMIO(bg); + + } + +} + + + +static void +ASTSubsequentScreenToScreenColorExpandFill(ScrnInfoPtr pScrn, + int dst_x, int dst_y, int width, int height, + int src_x, int src_y, int offset) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; + ULONG srcbase, dstbase, cmdreg; + USHORT srcpitch; + +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentScreenToScreenColorExpandFill\n"); +*/ + + /* Modify Reg. Value */ + cmdreg = pAST->ulCMDReg; + if (pAST->EnableClip) + cmdreg |= CMD_ENABLE_CLIP; + dstbase = 0; + if (dst_y >= pScrn->virtualY) + { + dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y; + dst_y=0; + } + srcbase = pAST->VideoModeInfo.ScreenPitch*src_y + ((pScrn->bitsPerPixel+1)/8)*src_x; + srcpitch = (pScrn->displayWidth+7)/8; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*6); + + ASTSetupSRCBase(pSingleCMD, srcbase); + pSingleCMD++; + ASTSetupSRCPitch(pSingleCMD,srcpitch); + pSingleCMD++; + ASTSetupDSTBase(pSingleCMD, dstbase); + pSingleCMD++; + ASTSetupDSTXY(pSingleCMD, dst_x, dst_y); + pSingleCMD++; + ASTSetupRECTXY(pSingleCMD, width, height); + pSingleCMD++; + ASTSetupCMDReg(pSingleCMD, cmdreg); + + /* Update Write Pointer */ + mUpdateWritePointer; + + } + else + { + ASTSetupSRCBase_MMIO(srcbase); + ASTSetupSRCPitch_MMIO(srcpitch); + ASTSetupDSTBase_MMIO(dstbase); + ASTSetupDSTXY_MMIO(dst_x, dst_y); + ASTSetupRECTXY_MMIO(width, height); + ASTSetupCMDReg_MMIO(cmdreg); + + vWaitEngIdle(pScrn, pAST); + + } + +} + + +/* Clipping */ +static void +ASTSetClippingRectangle(ScrnInfoPtr pScrn, + int left, int top, int right, int bottom) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + PKT_SC *pSingleCMD; +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetClippingRectangle\n"); +*/ + pAST->EnableClip = TRUE; + + if (!pAST->MMIO2D) + { + /* Write to CMDQ */ + pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*2); + + ASTSetupCLIP1(pSingleCMD, left, top); + pSingleCMD++; + ASTSetupCLIP2(pSingleCMD, right, bottom); + } + else + { + ASTSetupCLIP1_MMIO(left, top); + ASTSetupCLIP2_MMIO(right, bottom); + } + +} + +static void +ASTDisableClipping(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST = ASTPTR(pScrn); +/* + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTDisableClipping\n"); +*/ + pAST->EnableClip = FALSE; +} + + +#endif /* end of Accel_2D */ diff --git a/src/ast_cursor.c b/src/ast_cursor.c new file mode 100644 index 0000000..fbbce1b --- /dev/null +++ b/src/ast_cursor.c @@ -0,0 +1,376 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xf86.h" +#include "xf86_ansic.h" +#include "xf86_OSproc.h" +#include "xf86Resources.h" +#include "xf86RAC.h" +#include "xf86cmap.h" +#include "compiler.h" +#include "mibstore.h" +#include "vgaHW.h" +#include "mipointer.h" +#include "micmap.h" + +#include "fb.h" +#include "regionstr.h" +#include "xf86xv.h" +#include "Xv.h" +#include "vbe.h" + +#include "xf86PciInfo.h" +#include "xf86Pci.h" + +/* framebuffer offscreen manager */ +#include "xf86fbman.h" + +/* include xaa includes */ +#include "xaa.h" +#include "xaarop.h" + +/* H/W cursor support */ +#include "xf86Cursor.h" +#include "cursorstr.h" + +/* Driver specific headers */ +#include "ast.h" + +#ifdef HWC +/* Prototype type declaration */ +Bool ASTCursorInit(ScreenPtr pScreen); +Bool bInitHWC(ScrnInfoPtr pScrn, ASTRecPtr pAST); +static void ASTShowCursor(ScrnInfoPtr pScrn); +static void ASTHideCursor(ScrnInfoPtr pScrn); +static void ASTSetCursorPosition(ScrnInfoPtr pScrn, int x, int y); +static void ASTSetCursorColors(ScrnInfoPtr pScrn, int bg, int fg); +static void ASTLoadCursorImage(ScrnInfoPtr pScrn, UCHAR *src); +static Bool ASTUseHWCursor(ScreenPtr pScreen, CursorPtr pCurs); +static void ASTLoadCursorARGB(ScrnInfoPtr pScrn, CursorPtr pCurs); +static Bool ASTUseHWCursorARGB(ScreenPtr pScreen, CursorPtr pCurs); + +static void ASTFireCursor(ScrnInfoPtr pScrn); + +Bool +ASTCursorInit(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + ASTRecPtr pAST = ASTPTR(pScrn); + xf86CursorInfoPtr infoPtr; + + infoPtr = xf86CreateCursorInfoRec(); + if(!infoPtr) return FALSE; + + pAST->HWCInfoPtr = infoPtr; + + infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP | + HARDWARE_CURSOR_INVERT_MASK | + HARDWARE_CURSOR_BIT_ORDER_MSBFIRST; + + infoPtr->MaxWidth = MAX_HWC_WIDTH; + infoPtr->MaxHeight = MAX_HWC_HEIGHT; + infoPtr->ShowCursor = ASTShowCursor; + infoPtr->HideCursor = ASTHideCursor; + infoPtr->SetCursorPosition = ASTSetCursorPosition; + infoPtr->SetCursorColors = ASTSetCursorColors; + infoPtr->LoadCursorImage = ASTLoadCursorImage; + infoPtr->UseHWCursor = ASTUseHWCursor; +#ifdef ARGB_CURSOR + infoPtr->UseHWCursorARGB = ASTUseHWCursorARGB; + infoPtr->LoadCursorARGB = ASTLoadCursorARGB; +#endif + + return(xf86InitCursor(pScreen, infoPtr)); + +} + +Bool bInitHWC(ScrnInfoPtr pScrn, ASTRecPtr pAST) +{ + ScreenPtr pScreen; + + /* init cursor cache info */ + /* Set HWC_NUM in Options instead */ + /* pAST->HWCInfo.HWC_NUM = DEFAULT_HWC_NUM; */ + pAST->HWCInfo.HWC_NUM_Next = 0; + + /* allocate HWC cache */ + if (!pAST->pHWCPtr) { + pScreen = screenInfo.screens[pScrn->scrnIndex]; + pAST->pHWCPtr = xf86AllocateOffscreenLinear (pScreen, (HWC_SIZE+HWC_SIGNATURE_SIZE)*pAST->HWCInfo.HWC_NUM, HWC_ALIGN, NULL, NULL, NULL); + + if (!pAST->pHWCPtr) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR,"Allocate HWC Cache failed \n"); + return (FALSE); + } + + pAST->HWCInfo.ulHWCOffsetAddr = pAST->pHWCPtr->offset*((pScrn->bitsPerPixel + 1) / 8); + pAST->HWCInfo.pjHWCVirtualAddr = pAST->FBVirtualAddr + pAST->HWCInfo.ulHWCOffsetAddr; + } + + return (TRUE); +} + + +static void +ASTShowCursor(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + UCHAR jReg; + + jReg= 0x02; + if (pAST->HWCInfo.cursortype ==HWC_COLOR) + jReg |= 0x01; + + SetIndexRegMask(CRTC_PORT, 0xCB, 0xFC, jReg); /* enable mono */ + +} + +static void +ASTHideCursor(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + + SetIndexRegMask(CRTC_PORT, 0xCB, 0xFC, 0x00); /* disable HWC */ + +} + +static void +ASTSetCursorPosition(ScrnInfoPtr pScrn, int x, int y) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + DisplayModePtr mode = pAST->ModePtr; + int x_offset, y_offset; + + x_offset = pAST->HWCInfo.offset_x; + y_offset = pAST->HWCInfo.offset_y; + + if(x < 0) { + x_offset = (-x) + pAST->HWCInfo.offset_x; + x = 0; + } + + if(y < 0) { + y_offset = (-y) + pAST->HWCInfo.offset_y; + y = 0; + } + + if(mode->Flags & V_DBLSCAN) y *= 2; + + /* Set to Reg. */ + SetIndexReg(CRTC_PORT, 0xC2, (UCHAR) (x_offset)); + SetIndexReg(CRTC_PORT, 0xC3, (UCHAR) (y_offset)); + SetIndexReg(CRTC_PORT, 0xC4, (UCHAR) (x & 0xFF)); + SetIndexReg(CRTC_PORT, 0xC5, (UCHAR) ((x >> 8) & 0x0F)); + SetIndexReg(CRTC_PORT, 0xC6, (UCHAR) (y & 0xFF)); + SetIndexReg(CRTC_PORT, 0xC7, (UCHAR) ((y >> 8) & 0x07)); + + /* Fire HWC */ + ASTFireCursor(pScrn); + +} + +static void +ASTSetCursorColors(ScrnInfoPtr pScrn, int bg, int fg) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + + pAST->HWCInfo.fg = (fg & 0x0F) | (((fg>>8) & 0x0F) << 4) | (((fg>>16) & 0x0F) << 8); + pAST->HWCInfo.bg = (bg & 0x0F) | (((bg>>8) & 0x0F) << 4) | (((bg>>16) & 0x0F) << 8); +} + +static void +ASTLoadCursorImage(ScrnInfoPtr pScrn, UCHAR *src) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + int i, j, k; + UCHAR *pjSrcAnd, *pjSrcXor, *pjDstData; + ULONG ulTempDstAnd32[2], ulTempDstXor32[2], ulTempDstData32[2]; + UCHAR jTempSrcAnd32, jTempSrcXor32; + ULONG ulCheckSum = 0; + ULONG ulPatternAddr; + + /* init cursor info. */ + pAST->HWCInfo.cursortype = HWC_MONO; + pAST->HWCInfo.width = (USHORT) MAX_HWC_WIDTH; + pAST->HWCInfo.height = (USHORT) MAX_HWC_HEIGHT; + pAST->HWCInfo.offset_x = MAX_HWC_WIDTH - pAST->HWCInfo.width; + pAST->HWCInfo.offset_y = MAX_HWC_HEIGHT - pAST->HWCInfo.height; + + /* copy cursor image to cache */ + pjSrcXor = src; + pjSrcAnd = src + (MAX_HWC_WIDTH*MAX_HWC_HEIGHT/8); + pjDstData = pAST->HWCInfo.pjHWCVirtualAddr+(HWC_SIZE+HWC_SIGNATURE_SIZE)*pAST->HWCInfo.HWC_NUM_Next; + + for (j = 0; j < MAX_HWC_HEIGHT; j++) + { + for (i = 0; i < (MAX_HWC_WIDTH/8); i++ ) + { + for (k=7; k>0; k-=2) + { + jTempSrcAnd32 = *((UCHAR *) pjSrcAnd); + jTempSrcXor32 = *((UCHAR *) pjSrcXor); + ulTempDstAnd32[0] = ((jTempSrcAnd32 >> k) & 0x01) ? 0x00008000L:0x00L; + ulTempDstXor32[0] = ((jTempSrcXor32 >> k) & 0x01) ? 0x00004000L:0x00L; + ulTempDstData32[0] = ((jTempSrcXor32 >> k) & 0x01) ? pAST->HWCInfo.fg:pAST->HWCInfo.bg; + ulTempDstAnd32[1] = ((jTempSrcAnd32 >> (k-1)) & 0x01) ? 0x80000000L:0x00L; + ulTempDstXor32[1] = ((jTempSrcXor32 >> (k-1)) & 0x01) ? 0x40000000L:0x00L; + ulTempDstData32[1] = ((jTempSrcXor32 >> (k-1)) & 0x01) ? (pAST->HWCInfo.fg << 16):(pAST->HWCInfo.bg << 16); + *((ULONG *) pjDstData) = ulTempDstAnd32[0] | ulTempDstXor32[0] | ulTempDstData32[0] | ulTempDstAnd32[1] | ulTempDstXor32[1] | ulTempDstData32[1]; + ulCheckSum += *((ULONG *) pjDstData); + pjDstData += 4; + + } + pjSrcAnd ++; + pjSrcXor ++; + + } + + } + + /* Write Checksum as signature */ + pjDstData = (UCHAR *) pAST->HWCInfo.pjHWCVirtualAddr + (HWC_SIZE+HWC_SIGNATURE_SIZE)*pAST->HWCInfo.HWC_NUM_Next + HWC_SIZE; + *((ULONG *) pjDstData) = ulCheckSum; + + /* set pattern offset */ + ulPatternAddr = ((pAST->HWCInfo.ulHWCOffsetAddr+(HWC_SIZE+HWC_SIGNATURE_SIZE)*pAST->HWCInfo.HWC_NUM_Next) >> 3); + SetIndexReg(CRTC_PORT, 0xC8, (UCHAR) (ulPatternAddr & 0xFF)); + SetIndexReg(CRTC_PORT, 0xC9, (UCHAR) ((ulPatternAddr >> 8) & 0xFF)); + SetIndexReg(CRTC_PORT, 0xCA, (UCHAR) ((ulPatternAddr >> 16) & 0xFF)); + + /* update HWC_NUM_Next */ + pAST->HWCInfo.HWC_NUM_Next = (pAST->HWCInfo.HWC_NUM_Next+1) % pAST->HWCInfo.HWC_NUM; + +} + +static Bool +ASTUseHWCursor(ScreenPtr pScreen, CursorPtr pCurs) +{ + return TRUE; +} + +static void +ASTLoadCursorARGB(ScrnInfoPtr pScrn, CursorPtr pCurs) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + + UCHAR *pjDstXor, *pjSrcXor; + ULONG i, j, ulSrcWidth, ulSrcHeight; + ULONG ulPerPixelCopy, ulTwoPixelCopy; + LONG lAlphaDstDelta, lLastAlphaDstDelta; + union + { + ULONG ul; + UCHAR b[4]; + } ulSrcData32[2], ulData32; + union + { + USHORT us; + UCHAR b[2]; + } usData16; + ULONG ulCheckSum = 0; + ULONG ulPatternAddr; + + /* init cursor info. */ + pAST->HWCInfo.cursortype = HWC_COLOR; + pAST->HWCInfo.width = pCurs->bits->width; + pAST->HWCInfo.height = pCurs->bits->height; + pAST->HWCInfo.offset_x = MAX_HWC_WIDTH - pAST->HWCInfo.width; + pAST->HWCInfo.offset_y = MAX_HWC_HEIGHT - pAST->HWCInfo.height; + + /* copy cursor image to cache */ + ulSrcWidth = pAST->HWCInfo.width; + ulSrcHeight = pAST->HWCInfo.height; + + lAlphaDstDelta = MAX_HWC_WIDTH << 1; + lLastAlphaDstDelta = lAlphaDstDelta - (ulSrcWidth << 1); + + pjSrcXor = (UCHAR *) pCurs->bits->argb;; + pjDstXor = (UCHAR *) pAST->HWCInfo.pjHWCVirtualAddr + (HWC_SIZE+HWC_SIGNATURE_SIZE)*pAST->HWCInfo.HWC_NUM_Next + + lLastAlphaDstDelta + (MAX_HWC_HEIGHT - ulSrcHeight) * lAlphaDstDelta; + + ulPerPixelCopy = ulSrcWidth & 1; + ulTwoPixelCopy = ulSrcWidth >> 1; + + for (j = 0; j < ulSrcHeight; j++) + { + + for (i = 0; i < ulTwoPixelCopy; i++ ) + { + ulSrcData32[0].ul = *((ULONG *) pjSrcXor) & 0xF0F0F0F0; + ulSrcData32[1].ul = *((ULONG *) (pjSrcXor+4)) & 0xF0F0F0F0; + ulData32.b[0] = ulSrcData32[0].b[1] | (ulSrcData32[0].b[0] >> 4); + ulData32.b[1] = ulSrcData32[0].b[3] | (ulSrcData32[0].b[2] >> 4); + ulData32.b[2] = ulSrcData32[1].b[1] | (ulSrcData32[1].b[0] >> 4); + ulData32.b[3] = ulSrcData32[1].b[3] | (ulSrcData32[1].b[2] >> 4); + *((ULONG *) pjDstXor) = ulData32.ul; + ulCheckSum += (ULONG) ulData32.ul; + pjDstXor += 4; + pjSrcXor += 8; + } + + for (i = 0; i < ulPerPixelCopy; i++ ) + { + ulSrcData32[0].ul = *((ULONG *) pjSrcXor) & 0xF0F0F0F0; + usData16.b[0] = ulSrcData32[0].b[1] | (ulSrcData32[0].b[0] >> 4); + usData16.b[1] = ulSrcData32[0].b[3] | (ulSrcData32[0].b[2] >> 4); + *((USHORT *) pjDstXor) = usData16.us; + ulCheckSum += (ULONG) usData16.us; + pjDstXor += 2; + pjSrcXor += 4; + } + + /* Point to next source and dest scans */ + pjDstXor += lLastAlphaDstDelta; + + } /* end of for-loop */ + + /* Write Checksum as signature */ + pjDstXor = (UCHAR *) pAST->HWCInfo.pjHWCVirtualAddr + (HWC_SIZE+HWC_SIGNATURE_SIZE)*pAST->HWCInfo.HWC_NUM_Next + HWC_SIZE; + *((ULONG *) pjDstXor) = ulCheckSum; + + /* set pattern offset */ + ulPatternAddr = ((pAST->HWCInfo.ulHWCOffsetAddr +(HWC_SIZE+HWC_SIGNATURE_SIZE)*pAST->HWCInfo.HWC_NUM_Next) >> 3); + SetIndexReg(CRTC_PORT, 0xC8, (UCHAR) (ulPatternAddr & 0xFF)); + SetIndexReg(CRTC_PORT, 0xC9, (UCHAR) ((ulPatternAddr >> 8) & 0xFF)); + SetIndexReg(CRTC_PORT, 0xCA, (UCHAR) ((ulPatternAddr >> 16) & 0xFF)); + + /* update HWC_NUM_Next */ + pAST->HWCInfo.HWC_NUM_Next = (pAST->HWCInfo.HWC_NUM_Next+1) % pAST->HWCInfo.HWC_NUM; + +} + +static Bool +ASTUseHWCursorARGB(ScreenPtr pScreen, CursorPtr pCurs) +{ + return TRUE; +} + +static void +ASTFireCursor(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + + SetIndexRegMask(CRTC_PORT, 0xCB, 0xFF, 0x00); /* dummp write to fire HWC */ + +} + +#endif /* End of HWC */ diff --git a/src/ast_cursor.h b/src/ast_cursor.h new file mode 100644 index 0000000..b513f3f --- /dev/null +++ b/src/ast_cursor.h @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#define MAX_HWC_WIDTH 64 +#define MAX_HWC_HEIGHT 64 +#define HWC_SIZE (MAX_HWC_WIDTH*MAX_HWC_HEIGHT*2) +#define HWC_SIGNATURE_SIZE 32 +#define HWC_ALIGN 32 + +#define HWC_MONO 0 +#define HWC_COLOR 1 diff --git a/src/ast_driver.c b/src/ast_driver.c new file mode 100644 index 0000000..44a57d3 --- /dev/null +++ b/src/ast_driver.c @@ -0,0 +1,1220 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xf86.h" +#include "xf86_ansic.h" +#include "xf86_OSproc.h" +#include "xf86Resources.h" +#include "xf86RAC.h" +#include "xf86cmap.h" +#include "compiler.h" +#include "mibstore.h" +#include "vgaHW.h" +#include "mipointer.h" +#include "micmap.h" + +#include "fb.h" +#include "regionstr.h" +#include "xf86xv.h" +#include "Xv.h" +#include "vbe.h" + +#include "xf86PciInfo.h" +#include "xf86Pci.h" + +/* framebuffer offscreen manager */ +#include "xf86fbman.h" + +/* include xaa includes */ +#include "xaa.h" +#include "xaarop.h" + +/* H/W cursor support */ +#include "xf86Cursor.h" + +/* Driver specific headers */ +#include "ast.h" + +/* external reference fucntion */ +extern Bool ASTMapMem(ScrnInfoPtr pScrn); +extern Bool ASTUnmapMem(ScrnInfoPtr pScrn); +extern Bool ASTMapMMIO(ScrnInfoPtr pScrn); +extern void ASTUnmapMMIO(ScrnInfoPtr pScrn); + +extern void vASTOpenKey(ScrnInfoPtr pScrn); +extern Bool bASTRegInit(ScrnInfoPtr pScrn); +extern ULONG GetVRAMInfo(ScrnInfoPtr pScrn); +extern void vASTLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices, LOCO *colors, VisualPtr pVisual); +extern void ASTDisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags); +extern void vSetStartAddressCRT1(ASTRecPtr pAST, ULONG base); +extern Bool ASTSetMode(ScrnInfoPtr pScrn, DisplayModePtr mode); + +extern Bool bInitCMDQInfo(ScrnInfoPtr pScrn, ASTRecPtr pAST); +extern Bool bEnableCMDQ(ScrnInfoPtr pScrn, ASTRecPtr pAST); +extern void vDisable2D(ScrnInfoPtr pScrn, ASTRecPtr pAST); + +extern Bool ASTAccelInit(ScreenPtr pScreen); + +extern Bool ASTCursorInit(ScreenPtr pScreen); + +/* Mandatory functions */ +static void ASTIdentify(int flags); +const OptionInfoRec *ASTAvailableOptions(int chipid, int busid); +static Bool ASTProbe(DriverPtr drv, int flags); +static Bool ASTPreInit(ScrnInfoPtr pScrn, int flags); +static Bool ASTScreenInit(int Index, ScreenPtr pScreen, int argc, char **argv); +Bool ASTSwitchMode(int scrnIndex, DisplayModePtr mode, int flags); +void ASTAdjustFrame(int scrnIndex, int x, int y, int flags); +static Bool ASTEnterVT(int scrnIndex, int flags); +static void ASTLeaveVT(int scrnIndex, int flags); +static void ASTFreeScreen(int scrnIndex, int flags); +static ModeStatus ASTValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags); + +/* Internally used functions */ +static Bool ASTGetRec(ScrnInfoPtr pScrn); +static void ASTFreeRec(ScrnInfoPtr pScrn); +static Bool ASTSaveScreen(ScreenPtr pScreen, Bool unblack); +static Bool ASTCloseScreen(int scrnIndex, ScreenPtr pScreen); +static void ASTSave(ScrnInfoPtr pScrn); +static void ASTRestore(ScrnInfoPtr pScrn); +static void ASTProbeDDC(ScrnInfoPtr pScrn, int index); +static xf86MonPtr ASTDoDDC(ScrnInfoPtr pScrn, int index); +static void vFillASTModeInfo (ScrnInfoPtr pScrn); +static Bool ASTModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode); + +/* + * This is intentionally screen-independent. It indicates the binding + * choice made in the first PreInit. + */ +DriverRec AST = { + AST_VERSION, + AST_DRIVER_NAME, + ASTIdentify, + ASTProbe, + ASTAvailableOptions, + NULL, + 0 +}; + +/* Chipsets */ +static SymTabRec ASTChipsets[] = { + {PCI_CHIP_AST2000, "AST2000"}, + {-1, NULL} +}; + +static PciChipsets ASTPciChipsets[] = { + {PCI_CHIP_AST2000, PCI_CHIP_AST2000, RES_SHARED_VGA}, + {-1, -1, RES_UNDEFINED } +}; + +typedef enum { + OPTION_NOACCEL, + OPTION_MMIO2D, + OPTION_SW_CURSOR, + OPTION_HWC_NUM, + OPTION_ENG_CAPS, + OPTION_DBG_SELECT, + OPTION_NO_DDC, +} ASTOpts; + +static const OptionInfoRec ASTOptions[] = { + {OPTION_NOACCEL, "NoAccel", OPTV_BOOLEAN, {0}, FALSE}, + {OPTION_MMIO2D, "MMIO2D", OPTV_BOOLEAN, {0}, FALSE}, + {OPTION_SW_CURSOR, "SWCursor", OPTV_BOOLEAN, {0}, FALSE}, + {OPTION_HWC_NUM, "HWCNumber", OPTV_INTEGER, {0}, FALSE}, + {OPTION_ENG_CAPS, "ENGCaps", OPTV_INTEGER, {0}, FALSE}, + {OPTION_DBG_SELECT, "DBGSelect", OPTV_INTEGER, {0}, FALSE}, + {OPTION_NO_DDC, "NoDDC", OPTV_BOOLEAN, {0}, FALSE}, + {-1, NULL, OPTV_NONE, {0}, FALSE} +}; + +const char *vgahwSymbols[] = { + "vgaHWFreeHWRec", + "vgaHWGetHWRec", + "vgaHWGetIOBase", + "vgaHWGetIndex", + "vgaHWInit", + "vgaHWLock", + "vgaHWMapMem", + "vgaHWProtect", + "vgaHWRestore", + "vgaHWSave", + "vgaHWSaveScreen", + "vgaHWSetMmioFuncs", + "vgaHWUnlock", + "vgaHWUnmapMem", + NULL +}; + +const char *fbSymbols[] = { + "fbPictureInit", + "fbScreenInit", + NULL +}; + +const char *vbeSymbols[] = { + "VBEInit", + "VBEFreeModeInfo", + "VBEFreeVBEInfo", + "VBEGetModeInfo", + "VBEGetModePool", + "VBEGetVBEInfo", + "VBEGetVBEMode", + "VBEPrintModes", + "VBESaveRestore", + "VBESetDisplayStart", + "VBESetGetDACPaletteFormat", + "VBESetGetLogicalScanlineLength", + "VBESetGetPaletteData", + "VBESetModeNames", + "VBESetModeParameters", + "VBESetVBEMode", + "VBEValidateModes", + "vbeDoEDID", + "vbeFree", + NULL +}; + +#ifdef XFree86LOADER +static const char *vbeOptionalSymbols[] = { + "VBEDPMSSet", + "VBEGetPixelClock", + NULL +}; +#endif + +const char *ddcSymbols[] = { + "xf86PrintEDID", + "xf86SetDDCproperties", + NULL +}; + +const char *int10Symbols[] = { + "xf86ExecX86int10", + "xf86InitInt10", + "xf86Int10AllocPages", + "xf86int10Addr", + NULL +}; + +const char *xaaSymbols[] = { + "XAACreateInfoRec", + "XAADestroyInfoRec", + "XAAInit", + "XAACopyROP", + "XAAPatternROP", + NULL +}; + +const char *ramdacSymbols[] = { + "xf86CreateCursorInfoRec", + "xf86DestroyCursorInfoRec", + "xf86InitCursor", + NULL +}; + + +#ifdef XFree86LOADER + +static MODULESETUPPROTO(astSetup); + +static XF86ModuleVersionInfo astVersRec = { + AST_DRIVER_NAME, + MODULEVENDORSTRING, + MODINFOSTRING1, + MODINFOSTRING2, + XF86_VERSION_CURRENT, + AST_MAJOR_VERSION, AST_MINOR_VERSION, AST_PATCH_VERSION, + ABI_CLASS_VIDEODRV, + ABI_VIDEODRV_VERSION, + MOD_CLASS_VIDEODRV, + {0, 0, 0, 0} +}; + +XF86ModuleData astModuleData = { &astVersRec, astSetup, NULL }; + +static pointer +astSetup(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(&AST, module, 0); + + /* + * Tell the loader about symbols from other modules that this module + * might refer to. + */ + LoaderRefSymLists(vgahwSymbols, + fbSymbols, xaaSymbols, ramdacSymbols, + vbeSymbols, vbeOptionalSymbols, + ddcSymbols, int10Symbols, NULL); + + /* + * The return value must be non-NULL on success even though there + * is no TearDownProc. + */ + return (pointer) TRUE; + } else { + if (errmaj) + *errmaj = LDR_ONCEONLY; + return NULL; + } +} + +#endif /* XFree86LOADER */ + +/* + * ASTIdentify -- + * + * Returns the string name for the driver based on the chipset. In this + * case it will always be an AST, so we can return a static string. + * + */ +static void +ASTIdentify(int flags) +{ + xf86PrintChipsets(AST_NAME, "Driver for AST Graphics Chipsets", + ASTChipsets); +} + +const OptionInfoRec * +ASTAvailableOptions(int chipid, int busid) +{ + + return ASTOptions; + +} + +/* + * ASTProbe -- + * + * Look through the PCI bus to find cards that are AST boards. + * Setup the dispatch table for the rest of the driver functions. + * + */ +static Bool +ASTProbe(DriverPtr drv, int flags) +{ + int i, numUsed, numDevSections, *usedChips; + Bool foundScreen = FALSE; + GDevPtr *devSections; + + /* + * Find the config file Device sections that match this + * driver, and return if there are none. + */ + if ((numDevSections = + xf86MatchDevice(AST_DRIVER_NAME, &devSections)) <= 0) { + return FALSE; + } + + /* + * This probing is just checking the PCI data the server already + * collected. + */ + if (xf86GetPciVideoInfo() == NULL) { + return FALSE; + } + + numUsed = xf86MatchPciInstances(AST_NAME, PCI_VENDOR_AST, + ASTChipsets, ASTPciChipsets, + devSections, numDevSections, + drv, &usedChips); + + xfree(devSections); + + if (flags & PROBE_DETECT) { + if (numUsed > 0) + foundScreen = TRUE; + } else { + for (i = 0; i < numUsed; i++) { + ScrnInfoPtr pScrn = NULL; + + /* Allocate new ScrnInfoRec and claim the slot */ + if ((pScrn = xf86ConfigPciEntity(pScrn, 0, usedChips[i], + ASTPciChipsets, 0, 0, 0, 0, 0))) + { + EntityInfoPtr pEnt; + + pEnt = xf86GetEntityInfo(usedChips[i]); + + pScrn->driverVersion = AST_VERSION; + pScrn->driverName = AST_DRIVER_NAME; + pScrn->name = AST_NAME; + + pScrn->Probe = ASTProbe; + pScrn->PreInit = ASTPreInit; + pScrn->ScreenInit = ASTScreenInit; + pScrn->SwitchMode = ASTSwitchMode; + pScrn->AdjustFrame = ASTAdjustFrame; + pScrn->EnterVT = ASTEnterVT; + pScrn->LeaveVT = ASTLeaveVT; + pScrn->FreeScreen = ASTFreeScreen; + pScrn->ValidMode = ASTValidMode; + + foundScreen = TRUE; + + } /* end of if */ + } /* end of for-loop */ + } /* end of if flags */ + + xfree(usedChips); + + return foundScreen; +} + +/* + * ASTPreInit -- + * + * Do initial setup of the board before we know what resolution we will + * be running at. + * + */ +static Bool +ASTPreInit(ScrnInfoPtr pScrn, int flags) +{ + EntityInfoPtr pEnt; + vgaHWPtr hwp; + int flags24; + rgb defaultWeight = { 0, 0, 0 }; + + ASTRecPtr pAST; + + ClockRangePtr clockRanges; + int i; + MessageType from; + + /* Suport one adapter only now */ + if (pScrn->numEntities != 1) + return FALSE; + + pEnt = xf86GetEntityInfo(pScrn->entityList[0]); + + if (flags & PROBE_DETECT) { + ASTProbeDDC(pScrn, pEnt->index); + return TRUE; + } + + if (pEnt->location.type != BUS_PCI) + return FALSE; + + if (xf86RegisterResources(pEnt->index, 0, ResExclusive)) + return FALSE; + + /* The vgahw module should be loaded here when needed */ + if (!xf86LoadSubModule(pScrn, "vgahw")) + return FALSE; + xf86LoaderReqSymLists(vgahwSymbols, NULL); + + /* The fb module should be loaded here when needed */ + if (!xf86LoadSubModule(pScrn, "fb")) + return FALSE; + xf86LoaderReqSymLists(fbSymbols, NULL); + + /* Allocate a vgaHWRec */ + if (!vgaHWGetHWRec(pScrn)) + return FALSE; + hwp = VGAHWPTR(pScrn); + + /* Color Depth Check */ + flags24 = Support32bppFb; + if (!xf86SetDepthBpp(pScrn, 0, 0, 0, flags24)) { + return FALSE; + } else { + switch (pScrn->depth) { + case 8: + case 16: + case 24: + break; + default: + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, + "Given depth (%d) is not supported by ast driver\n", + pScrn->depth); + return FALSE; + } + } + xf86PrintDepthBpp(pScrn); + + switch (pScrn->bitsPerPixel) { + case 8: + case 16: + case 32: + break; + default: + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, + "Given bpp (%d) is not supported by ast driver\n", + pScrn->bitsPerPixel); + return FALSE; + } + + /* fill pScrn misc. */ + pScrn->progClock = TRUE; + pScrn->rgbBits = 6; + pScrn->monitor = pScrn->confScreen->monitor; /* should be initialized before set gamma */ + pScrn->racMemFlags = RAC_FB | RAC_COLORMAP | RAC_CURSOR | RAC_VIEWPORT; + pScrn->racIoFlags = RAC_COLORMAP | RAC_CURSOR | RAC_VIEWPORT; + + /* + * If the driver can do gamma correction, it should call xf86SetGamma() + * here. + */ + { + Gamma zeros = { 0.0, 0.0, 0.0 }; + + if (!xf86SetGamma(pScrn, zeros)) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "call xf86SetGamma failed \n"); + return FALSE; + } + } + + + if (!xf86SetWeight(pScrn, defaultWeight, defaultWeight)) { + return FALSE; + } + + if (!xf86SetDefaultVisual(pScrn, -1)) { + return FALSE; + } + + /* Allocate driverPrivate */ + if (!ASTGetRec(pScrn)) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "call ASTGetRec failed \n"); + return FALSE; + } + + /* Fill AST Info */ + pAST = ASTPTR(pScrn); + pAST->pEnt = xf86GetEntityInfo(pScrn->entityList[0]); + pAST->PciInfo = xf86GetPciInfoForEntity(pAST->pEnt->index); + pAST->PciTag = pciTag(pAST->PciInfo->bus, pAST->PciInfo->device, + pAST->PciInfo->func); + + /* Process the options + * pScrn->confScreen, pScrn->display, pScrn->monitor, pScrn->numEntities, + * and pScrn->entityList should be initialized before + */ + xf86CollectOptions(pScrn, NULL); + if (!(pAST->Options = xalloc(sizeof(ASTOptions)))) + { + ASTFreeRec(pScrn); + return FALSE; + } + memcpy(pAST->Options, ASTOptions, sizeof(ASTOptions)); + xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pAST->Options); + + /* + * Set the Chipset and ChipRev, allowing config file entries to + * override. + */ + if (pAST->pEnt->device->chipset && *pAST->pEnt->device->chipset) { + pScrn->chipset = pAST->pEnt->device->chipset; + from = X_CONFIG; + } else if (pAST->pEnt->device->chipID >= 0) { + pScrn->chipset = (char *)xf86TokenToString(ASTChipsets, + pAST->pEnt->device->chipID); + from = X_CONFIG; + xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipID override: 0x%04X\n", + pAST->pEnt->device->chipID); + } else { + from = X_PROBED; + pScrn->chipset = (char *)xf86TokenToString(ASTChipsets, + pAST->PciInfo->chipType); + } + if (pAST->pEnt->device->chipRev >= 0) { + xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipRev override: %d\n", + pAST->pEnt->device->chipRev); + } + + xf86DrvMsg(pScrn->scrnIndex, from, "Chipset: \"%s\"\n", + (pScrn->chipset != NULL) ? pScrn->chipset : "Unknown ast"); + + /* Resource Allocation */ +#if XF86_VERSION_CURRENT < XF86_VERSION_NUMERIC(4,2,99,0,0) + pAST->IODBase = 0; +#else + pAST->IODBase = pScrn->domainIOBase; +#endif + /* "Patch" the PIOOffset inside vgaHW in order to force + * the vgaHW module to use our relocated i/o ports. + */ + VGAHWPTR(pScrn)->PIOOffset = pAST->PIOOffset = pAST->IODBase + pAST->PciInfo->ioBase[2] - 0x380; + + pAST->RelocateIO = (IOADDRESS)(pAST->PciInfo->ioBase[2] + pAST->IODBase); + + if (pAST->pEnt->device->MemBase != 0) { + pAST->FBPhysAddr = pAST->pEnt->device->MemBase; + from = X_CONFIG; + } else { + if (pAST->PciInfo->memBase[0] != 0) { + pAST->FBPhysAddr = pAST->PciInfo->memBase[0] & 0xFFF00000; + from = X_PROBED; + } else { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, + "No valid FB address in PCI config space\n"); + ASTFreeRec(pScrn); + return FALSE; + } + } + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Linear framebuffer at 0x%lX\n", + (unsigned long) pAST->FBPhysAddr); + + if (pAST->pEnt->device->IOBase != 0) { + pAST->MMIOPhysAddr = pAST->pEnt->device->IOBase; + from = X_CONFIG; + } else { + if (pAST->PciInfo->memBase[1]) { + pAST->MMIOPhysAddr = pAST->PciInfo->memBase[1] & 0xFFFF0000; + from = X_PROBED; + } else { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, + "No valid MMIO address in PCI config space\n"); + ASTFreeRec(pScrn); + return FALSE; + } + } + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "IO registers at addr 0x%lX\n", + (unsigned long) pAST->MMIOPhysAddr); + + pScrn->videoRam = GetVRAMInfo(pScrn) / 1024; + from = X_DEFAULT; + + + if (pAST->pEnt->device->videoRam) { + pScrn->videoRam = pAST->pEnt->device->videoRam; + from = X_CONFIG; + } + + pAST->FbMapSize = pScrn->videoRam * 1024; + pAST->MMIOMapSize = DEFAULT_MMIO_SIZE; + + /* Do DDC + * should be done after xf86CollectOptions + */ + pScrn->monitor->DDC = ASTDoDDC(pScrn, pAST->pEnt->index); + + /* Mode Valid */ + clockRanges = xnfcalloc(sizeof(ClockRange), 1); + clockRanges->next = NULL; + clockRanges->minClock = 9500; + clockRanges->maxClock = 165000; + clockRanges->clockIndex = -1; + clockRanges->interlaceAllowed = FALSE; + clockRanges->doubleScanAllowed = FALSE; + + i = xf86ValidateModes(pScrn, pScrn->monitor->Modes, + pScrn->display->modes, clockRanges, + 0, 320, 1600, 8 * pScrn->bitsPerPixel, + 200, 1200, + pScrn->display->virtualX, pScrn->display->virtualY, + pAST->FbMapSize, LOOKUP_BEST_REFRESH); + + if (i == -1) { + ASTFreeRec(pScrn); + return FALSE; + } + + xf86PruneDriverModes(pScrn); + + if (!i || !pScrn->modes) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n"); + ASTFreeRec(pScrn); + return FALSE; + } + + xf86SetCrtcForModes(pScrn, INTERLACE_HALVE_V); + + pScrn->currentMode = pScrn->modes; + + xf86PrintModes(pScrn); + + xf86SetDpi(pScrn, 0, 0); + + /* Accelaration Check */ + pAST->noAccel = TRUE; + pAST->AccelInfoPtr = NULL; + pAST->pCMDQPtr = NULL; + pAST->CMDQInfo.ulCMDQSize = 0; +#ifdef Accel_2D + if (!xf86ReturnOptValBool(pAST->Options, OPTION_NOACCEL, FALSE)) + { + if (!xf86LoadSubModule(pScrn, "xaa")) { + ASTFreeRec(pScrn); + return FALSE; + } + xf86LoaderReqSymLists(xaaSymbols, NULL); + + pAST->noAccel = FALSE; + + pAST->MMIO2D = TRUE; +#ifndef MMIO_2D + if (!xf86ReturnOptValBool(pAST->Options, OPTION_MMIO2D, FALSE)) { + pAST->CMDQInfo.ulCMDQSize = DEFAULT_CMDQ_SIZE; + pAST->MMIO2D = FALSE; + } +#endif + + pAST->ENGCaps = ENG_CAP_ALL; + if (!xf86GetOptValInteger(pAST->Options, OPTION_ENG_CAPS, &pAST->ENGCaps)) { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "No ENG Capability options found\n"); + } + + pAST->DBGSelect = 0; + if (!xf86GetOptValInteger(pAST->Options, OPTION_DBG_SELECT, &pAST->DBGSelect)) { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "No DBG Seleclt options found\n"); + } + } +#endif + + /* HW Cursor Check */ + pAST->noHWC = TRUE; + pAST->HWCInfoPtr = NULL; + pAST->pHWCPtr = NULL; +#ifdef HWC + if (!xf86ReturnOptValBool(pAST->Options, OPTION_SW_CURSOR, FALSE)) { + if (!xf86LoadSubModule(pScrn, "ramdac")) { + ASTFreeRec(pScrn); + return FALSE; + } + xf86LoaderReqSymLists(ramdacSymbols, NULL); + + pAST->noHWC = FALSE; + pAST->HWCInfo.HWC_NUM = DEFAULT_HWC_NUM; + if (!xf86GetOptValInteger(pAST->Options, OPTION_HWC_NUM, &pAST->HWCInfo.HWC_NUM)) { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "No HWC_NUM options found\n"); + } + + } +#endif + + /* We won't be using the VGA access after the probe */ + xf86SetOperatingState(resVgaIo, pAST->pEnt->index, ResUnusedOpr); + xf86SetOperatingState(resVgaMem, pAST->pEnt->index, ResDisableOpr); + + return TRUE; +} + + +static Bool +ASTScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv) +{ + ScrnInfoPtr pScrn; + ASTRecPtr pAST; + vgaHWPtr hwp; + VisualPtr visual; + + /* for FB Manager */ + BoxRec FBMemBox; + int AvailFBSize; + + pScrn = xf86Screens[pScreen->myNum]; + pAST = ASTPTR(pScrn); + hwp = VGAHWPTR(pScrn); + + + if (!ASTMapMem(pScrn)) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Map FB Memory Failed \n"); + return FALSE; + } + + if (!ASTMapMMIO(pScrn)) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Map Memory Map IO Failed \n"); + return FALSE; + } + + pScrn->memPhysBase = (ULONG)pAST->FBPhysAddr; + pScrn->fbOffset = 0; + +/* if (!pAST->noAccel) */ + { + /* AvailFBSize = pAST->FbMapSize - pAST->CMDQInfo.ulCMDQSize; */ + AvailFBSize = pAST->FbMapSize; + + FBMemBox.x1 = 0; + FBMemBox.y1 = 0; + FBMemBox.x2 = pScrn->displayWidth; + FBMemBox.y2 = (AvailFBSize / (pScrn->displayWidth * ((pScrn->bitsPerPixel+1)/8))) - 1; + + if (!xf86InitFBManager(pScreen, &FBMemBox)) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Failed to init memory manager\n"); + return FALSE; + } + + } + + vgaHWGetIOBase(hwp); + + vFillASTModeInfo (pScrn); + + ASTSave(pScrn); + if (!ASTModeInit(pScrn, pScrn->currentMode)) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Mode Init Failed \n"); + return FALSE; + } + + ASTSaveScreen(pScreen, FALSE); + ASTAdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0); + + miClearVisualTypes(); + + /* Re-implemented Direct Color support, -jens */ + if (!miSetVisualTypes(pScrn->depth, miGetDefaultVisualMask(pScrn->depth), + pScrn->rgbBits, pScrn->defaultVisual)) + return FALSE; + + if (!miSetPixmapDepths()) + { + ASTSaveScreen(pScreen, SCREEN_SAVER_OFF); + return FALSE; + } + + switch(pScrn->bitsPerPixel) { + case 8: + case 16: + case 32: + if (!fbScreenInit(pScreen, pAST->FBVirtualAddr + pScrn->fbOffset, + pScrn->virtualX, pScrn->virtualY, + pScrn->xDpi, pScrn->yDpi, + pScrn->displayWidth, pScrn->bitsPerPixel)) + return FALSE; + break; + default: + return FALSE; + + } + + if (pScrn->bitsPerPixel > 8) { + /* Fixup RGB ordering */ + visual = pScreen->visuals + pScreen->numVisuals; + while (--visual >= pScreen->visuals) { + if ((visual->class | DynamicClass) == DirectColor) { + visual->offsetRed = pScrn->offset.red; + visual->offsetGreen = pScrn->offset.green; + visual->offsetBlue = pScrn->offset.blue; + visual->redMask = pScrn->mask.red; + visual->greenMask = pScrn->mask.green; + visual->blueMask = pScrn->mask.blue; + } + } + } + + fbPictureInit(pScreen, 0, 0); + + xf86SetBlackWhitePixels(pScreen); + +#ifdef Accel_2D + if (!pAST->noAccel) + { + if (!ASTAccelInit(pScreen)) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR,"Hardware acceleration initialization failed\n"); + pAST->noAccel = TRUE; + } + } +#endif /* end of Accel_2D */ + + miInitializeBackingStore(pScreen); + xf86SetBackingStore(pScreen); + xf86SetSilkenMouse(pScreen); + + miDCInitialize(pScreen, xf86GetPointerScreenFuncs()); + + if (!pAST->noHWC) + { + if (!ASTCursorInit(pScreen)) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR,"Hardware cursor initialization failed\n"); + pAST->noHWC = TRUE; + } + } + + if (!miCreateDefColormap(pScreen)) + return FALSE; + + if(!xf86HandleColormaps(pScreen, 256, (pScrn->depth == 8) ? 8 : pScrn->rgbBits, + vASTLoadPalette, NULL, + CMAP_PALETTED_TRUECOLOR | CMAP_RELOAD_ON_MODE_SWITCH)) { + return FALSE; + } + + xf86DPMSInit(pScreen, ASTDisplayPowerManagementSet, 0); + + pScreen->SaveScreen = ASTSaveScreen; + pAST->CloseScreen = pScreen->CloseScreen; + pScreen->CloseScreen = ASTCloseScreen; + + if (serverGeneration == 1) + xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options); + + return TRUE; + +} /* ASTScreenInit */ + + +Bool +ASTSwitchMode(int scrnIndex, DisplayModePtr mode, int flags) +{ + ScrnInfoPtr pScrn = xf86Screens[scrnIndex]; + ASTRecPtr pAST = ASTPTR(pScrn); + +#ifdef HWC + if (pAST->pHWCPtr) { + xf86FreeOffscreenLinear(pAST->pHWCPtr); /* free HWC Cache */ + pAST->pHWCPtr = NULL; + } +#endif + +#ifdef Accel_2D + if (pAST->pCMDQPtr) { + xf86FreeOffscreenLinear(pAST->pCMDQPtr); /* free CMDQ */ + pAST->pCMDQPtr = NULL; + } + vDisable2D(pScrn, pAST); +#endif + + ASTRestore(pScrn); + + return ASTModeInit(pScrn, mode); + +} + +void +ASTAdjustFrame(int scrnIndex, int x, int y, int flags) +{ + ScrnInfoPtr pScrn = xf86Screens[scrnIndex]; + ASTRecPtr pAST = ASTPTR(pScrn); + ULONG base; + + base = y * pAST->VideoModeInfo.ScreenWidth + x * ((pAST->VideoModeInfo.bitsPerPixel + 1) / 8); + base = base >> 2; /* DW unit */ + + vSetStartAddressCRT1(pAST, base); + +} + +/* enter into X Server */ +static Bool +ASTEnterVT(int scrnIndex, int flags) +{ + ScrnInfoPtr pScrn = xf86Screens[scrnIndex]; + + if (!ASTModeInit(pScrn, pScrn->currentMode)) + return FALSE; + ASTAdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0); + + return TRUE; + +} + +/* leave X server */ +static void +ASTLeaveVT(int scrnIndex, int flags) +{ + + ScrnInfoPtr pScrn = xf86Screens[scrnIndex]; + vgaHWPtr hwp = VGAHWPTR(pScrn); + ASTRecPtr pAST = ASTPTR(pScrn); + +#ifdef HWC + if (pAST->pHWCPtr) { + xf86FreeOffscreenLinear(pAST->pHWCPtr); /* free HWC Cache */ + pAST->pHWCPtr = NULL; + } +#endif + +#ifdef Accel_2D + if (pAST->pCMDQPtr) { + xf86FreeOffscreenLinear(pAST->pCMDQPtr); /* free CMDQ */ + pAST->pCMDQPtr = NULL; + } + vDisable2D(pScrn, pAST); +#endif + + ASTRestore(pScrn); + vgaHWLock(hwp); + +} + +static void +ASTFreeScreen(int scrnIndex, int flags) +{ + ASTFreeRec(xf86Screens[scrnIndex]); + if (xf86LoaderCheckSymbol("vgaHWFreeHWRec")) + vgaHWFreeHWRec(xf86Screens[scrnIndex]); +} + + +static ModeStatus +ASTValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags) +{ + + Bool Flags = MODE_NOMODE; + + if (mode->Flags & V_INTERLACE) { + if (verbose) { + xf86DrvMsg(scrnIndex, X_PROBED, + "Removing interlaced mode \"%s\"\n", mode->name); + } + return MODE_NO_INTERLACE; + } + + if ((mode->CrtcHDisplay > MAX_HResolution) || (mode->CrtcVDisplay > MAX_VResolution)) { + if (verbose) { + xf86DrvMsg(scrnIndex, X_PROBED, + "Removing the mode \"%s\"\n", mode->name); + } + return Flags; + } + + switch (mode->CrtcHDisplay) + { + case 640: + if (mode->CrtcVDisplay == 480) Flags=MODE_OK; + break; + case 800: + if (mode->CrtcVDisplay == 600) Flags=MODE_OK; + break; + case 1024: + if (mode->CrtcVDisplay == 768) Flags=MODE_OK; + break; + case 1280: + if (mode->CrtcVDisplay == 1024) Flags=MODE_OK; + break; + case 1600: + if (mode->CrtcVDisplay == 1200) Flags=MODE_OK; + break; + default: + return Flags; + } + + return Flags; + +} + + +/* Internal used modules */ +/* + * ASTGetRec and ASTFreeRec -- + * + * Private data for the driver is stored in the screen structure. + * These two functions create and destroy that private data. + * + */ +static Bool +ASTGetRec(ScrnInfoPtr pScrn) +{ + if (pScrn->driverPrivate) + return TRUE; + + pScrn->driverPrivate = xnfcalloc(sizeof(ASTRec), 1); + return TRUE; +} + +static void +ASTFreeRec(ScrnInfoPtr pScrn) +{ + if (!pScrn) + return; + if (!pScrn->driverPrivate) + return; + xfree(pScrn->driverPrivate); + pScrn->driverPrivate = 0; +} + +static Bool +ASTSaveScreen(ScreenPtr pScreen, Bool unblack) +{ + /* more ref. SiS */ + return vgaHWSaveScreen(pScreen, unblack); +} + +static Bool +ASTCloseScreen(int scrnIndex, ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[scrnIndex]; + vgaHWPtr hwp = VGAHWPTR(pScrn); + ASTRecPtr pAST = ASTPTR(pScrn); + + if (pScrn->vtSema == TRUE) + { +#ifdef HWC + if (pAST->pHWCPtr) { + xf86FreeOffscreenLinear(pAST->pHWCPtr); /* free HWC Cache */ + pAST->pHWCPtr = NULL; + } +#endif + +#ifdef Accel_2D + if (pAST->pCMDQPtr) { + xf86FreeOffscreenLinear(pAST->pCMDQPtr); /* free CMDQ */ + pAST->pCMDQPtr = NULL; + } + vDisable2D(pScrn, pAST); +#endif + + ASTRestore(pScrn); + vgaHWLock(hwp); + } + + ASTUnmapMem(pScrn); + vgaHWUnmapMem(pScrn); + + if(pAST->AccelInfoPtr) { + XAADestroyInfoRec(pAST->AccelInfoPtr); + pAST->AccelInfoPtr = NULL; + } + + if(pAST->HWCInfoPtr) { + xf86DestroyCursorInfoRec(pAST->HWCInfoPtr); + pAST->HWCInfoPtr = NULL; + } + + pScrn->vtSema = FALSE; + pScreen->CloseScreen = pAST->CloseScreen; + return (*pScreen->CloseScreen) (scrnIndex, pScreen); +} + +static void +ASTSave(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST; + vgaRegPtr vgaReg; + ASTRegPtr astReg; + int i; + + pAST = ASTPTR(pScrn); + vgaReg = &VGAHWPTR(pScrn)->SavedReg; + astReg = &pAST->SavedReg; + + /* do save */ + vgaHWSave(pScrn, vgaReg, VGA_SR_ALL); + + /* Ext. Save */ + vASTOpenKey(pScrn); + + for (i=0; i<0x50; i++) + GetIndexReg(CRTC_PORT, (UCHAR) (i+0x80), astReg->ExtCRTC[i]); + +} + +static void +ASTRestore(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST; + vgaRegPtr vgaReg; + ASTRegPtr astReg; + int i; + + pAST = ASTPTR(pScrn); + vgaReg = &VGAHWPTR(pScrn)->SavedReg; + astReg = &pAST->SavedReg; + + /* do restore */ + vgaHWProtect(pScrn, TRUE); + vgaHWRestore(pScrn, vgaReg, VGA_SR_ALL); + vgaHWProtect(pScrn, FALSE); + + /* Ext. restore */ + vASTOpenKey(pScrn); + + for (i=0; i<0x50; i++) + SetIndexReg(CRTC_PORT, (UCHAR) (i+0x80), astReg->ExtCRTC[i]); + +} + +static void +ASTProbeDDC(ScrnInfoPtr pScrn, int index) +{ + vbeInfoPtr pVbe; + + if (xf86LoadSubModule(pScrn, "vbe")) { + pVbe = VBEInit(NULL, index); + ConfiguredMonitor = vbeDoEDID(pVbe, NULL); + vbeFree(pVbe); + } +} + +static xf86MonPtr +ASTDoDDC(ScrnInfoPtr pScrn, int index) +{ + vbeInfoPtr pVbe; + xf86MonPtr MonInfo = NULL; + ASTRecPtr pAST = ASTPTR(pScrn); + + /* Honour Option "noDDC" */ + if (xf86ReturnOptValBool(pAST->Options, OPTION_NO_DDC, FALSE)) { + return MonInfo; + } + + if (xf86LoadSubModule(pScrn, "vbe") && (pVbe = VBEInit(NULL, index))) { + xf86LoaderReqSymLists(vbeSymbols, NULL); + MonInfo = vbeDoEDID(pVbe, NULL); + xf86PrintEDID(MonInfo); + xf86SetDDCproperties(pScrn, MonInfo); + vbeFree(pVbe); + } else { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, + "this driver cannot do DDC without VBE\n"); + } + + return MonInfo; +} + +static void +vFillASTModeInfo (ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST; + + pAST = ASTPTR(pScrn); + + pAST->VideoModeInfo.ScreenWidth = pScrn->virtualX; + pAST->VideoModeInfo.ScreenHeight = pScrn->virtualY; + pAST->VideoModeInfo.bitsPerPixel = pScrn->bitsPerPixel; + pAST->VideoModeInfo.ScreenPitch = pScrn->virtualX * ((pScrn->bitsPerPixel + 1) / 8) ; + +} + +static Bool +ASTModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode) +{ + vgaHWPtr hwp; + ASTRecPtr pAST; + + hwp = VGAHWPTR(pScrn); + pAST = ASTPTR(pScrn); + + vgaHWUnlock(hwp); + + if (!vgaHWInit(pScrn, mode)) + return FALSE; + + pScrn->vtSema = TRUE; + pAST->ModePtr = mode; + + if (!ASTSetMode(pScrn, mode)) + return FALSE; + + vgaHWProtect(pScrn, FALSE); + + return TRUE; +} diff --git a/src/ast_mode.c b/src/ast_mode.c new file mode 100644 index 0000000..94d2ef5 --- /dev/null +++ b/src/ast_mode.c @@ -0,0 +1,712 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xf86.h" +#include "xf86_ansic.h" +#include "xf86_OSproc.h" +#include "xf86Resources.h" +#include "xf86RAC.h" +#include "xf86cmap.h" +#include "compiler.h" +#include "mibstore.h" +#include "vgaHW.h" +#include "mipointer.h" +#include "micmap.h" + +#include "fb.h" +#include "regionstr.h" +#include "xf86xv.h" +#include "Xv.h" +#include "vbe.h" + +#include "xf86PciInfo.h" +#include "xf86Pci.h" + +/* framebuffer offscreen manager */ +#include "xf86fbman.h" + +/* include xaa includes */ +#include "xaa.h" +#include "xaarop.h" + +/* H/W cursor support */ +#include "xf86Cursor.h" + +/* Driver specific headers */ +#include "ast.h" + +VBIOS_STDTABLE_STRUCT StdTable[] = { + /* MD_2_3_400 */ + { + 0x67, + {0x00,0x03,0x00,0x02}, + {0x5f,0x4f,0x50,0x82,0x55,0x81,0xbf,0x1f, + 0x00,0x4f,0x0d,0x0e,0x00,0x00,0x00,0x00, + 0x9c,0x8e,0x8f,0x28,0x1f,0x96,0xb9,0xa3, + 0xff}, + {0x00,0x01,0x02,0x03,0x04,0x05,0x14,0x07, + 0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f, + 0x0c,0x00,0x0f,0x08}, + {0x00,0x00,0x00,0x00,0x00,0x10,0x0e,0x00, + 0xff} + }, + /* Mode12/ExtEGATable */ + { + 0xe3, + {0x01,0x0f,0x00,0x06}, + {0x5f,0x4f,0x50,0x82,0x55,0x81,0x0b,0x3e, + 0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00, + 0xe9,0x8b,0xdf,0x28,0x00,0xe7,0x04,0xe3, + 0xff}, + {0x00,0x01,0x02,0x03,0x04,0x05,0x14,0x07, + 0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f, + 0x01,0x00,0x0f,0x00}, + {0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x0f, + 0xff} + }, + /* ExtVGATable */ + { + 0x2f, + {0x01,0x0f,0x00,0x0e}, + {0x5f,0x4f,0x50,0x82,0x54,0x80,0x0b,0x3e, + 0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00, + 0xea,0x8c,0xdf,0x28,0x40,0xe7,0x04,0xa3, + 0xff}, + {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, + 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f, + 0x01,0x00,0x00,0x00}, + {0x00,0x00,0x00,0x00,0x00,0x40,0x05,0x0f, + 0xff} + }, + /* ExtHiCTable */ + { + 0x2f, + {0x01,0x0f,0x00,0x0e}, + {0x5f,0x4f,0x50,0x82,0x54,0x80,0x0b,0x3e, + 0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00, + 0xea,0x8c,0xdf,0x28,0x40,0xe7,0x04,0xa3, + 0xff}, + {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, + 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f, + 0x01,0x00,0x00,0x00}, + {0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x0f, + 0xff} + }, + /* ExtTrueCTable */ + { + 0x2f, + {0x01,0x0f,0x00,0x0e}, + {0x5f,0x4f,0x50,0x82,0x54,0x80,0x0b,0x3e, + 0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00, + 0xea,0x8c,0xdf,0x28,0x40,0xe7,0x04,0xa3, + 0xff}, + {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, + 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f, + 0x01,0x00,0x00,0x00}, + {0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x0f, + 0xff} + }, +}; + +VBIOS_ENHTABLE_STRUCT Res640x480Table[] = { + { 800, 640, 8, 96, 525, 480, 2, 2, VCLK28_322, /* 60Hz */ + (SyncNN | HBorder | VBorder | Charx8Dot), 60, 1, 0x2E }, + { 832, 640, 16, 40, 520, 480, 1, 3, VCLK31_5, /* 72Hz */ + (SyncNN | HBorder | VBorder | Charx8Dot), 72, 2, 0x2E }, + { 840, 640, 16, 64, 500, 480, 1, 3, VCLK31_5, /* 75Hz */ + (SyncNN | Charx8Dot) , 75, 3, 0x2E }, + { 832, 640, 56, 56, 509, 480, 1, 3, VCLK36, /* 85Hz */ + (SyncNN | Charx8Dot) , 85, 4, 0x2E }, + { 832, 640, 56, 56, 509, 480, 1, 3, VCLK36, /* end */ + (SyncNN | Charx8Dot) , 0xFF, 4, 0x2E }, +}; + + +VBIOS_ENHTABLE_STRUCT Res800x600Table[] = { + {1024, 800, 24, 72, 625, 600, 1, 2, VCLK36, /* 56Hz */ + (SyncPP | Charx8Dot), 56, 1, 0x30 }, + {1056, 800, 40, 128, 628, 600, 1, 4, VCLK40, /* 60Hz */ + (SyncPP | Charx8Dot), 60, 2, 0x30 }, + {1040, 800, 56, 120, 666, 600, 37, 6, VCLK50, /* 72Hz */ + (SyncPP | Charx8Dot), 72, 3, 0x30 }, + {1056, 800, 16, 80, 625, 600, 1, 3, VCLK49_5, /* 75Hz */ + (SyncPP | Charx8Dot), 75, 4, 0x30 }, + {1048, 800, 32, 64, 631, 600, 1, 3, VCLK56_25, /* 85Hz */ + (SyncPP | Charx8Dot), 85, 5, 0x30 }, + {1048, 800, 32, 64, 631, 600, 1, 3, VCLK56_25, /* end */ + (SyncPP | Charx8Dot), 0xFF, 5, 0x30 }, +}; + + +VBIOS_ENHTABLE_STRUCT Res1024x768Table[] = { + {1344, 1024, 24, 136, 806, 768, 3, 6, VCLK65, /* 60Hz */ + (SyncNN | Charx8Dot), 60, 1, 0x31 }, + {1328, 1024, 24, 136, 806, 768, 3, 6, VCLK75, /* 70Hz */ + (SyncNN | Charx8Dot), 70, 2, 0x31 }, + {1312, 1024, 16, 96, 800, 768, 1, 3, VCLK78_75, /* 75Hz */ + (SyncPP | Charx8Dot), 75, 3, 0x31 }, + {1376, 1024, 48, 96, 808, 768, 1, 3, VCLK94_5, /* 85Hz */ + (SyncPP | Charx8Dot), 85, 4, 0x31 }, + {1376, 1024, 48, 96, 808, 768, 1, 3, VCLK94_5, /* end */ + (SyncPP | Charx8Dot), 0xFF, 4, 0x31 }, +}; + +VBIOS_ENHTABLE_STRUCT Res1280x1024Table[] = { + {1688, 1280, 48, 112, 1066, 1024, 1, 3, VCLK108, /* 60Hz */ + (SyncPP | Charx8Dot), 60, 1, 0x32 }, + {1688, 1280, 16, 144, 1066, 1024, 1, 3, VCLK135, /* 75Hz */ + (SyncPP | Charx8Dot), 75, 2, 0x32 }, + {1728, 1280, 64, 160, 1072, 1024, 1, 3, VCLK157_5, /* 85Hz */ + (SyncPP | Charx8Dot), 85, 3, 0x32 }, + {1728, 1280, 64, 160, 1072, 1024, 1, 3, VCLK157_5, /* end */ + (SyncPP | Charx8Dot), 0xFF, 3, 0x32 }, +}; + +VBIOS_ENHTABLE_STRUCT Res1600x1200Table[] = { + {2160, 1600, 64, 192, 1250, 1200, 1, 3, VCLK162, /* 60Hz */ + (SyncPP | Charx8Dot), 60, 1, 0x33 }, + {2160, 1600, 64, 192, 1250, 1200, 1, 3, VCLK162, /* end */ + (SyncPP | Charx8Dot), 60, 1, 0x33 }, +}; + +VBIOS_DCLK_INFO DCLKTable [] = { + {0x2C, 0xE7, 0x03}, /* 00: VCLK25_175 */ + {0x95, 0x62, 0x03}, /* 01: VCLK28_322 */ + {0x67, 0x63, 0x01}, /* 02: VCLK31_5 */ + {0x76, 0x63, 0x01}, /* 03: VCLK36 */ + {0xEE, 0x67, 0x01}, /* 04: VCLK40 */ + {0x82, 0x62, 0x01}, /* 05: VCLK49_5 */ + {0xC6, 0x64, 0x01}, /* 06: VCLK50 */ + {0x94, 0x62, 0x01}, /* 07: VCLK56_25 */ + {0x80, 0x64, 0x00}, /* 08: VCLK65 */ + {0x7B, 0x63, 0x00}, /* 09: VCLK75 */ + {0x67, 0x62, 0x00}, /* 0A: VCLK78_75 */ + {0x7C, 0x62, 0x00}, /* 0B: VCLK94_5 */ + {0x8E, 0x62, 0x00}, /* 0C: VCLK108 */ + {0x85, 0x24, 0x00}, /* 0D: VCLK135 */ + {0x67, 0x22, 0x00}, /* 0E: VCLK157_5 */ + {0x6A, 0x22, 0x00}, /* 0F: VCLK162 */ +}; + +VBIOS_DAC_INFO DAC_TEXT[] = { + { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x2a }, { 0x00, 0x2a, 0x00 }, { 0x00, 0x2a, 0x2a }, + { 0x2a, 0x00, 0x00 }, { 0x2a, 0x00, 0x2a }, { 0x2a, 0x2a, 0x00 }, { 0x2a, 0x2a, 0x2a }, + { 0x00, 0x00, 0x15 }, { 0x00, 0x00, 0x3f }, { 0x00, 0x2a, 0x15 }, { 0x00, 0x2a, 0x3f }, + { 0x2a, 0x00, 0x15 }, { 0x2a, 0x00, 0x3f }, { 0x2a, 0x2a, 0x15 }, { 0x2a, 0x2a, 0x3f }, + { 0x00, 0x15, 0x00 }, { 0x00, 0x15, 0x2a }, { 0x00, 0x3f, 0x00 }, { 0x00, 0x3f, 0x2a }, + { 0x2a, 0x15, 0x00 }, { 0x2a, 0x15, 0x2a }, { 0x2a, 0x3f, 0x00 }, { 0x2a, 0x3f, 0x2a }, + { 0x00, 0x15, 0x15 }, { 0x00, 0x15, 0x3f }, { 0x00, 0x3f, 0x15 }, { 0x00, 0x3f, 0x3f }, + { 0x2a, 0x15, 0x15 }, { 0x2a, 0x15, 0x3f }, { 0x2a, 0x3f, 0x15 }, { 0x2a, 0x3f, 0x3f }, + { 0x15, 0x00, 0x00 }, { 0x15, 0x00, 0x2a }, { 0x15, 0x2a, 0x00 }, { 0x15, 0x2a, 0x2a }, + { 0x3f, 0x00, 0x00 }, { 0x3f, 0x00, 0x2a }, { 0x3f, 0x2a, 0x00 }, { 0x3f, 0x2a, 0x2a }, + { 0x15, 0x00, 0x15 }, { 0x15, 0x00, 0x3f }, { 0x15, 0x2a, 0x15 }, { 0x15, 0x2a, 0x3f }, + { 0x3f, 0x00, 0x15 }, { 0x3f, 0x00, 0x3f }, { 0x3f, 0x2a, 0x15 }, { 0x3f, 0x2a, 0x3f }, + { 0x15, 0x15, 0x00 }, { 0x15, 0x15, 0x2a }, { 0x15, 0x3f, 0x00 }, { 0x15, 0x3f, 0x2a }, + { 0x3f, 0x15, 0x00 }, { 0x3f, 0x15, 0x2a }, { 0x3f, 0x3f, 0x00 }, { 0x3f, 0x3f, 0x2a }, + { 0x15, 0x15, 0x15 }, { 0x15, 0x15, 0x3f }, { 0x15, 0x3f, 0x15 }, { 0x15, 0x3f, 0x3f }, + { 0x3f, 0x15, 0x15 }, { 0x3f, 0x15, 0x3f }, { 0x3f, 0x3f, 0x15 }, { 0x3f, 0x3f, 0x3f }, +}; + +VBIOS_DAC_INFO DAC_EGA[] = { + { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x2a }, { 0x00, 0x2a, 0x00 }, { 0x00, 0x2a, 0x2a }, + { 0x2a, 0x00, 0x00 }, { 0x2a, 0x00, 0x2a }, { 0x2a, 0x2a, 0x00 }, { 0x2a, 0x2a, 0x2a }, + { 0x00, 0x00, 0x15 }, { 0x00, 0x00, 0x3f }, { 0x00, 0x2a, 0x15 }, { 0x00, 0x2a, 0x3f }, + { 0x2a, 0x00, 0x15 }, { 0x2a, 0x00, 0x3f }, { 0x2a, 0x2a, 0x15 }, { 0x2a, 0x2a, 0x3f }, + { 0x00, 0x15, 0x00 }, { 0x00, 0x15, 0x2a }, { 0x00, 0x3f, 0x00 }, { 0x00, 0x3f, 0x2a }, + { 0x2a, 0x15, 0x00 }, { 0x2a, 0x15, 0x2a }, { 0x2a, 0x3f, 0x00 }, { 0x2a, 0x3f, 0x2a }, + { 0x00, 0x15, 0x15 }, { 0x00, 0x15, 0x3f }, { 0x00, 0x3f, 0x15 }, { 0x00, 0x3f, 0x3f }, + { 0x2a, 0x15, 0x15 }, { 0x2a, 0x15, 0x3f }, { 0x2a, 0x3f, 0x15 }, { 0x2a, 0x3f, 0x3f }, + { 0x15, 0x00, 0x00 }, { 0x15, 0x00, 0x2a }, { 0x15, 0x2a, 0x00 }, { 0x15, 0x2a, 0x2a }, + { 0x3f, 0x00, 0x00 }, { 0x3f, 0x00, 0x2a }, { 0x3f, 0x2a, 0x00 }, { 0x3f, 0x2a, 0x2a }, + { 0x15, 0x00, 0x15 }, { 0x15, 0x00, 0x3f }, { 0x15, 0x2a, 0x15 }, { 0x15, 0x2a, 0x3f }, + { 0x3f, 0x00, 0x15 }, { 0x3f, 0x00, 0x3f }, { 0x3f, 0x2a, 0x15 }, { 0x3f, 0x2a, 0x3f }, + { 0x15, 0x15, 0x00 }, { 0x15, 0x15, 0x2a }, { 0x15, 0x3f, 0x00 }, { 0x15, 0x3f, 0x2a }, + { 0x3f, 0x15, 0x00 }, { 0x3f, 0x15, 0x2a }, { 0x3f, 0x3f, 0x00 }, { 0x3f, 0x3f, 0x2a }, + { 0x15, 0x15, 0x15 }, { 0x15, 0x15, 0x3f }, { 0x15, 0x3f, 0x15 }, { 0x15, 0x3f, 0x3f }, + { 0x3f, 0x15, 0x15 }, { 0x3f, 0x15, 0x3f }, { 0x3f, 0x3f, 0x15 }, { 0x3f, 0x3f, 0x3f }, +}; + +VBIOS_DAC_INFO DAC_VGA[] = { + { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x2a }, { 0x00, 0x2a, 0x00 }, { 0x00, 0x2a, 0x2a }, + { 0x2a, 0x00, 0x00 }, { 0x2a, 0x00, 0x2a }, { 0x2a, 0x15, 0x00 }, { 0x2a, 0x2a, 0x2a }, + { 0x15, 0x15, 0x15 }, { 0x15, 0x15, 0x3f }, { 0x15, 0x3f, 0x15 }, { 0x15, 0x3f, 0x3f }, + { 0x3f, 0x15, 0x15 }, { 0x3f, 0x15, 0x3f }, { 0x3f, 0x3f, 0x15 }, { 0x3f, 0x3f, 0x3f }, + { 0x00, 0x00, 0x00 }, { 0x05, 0x05, 0x05 }, { 0x08, 0x08, 0x08 }, { 0x0b, 0x0b, 0x0b }, + { 0x0e, 0x0e, 0x0e }, { 0x11, 0x11, 0x11 }, { 0x14, 0x14, 0x14 }, { 0x18, 0x18, 0x18 }, + { 0x1c, 0x1c, 0x1c }, { 0x20, 0x20, 0x20 }, { 0x24, 0x24, 0x24 }, { 0x28, 0x28, 0x28 }, + { 0x2d, 0x2d, 0x2d }, { 0x32, 0x32, 0x32 }, { 0x38, 0x38, 0x38 }, { 0x3f, 0x3f, 0x3f }, + { 0x00, 0x00, 0x3f }, { 0x10, 0x00, 0x3f }, { 0x1f, 0x00, 0x3f }, { 0x2f, 0x00, 0x3f }, + { 0x3f, 0x00, 0x3f }, { 0x3f, 0x00, 0x2f }, { 0x3f, 0x00, 0x1f }, { 0x3f, 0x00, 0x10 }, + { 0x3f, 0x00, 0x00 }, { 0x3f, 0x10, 0x00 }, { 0x3f, 0x1f, 0x00 }, { 0x3f, 0x2f, 0x00 }, + { 0x3f, 0x3f, 0x00 }, { 0x2f, 0x3f, 0x00 }, { 0x1f, 0x3f, 0x00 }, { 0x10, 0x3f, 0x00 }, + { 0x00, 0x3f, 0x00 }, { 0x00, 0x3f, 0x10 }, { 0x00, 0x3f, 0x1f }, { 0x00, 0x3f, 0x2f }, + { 0x00, 0x3f, 0x3f }, { 0x00, 0x2f, 0x3f }, { 0x00, 0x1f, 0x3f }, { 0x00, 0x10, 0x3f }, + { 0x1f, 0x1f, 0x3f }, { 0x27, 0x1f, 0x3f }, { 0x2f, 0x1f, 0x3f }, { 0x37, 0x1f, 0x3f }, + { 0x3f, 0x1f, 0x3f }, { 0x3f, 0x1f, 0x37 }, { 0x3f, 0x1f, 0x2f }, { 0x3f, 0x1f, 0x27 }, + { 0x3f, 0x1f, 0x1f }, { 0x3f, 0x27, 0x1f }, { 0x3f, 0x2f, 0x1f }, { 0x3f, 0x37, 0x1f }, + { 0x3f, 0x3f, 0x1f }, { 0x37, 0x3f, 0x1f }, { 0x2f, 0x3f, 0x1f }, { 0x27, 0x3f, 0x1f }, + { 0x1f, 0x3f, 0x1f }, { 0x1f, 0x3f, 0x27 }, { 0x1f, 0x3f, 0x2f }, { 0x1f, 0x3f, 0x37 }, + { 0x1f, 0x3f, 0x3f }, { 0x1f, 0x37, 0x3f }, { 0x1f, 0x2f, 0x3f }, { 0x1f, 0x27, 0x3f }, + { 0x2d, 0x2d, 0x3f }, { 0x31, 0x2d, 0x3f }, { 0x36, 0x2d, 0x3f }, { 0x3a, 0x2d, 0x3f }, + { 0x3f, 0x2d, 0x3f }, { 0x3f, 0x2d, 0x3a }, { 0x3f, 0x2d, 0x36 }, { 0x3f, 0x2d, 0x31 }, + { 0x3f, 0x2d, 0x2d }, { 0x3f, 0x31, 0x2d }, { 0x3f, 0x36, 0x2d }, { 0x3f, 0x3a, 0x2d }, + { 0x3f, 0x3f, 0x2d }, { 0x3a, 0x3f, 0x2d }, { 0x36, 0x3f, 0x2d }, { 0x31, 0x3f, 0x2d }, + { 0x2d, 0x3f, 0x2d }, { 0x2d, 0x3f, 0x31 }, { 0x2d, 0x3f, 0x36 }, { 0x2d, 0x3f, 0x3a }, + { 0x2d, 0x3f, 0x3f }, { 0x2d, 0x3a, 0x3f }, { 0x2d, 0x36, 0x3f }, { 0x2d, 0x31, 0x3f }, + { 0x00, 0x00, 0x1c }, { 0x07, 0x00, 0x1c }, { 0x0e, 0x00, 0x1c }, { 0x15, 0x00, 0x1c }, + { 0x1c, 0x00, 0x1c }, { 0x1c, 0x00, 0x15 }, { 0x1c, 0x00, 0x0e }, { 0x1c, 0x00, 0x07 }, + { 0x1c, 0x00, 0x00 }, { 0x1c, 0x07, 0x00 }, { 0x1c, 0x0e, 0x00 }, { 0x1c, 0x15, 0x00 }, + { 0x1c, 0x1c, 0x00 }, { 0x15, 0x1c, 0x00 }, { 0x0e, 0x1c, 0x00 }, { 0x07, 0x1c, 0x00 }, + { 0x00, 0x1c, 0x00 }, { 0x00, 0x1c, 0x07 }, { 0x00, 0x1c, 0x0e }, { 0x00, 0x1c, 0x15 }, + { 0x00, 0x1c, 0x1c }, { 0x00, 0x15, 0x1c }, { 0x00, 0x0e, 0x1c }, { 0x00, 0x07, 0x1c }, + { 0x0e, 0x0e, 0x1c }, { 0x11, 0x0e, 0x1c }, { 0x15, 0x0e, 0x1c }, { 0x18, 0x0e, 0x1c }, + { 0x1c, 0x0e, 0x1c }, { 0x1c, 0x0e, 0x18 }, { 0x1c, 0x0e, 0x15 }, { 0x1c, 0x0e, 0x11 }, + { 0x1c, 0x0e, 0x0e }, { 0x1c, 0x11, 0x0e }, { 0x1c, 0x15, 0x0e }, { 0x1c, 0x18, 0x0e }, + { 0x1c, 0x1c, 0x0e }, { 0x18, 0x1c, 0x0e }, { 0x15, 0x1c, 0x0e }, { 0x11, 0x1c, 0x0e }, + { 0x0e, 0x1c, 0x0e }, { 0x0e, 0x1c, 0x11 }, { 0x0e, 0x1c, 0x15 }, { 0x0e, 0x1c, 0x18 }, + { 0x0e, 0x1c, 0x1c }, { 0x0e, 0x18, 0x1c }, { 0x0e, 0x15, 0x1c }, { 0x0e, 0x11, 0x1c }, + { 0x14, 0x14, 0x1c }, { 0x16, 0x14, 0x1c }, { 0x18, 0x14, 0x1c }, { 0x1a, 0x14, 0x1c }, + { 0x1c, 0x14, 0x1c }, { 0x1c, 0x14, 0x1a }, { 0x1c, 0x14, 0x18 }, { 0x1c, 0x14, 0x16 }, + { 0x1c, 0x14, 0x14 }, { 0x1c, 0x16, 0x14 }, { 0x1c, 0x18, 0x14 }, { 0x1c, 0x1a, 0x14 }, + { 0x1c, 0x1c, 0x14 }, { 0x1a, 0x1c, 0x14 }, { 0x18, 0x1c, 0x14 }, { 0x16, 0x1c, 0x14 }, + { 0x14, 0x1c, 0x14 }, { 0x14, 0x1c, 0x16 }, { 0x14, 0x1c, 0x18 }, { 0x14, 0x1c, 0x1a }, + { 0x14, 0x1c, 0x1c }, { 0x14, 0x1a, 0x1c }, { 0x14, 0x18, 0x1c }, { 0x14, 0x16, 0x1c }, + { 0x00, 0x00, 0x10 }, { 0x04, 0x00, 0x10 }, { 0x08, 0x00, 0x10 }, { 0x0c, 0x00, 0x10 }, + { 0x10, 0x00, 0x10 }, { 0x10, 0x00, 0x0c }, { 0x10, 0x00, 0x08 }, { 0x10, 0x00, 0x04 }, + { 0x10, 0x00, 0x00 }, { 0x10, 0x04, 0x00 }, { 0x10, 0x08, 0x00 }, { 0x10, 0x0c, 0x00 }, + { 0x10, 0x10, 0x00 }, { 0x0c, 0x10, 0x00 }, { 0x08, 0x10, 0x00 }, { 0x04, 0x10, 0x00 }, + { 0x00, 0x10, 0x00 }, { 0x00, 0x10, 0x04 }, { 0x00, 0x10, 0x08 }, { 0x00, 0x10, 0x0c }, + { 0x00, 0x10, 0x10 }, { 0x00, 0x0c, 0x10 }, { 0x00, 0x08, 0x10 }, { 0x00, 0x04, 0x10 }, + { 0x08, 0x08, 0x10 }, { 0x0a, 0x08, 0x10 }, { 0x0c, 0x08, 0x10 }, { 0x0e, 0x08, 0x10 }, + { 0x10, 0x08, 0x10 }, { 0x10, 0x08, 0x0e }, { 0x10, 0x08, 0x0c }, { 0x10, 0x08, 0x0a }, + { 0x10, 0x08, 0x08 }, { 0x10, 0x0a, 0x08 }, { 0x10, 0x0c, 0x08 }, { 0x10, 0x0e, 0x08 }, + { 0x10, 0x10, 0x08 }, { 0x0e, 0x10, 0x08 }, { 0x0c, 0x10, 0x08 }, { 0x0a, 0x10, 0x08 }, + { 0x08, 0x10, 0x08 }, { 0x08, 0x10, 0x0a }, { 0x08, 0x10, 0x0c }, { 0x08, 0x10, 0x0e }, + { 0x08, 0x10, 0x10 }, { 0x08, 0x0e, 0x10 }, { 0x08, 0x0c, 0x10 }, { 0x08, 0x0a, 0x10 }, + { 0x0b, 0x0b, 0x10 }, { 0x0c, 0x0b, 0x10 }, { 0x0d, 0x0b, 0x10 }, { 0x0f, 0x0b, 0x10 }, + { 0x10, 0x0b, 0x10 }, { 0x10, 0x0b, 0x0f }, { 0x10, 0x0b, 0x0d }, { 0x10, 0x0b, 0x0c }, + { 0x10, 0x0b, 0x0b }, { 0x10, 0x0c, 0x0b }, { 0x10, 0x0d, 0x0b }, { 0x10, 0x0f, 0x0b }, + { 0x10, 0x10, 0x0b }, { 0x0f, 0x10, 0x0b }, { 0x0d, 0x10, 0x0b }, { 0x0c, 0x10, 0x0b }, + { 0x0b, 0x10, 0x0b }, { 0x0b, 0x10, 0x0c }, { 0x0b, 0x10, 0x0d }, { 0x0b, 0x10, 0x0f }, + { 0x0b, 0x10, 0x10 }, { 0x0b, 0x0f, 0x10 }, { 0x0b, 0x0d, 0x10 }, { 0x0b, 0x0c, 0x10 }, + { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x00 }, + { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x00 }, +}; + +/* extern. function */ +extern void vASTOpenKey(ScrnInfoPtr pScrn); +extern Bool bASTRegInit(ScrnInfoPtr pScrn); +extern void vAST1000DisplayOn(ASTRecPtr pAST); +extern void vAST1000DisplayOff(ASTRecPtr pAST); + +extern Bool bEnable2D(ScrnInfoPtr pScrn, ASTRecPtr pAST); +extern void vDisable2D(ScrnInfoPtr pScrn, ASTRecPtr pAST); + +extern Bool bInitHWC(ScrnInfoPtr pScrn, ASTRecPtr pAST); + +/* Prototype type declaration*/ +Bool ASTSetMode(ScrnInfoPtr pScrn, DisplayModePtr mode); +Bool bGetAST1000VGAModeInfo(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo); +void vSetStdReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo); +void vSetCRTCReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo); +void vSetOffsetReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo); +void vSetDCLKReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo); +void vSetExtReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo); +Bool bSetDACReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo); + +Bool +ASTSetMode(ScrnInfoPtr pScrn, DisplayModePtr mode) +{ + ASTRecPtr pAST; + VBIOS_MODE_INFO vgamodeinfo; + + pAST = ASTPTR(pScrn); + + vASTOpenKey(pScrn); + bASTRegInit(pScrn); + + /* pre set mode */ + bGetAST1000VGAModeInfo(pScrn, mode, &vgamodeinfo); + + /* set mode */ + vSetStdReg(pScrn, mode, &vgamodeinfo); + vSetCRTCReg(pScrn, mode, &vgamodeinfo); + vSetOffsetReg(pScrn, mode, &vgamodeinfo); + vSetDCLKReg(pScrn, mode, &vgamodeinfo); + vSetExtReg(pScrn, mode, &vgamodeinfo); + bSetDACReg(pScrn, mode, &vgamodeinfo); + + /* post set mode */ +#ifdef Accel_2D + if (!pAST->noAccel) { + if (!bEnable2D(pScrn, pAST)) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR,"Enable 2D failed\n"); + pAST->noAccel = TRUE; + } + } +#endif +#ifdef HWC + if (!pAST->noHWC) { + if (!bInitHWC(pScrn, pAST)) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR,"Init HWC failed\n"); + pAST->noHWC = TRUE; + } + } +#endif + vAST1000DisplayOn(pAST); + + return (TRUE); +} + + +Bool bGetAST1000VGAModeInfo(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo) +{ + ASTRecPtr pAST; + ULONG ulModeID, ulColorIndex, ulRefreshRate, ulRefreshRateIndex = 0; + ULONG ulHBorder, ulVBorder; + + pAST = ASTPTR(pScrn); + + switch (pScrn->bitsPerPixel) + { + case 8: + pVGAModeInfo->pStdTableEntry = (PVBIOS_STDTABLE_STRUCT) &StdTable[VGAModeIndex]; + ulColorIndex = VGAModeIndex-1; + break; + case 16: + pVGAModeInfo->pStdTableEntry = (PVBIOS_STDTABLE_STRUCT) &StdTable[HiCModeIndex]; + ulColorIndex = HiCModeIndex-1; + break; + case 24: + case 32: + pVGAModeInfo->pStdTableEntry = (PVBIOS_STDTABLE_STRUCT) &StdTable[TrueCModeIndex]; + ulColorIndex = TrueCModeIndex-1; + break; + default: + return (FALSE); + } + + switch (mode->CrtcHDisplay) + { + case 640: + pVGAModeInfo->pEnhTableEntry = (PVBIOS_ENHTABLE_STRUCT) &Res640x480Table[ulRefreshRateIndex]; + break; + case 800: + pVGAModeInfo->pEnhTableEntry = (PVBIOS_ENHTABLE_STRUCT) &Res800x600Table[ulRefreshRateIndex]; + break; + case 1024: + pVGAModeInfo->pEnhTableEntry = (PVBIOS_ENHTABLE_STRUCT) &Res1024x768Table[ulRefreshRateIndex]; + break; + case 1280: + pVGAModeInfo->pEnhTableEntry = (PVBIOS_ENHTABLE_STRUCT) &Res1280x1024Table[ulRefreshRateIndex]; + break; + case 1600: + pVGAModeInfo->pEnhTableEntry = (PVBIOS_ENHTABLE_STRUCT) &Res1600x1200Table[ulRefreshRateIndex]; + break; + default: + return (FALSE); + } + + /* Get Proper Mode Index */ + ulRefreshRate = (mode->Clock * 1000) / (mode->HTotal * mode->VTotal); + + while (pVGAModeInfo->pEnhTableEntry->ulRefreshRate < ulRefreshRate) + { + pVGAModeInfo->pEnhTableEntry++; + if ((pVGAModeInfo->pEnhTableEntry->ulRefreshRate > ulRefreshRate) || + (pVGAModeInfo->pEnhTableEntry->ulRefreshRate == 0xFF)) + { + pVGAModeInfo->pEnhTableEntry--; + break; + } + } + + /* Update mode CRTC info */ + ulHBorder = (pVGAModeInfo->pEnhTableEntry->Flags & HBorder) ? 1:0; + ulVBorder = (pVGAModeInfo->pEnhTableEntry->Flags & VBorder) ? 1:0; + + mode->CrtcHTotal = (int) pVGAModeInfo->pEnhTableEntry->HT; + mode->CrtcHBlankStart = (int) (pVGAModeInfo->pEnhTableEntry->HDE + ulHBorder); + mode->CrtcHBlankEnd = (int) (pVGAModeInfo->pEnhTableEntry->HT - ulHBorder); + mode->CrtcHSyncStart = (int) (pVGAModeInfo->pEnhTableEntry->HDE + ulHBorder + + pVGAModeInfo->pEnhTableEntry->HFP); + mode->CrtcHSyncEnd = (int) (pVGAModeInfo->pEnhTableEntry->HDE + ulHBorder + + pVGAModeInfo->pEnhTableEntry->HFP + + pVGAModeInfo->pEnhTableEntry->HSYNC); + + mode->CrtcVTotal = (int) pVGAModeInfo->pEnhTableEntry->VT; + mode->CrtcVBlankStart = (int) (pVGAModeInfo->pEnhTableEntry->VDE + ulVBorder); + mode->CrtcVBlankEnd = (int) (pVGAModeInfo->pEnhTableEntry->VT - ulVBorder); + mode->CrtcVSyncStart = (int) (pVGAModeInfo->pEnhTableEntry->VDE + ulVBorder + + pVGAModeInfo->pEnhTableEntry->VFP); + mode->CrtcVSyncEnd = (int) (pVGAModeInfo->pEnhTableEntry->VDE + ulVBorder + + pVGAModeInfo->pEnhTableEntry->VFP + + pVGAModeInfo->pEnhTableEntry->VSYNC); + + /* Write mode info to scratch */ + ulRefreshRateIndex = pVGAModeInfo->pEnhTableEntry->ulRefreshRateIndex; + ulModeID = pVGAModeInfo->pEnhTableEntry->ulModeID; + + SetIndexReg(CRTC_PORT, 0x8C, (UCHAR) ((ulColorIndex & 0x0F) << 4)); + SetIndexReg(CRTC_PORT, 0x8D, (UCHAR) (ulRefreshRateIndex & 0xFF)); + SetIndexReg(CRTC_PORT, 0x8E, (UCHAR) (ulModeID & 0xFF)); + + return (TRUE); +} + +void vSetStdReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo) +{ + + PVBIOS_STDTABLE_STRUCT pStdModePtr; + ASTRecPtr pAST; + ULONG i; + UCHAR jReg; + + pStdModePtr = pVGAModeInfo->pStdTableEntry; + pAST = ASTPTR(pScrn); + + /* Set Misc */ + jReg = pStdModePtr->MISC; + SetReg(MISC_PORT_WRITE,jReg); + + /* Set Seq */ + SetIndexReg(SEQ_PORT,0x00, 0x03); + for (i=0; i<4; i++) + { + jReg = pStdModePtr->SEQ[i]; + if (!i) (jReg |= 0x20); /* display off */ + SetIndexReg(SEQ_PORT,(UCHAR) (i+1), jReg); + } + + /* Set CRTC */ + SetIndexRegMask(CRTC_PORT,0x11, 0x7F, 0x00); + for (i=0; i<25; i++) + { + jReg = pStdModePtr->CRTC[i]; + SetIndexReg(CRTC_PORT,(UCHAR) i, jReg); + } + + /* Set AR */ + jReg = GetReg(INPUT_STATUS1_READ); + for (i=0; i<20; i++) + { + jReg = pStdModePtr->AR[i]; + SetReg(AR_PORT_WRITE, (UCHAR) i); + SetReg(AR_PORT_WRITE, jReg); + } + SetReg(AR_PORT_WRITE, 0x14); + SetReg(AR_PORT_WRITE, 0x00); + + jReg = GetReg(INPUT_STATUS1_READ); + SetReg (AR_PORT_WRITE, 0x20); /* set POS */ + + /* Set GR */ + for (i=0; i<9; i++) + { + SetIndexReg(GR_PORT,(UCHAR) i, jReg); + + } + + +} + +void +vSetCRTCReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo) +{ + ASTRecPtr pAST; + USHORT usTemp; + UCHAR jReg05, jReg07, jReg09, jRegAC, jRegAD, jRegAE; + + pAST = ASTPTR(pScrn); + jReg05 = jReg07 = jReg09 = jRegAC = jRegAD = jRegAE = 0; + + /* unlock CRTC */ + SetIndexRegMask(CRTC_PORT,0x11, 0x7F, 0x00); + + /* Horizontal Timing Programming */ + usTemp = (mode->CrtcHTotal >> 3) - 5; + if (usTemp & 0x100) jRegAC |= 0x01; /* HT D[8] */ + SetIndexRegMask(CRTC_PORT,0x00, 0x00, (UCHAR) usTemp); + usTemp = (mode->CrtcHDisplay >> 3) - 1; + if (usTemp & 0x100) jRegAC |= 0x04; /* HDE D[8] */ + SetIndexRegMask(CRTC_PORT,0x01, 0x00, (UCHAR) usTemp); + usTemp = (mode->CrtcHBlankStart >> 3) - 1; + if (usTemp & 0x100) jRegAC |= 0x10; /* HBS D[8] */ + SetIndexRegMask(CRTC_PORT,0x02, 0x00, (UCHAR) usTemp); + usTemp = ((mode->CrtcHBlankEnd >> 3) - 1) & 0x7F; + if (usTemp & 0x20) jReg05 |= 0x80; /* HBE D[5] */ + if (usTemp & 0x40) jRegAD |= 0x01; /* HBE D[6] */ + SetIndexRegMask(CRTC_PORT,0x03, 0xE0, (UCHAR) (usTemp & 0x1F)); + usTemp = (mode->CrtcHSyncStart >> 3 ); + if (usTemp & 0x100) jRegAC |= 0x40; /* HRS D[5] */ + SetIndexRegMask(CRTC_PORT,0x04, 0x00, (UCHAR) (usTemp)); + usTemp = (mode->CrtcHSyncEnd >> 3 ) & 0x3F; + if (usTemp & 0x20) jRegAD |= 0x04; /* HRE D[5] */ + SetIndexRegMask(CRTC_PORT,0x05, 0x60, (UCHAR) ((usTemp & 0x1F) | jReg05)); + + SetIndexRegMask(CRTC_PORT,0xAC, 0x00, (UCHAR) jRegAC); + SetIndexRegMask(CRTC_PORT,0xAD, 0x00, (UCHAR) jRegAD); + + /* Vetical Timing Programming */ + usTemp = (mode->CrtcVTotal) - 2; + if (usTemp & 0x100) jReg07 |= 0x01; /* VT D[8] */ + if (usTemp & 0x200) jReg07 |= 0x20; + if (usTemp & 0x400) jRegAE |= 0x01; /* VT D[10] */ + SetIndexRegMask(CRTC_PORT,0x06, 0x00, (UCHAR) usTemp); + usTemp = (mode->CrtcVSyncStart) - 1; + if (usTemp & 0x100) jReg07 |= 0x04; /* VRS D[8] */ + if (usTemp & 0x200) jReg07 |= 0x80; /* VRS D[9] */ + if (usTemp & 0x400) jRegAE |= 0x08; /* VRS D[10] */ + SetIndexRegMask(CRTC_PORT,0x10, 0x00, (UCHAR) usTemp); + usTemp = ((mode->CrtcVSyncEnd) - 1) & 0x3F; + if (usTemp & 0x10) jRegAE |= 0x20; /* VRE D[4] */ + if (usTemp & 0x20) jRegAE |= 0x40; /* VRE D[5] */ + SetIndexRegMask(CRTC_PORT,0x11, 0x70, (UCHAR) (usTemp & 0x0F)); + usTemp = (mode->CrtcVDisplay) - 1; + if (usTemp & 0x100) jReg07 |= 0x02; /* VDE D[8] */ + if (usTemp & 0x200) jReg07 |= 0x40; /* VDE D[9] */ + if (usTemp & 0x400) jRegAE |= 0x02; /* VDE D[10] */ + SetIndexRegMask(CRTC_PORT,0x12, 0x00, (UCHAR) usTemp); + usTemp = (mode->CrtcVBlankStart) - 1; + if (usTemp & 0x100) jReg07 |= 0x08; /* VBS D[8] */ + if (usTemp & 0x200) jReg09 |= 0x20; /* VBS D[9] */ + if (usTemp & 0x400) jRegAE |= 0x04; /* VBS D[10] */ + SetIndexRegMask(CRTC_PORT,0x15, 0x00, (UCHAR) usTemp); + usTemp = (mode->CrtcVBlankEnd) - 1 ; + if (usTemp & 0x100) jRegAE |= 0x10; /* VBE D[8] */ + SetIndexRegMask(CRTC_PORT,0x16, 0x00, (UCHAR) usTemp); + + SetIndexRegMask(CRTC_PORT,0x07, 0x00, (UCHAR) jReg07); + SetIndexRegMask(CRTC_PORT,0x09, 0xDF, (UCHAR) jReg09); + SetIndexRegMask(CRTC_PORT,0xAE, 0x00, (UCHAR) (jRegAE | 0x80)); /* disable line compare */ + + /* lock CRTC */ + SetIndexRegMask(CRTC_PORT,0x11, 0x7F, 0x80); + +} + +void vSetOffsetReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo) +{ + ASTRecPtr pAST; + USHORT usOffset; + + pAST = ASTPTR(pScrn); + + usOffset = pAST->VideoModeInfo.ScreenPitch >> 3; /* Unit: char */ + + SetIndexReg(CRTC_PORT,0x13, (UCHAR) (usOffset & 0xFF)); + SetIndexReg(CRTC_PORT,0xB0, (UCHAR) ((usOffset >> 8) & 0x3F)); + +} + +void vSetDCLKReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo) +{ + PVBIOS_ENHTABLE_STRUCT pEnhModePtr; + PVBIOS_DCLK_INFO pDCLKPtr; + ASTRecPtr pAST; + + pAST = ASTPTR(pScrn); + + pEnhModePtr = pVGAModeInfo->pEnhTableEntry; + pDCLKPtr = &DCLKTable[pEnhModePtr->DCLKIndex]; + + SetIndexRegMask(CRTC_PORT,0xC0, 0x00, pDCLKPtr->Param1); + SetIndexRegMask(CRTC_PORT,0xC1, 0x00, pDCLKPtr->Param2); + SetIndexRegMask(CRTC_PORT,0xBB, 0xCF, ((pDCLKPtr->Param3 & 0x03) << 4)); + +} + + +void vSetExtReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo) +{ + + ASTRecPtr pAST; + UCHAR jRegA0, jRegA3, jRegA8; + + pAST = ASTPTR(pScrn); + + jRegA0=jRegA3=jRegA8=0; + /* Mode Type Setting */ + switch (pScrn->bitsPerPixel) { + case 8: + jRegA0 = 0x70; + jRegA3 = 0x01; + jRegA8 = 0x00; + break; + case 15: + case 16: + jRegA0 = 0x70; + jRegA3 = 0x04; + jRegA8 = 0x02; + break; + case 32: + jRegA0 = 0x70; + jRegA3 = 0x08; + jRegA8 = 0x02; + break; + } + SetIndexRegMask(CRTC_PORT,0xA0, 0x8F, (UCHAR) jRegA0); + SetIndexRegMask(CRTC_PORT,0xA3, 0xF0, (UCHAR) jRegA3); + SetIndexRegMask(CRTC_PORT,0xA8, 0xFD, (UCHAR) jRegA8); + + /* Set Threshold */ + SetIndexReg(CRTC_PORT,0xA7, 0x2F); + SetIndexReg(CRTC_PORT,0xA6, 0x1F); + +} + + +Bool bSetDACReg(ScrnInfoPtr pScrn, DisplayModePtr mode, PVBIOS_MODE_INFO pVGAModeInfo) +{ + PVBIOS_DAC_INFO pDACPtr; + ASTRecPtr pAST; + ULONG i, ulDACNumber; + UCHAR DACR, DACG, DACB; + + pAST = ASTPTR(pScrn); + + switch (pScrn->bitsPerPixel) + { + case 8: + ulDACNumber = DAC_NUM_VGA; + pDACPtr = (PVBIOS_DAC_INFO) &DAC_VGA[0]; + break; + default: + return (FALSE); + } + + for (i=0; iDACR; + DACG = pDACPtr->DACG; + DACB = pDACPtr->DACB; + + VGA_LOAD_PALETTE_INDEX (i, DACR, DACG, DACB); + + pDACPtr++; + } + + return (TRUE); + +} + + diff --git a/src/ast_mode.h b/src/ast_mode.h new file mode 100644 index 0000000..0a8e20c --- /dev/null +++ b/src/ast_mode.h @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/* Mode Limitation */ +#define MAX_HResolution 1600 +#define MAX_VResolution 1200 + +/* Std. Table Index Definition */ +#define TextModeIndex 0 +#define EGAModeIndex 1 +#define VGAModeIndex 2 +#define HiCModeIndex 3 +#define TrueCModeIndex 4 + +/* DCLK Index */ +#define VCLK25_175 0x00 +#define VCLK28_322 0x01 +#define VCLK31_5 0x02 +#define VCLK36 0x03 +#define VCLK40 0x04 +#define VCLK49_5 0x05 +#define VCLK50 0x06 +#define VCLK56_25 0x07 +#define VCLK65 0x08 +#define VCLK75 0x09 +#define VCLK78_75 0x0A +#define VCLK94_5 0x0B +#define VCLK108 0x0C +#define VCLK135 0x0D +#define VCLK157_5 0x0E +#define VCLK162 0x0F + +/* Flags Definition */ +#define Charx8Dot 0x00000001 +#define HalfDCLK 0x00000002 +#define DoubleScanMode 0x00000004 +#define LineCompareOff 0x00000008 +#define SyncPP 0x00000000 +#define SyncPN 0x00000040 +#define SyncNP 0x00000080 +#define SyncNN 0x000000C0 +#define HBorder 0x00000020 +#define VBorder 0x00000010 + +/* DAC Definition */ +#define DAC_NUM_TEXT 64 +#define DAC_NUM_EGA 64 +#define DAC_NUM_VGA 256 + +/* Data Structure decalration for internal use */ +typedef struct { + + UCHAR MISC; + UCHAR SEQ[4]; + UCHAR CRTC[25]; + UCHAR AR[20]; + UCHAR GR[9]; + +} VBIOS_STDTABLE_STRUCT, *PVBIOS_STDTABLE_STRUCT; + +typedef struct { + + ULONG HT; + ULONG HDE; + ULONG HFP; + ULONG HSYNC; + ULONG VT; + ULONG VDE; + ULONG VFP; + ULONG VSYNC; + ULONG DCLKIndex; + ULONG Flags; + + ULONG ulRefreshRate; + ULONG ulRefreshRateIndex; + ULONG ulModeID; + +} VBIOS_ENHTABLE_STRUCT, *PVBIOS_ENHTABLE_STRUCT; + +typedef struct { + UCHAR Param1; + UCHAR Param2; + UCHAR Param3; +} VBIOS_DCLK_INFO, *PVBIOS_DCLK_INFO; + +typedef struct { + UCHAR DACR; + UCHAR DACG; + UCHAR DACB; +} VBIOS_DAC_INFO, *PVBIOS_DAC_INFO; + +typedef struct { + PVBIOS_STDTABLE_STRUCT pStdTableEntry; + PVBIOS_ENHTABLE_STRUCT pEnhTableEntry; + +} VBIOS_MODE_INFO, *PVBIOS_MODE_INFO; diff --git a/src/ast_tool.c b/src/ast_tool.c new file mode 100644 index 0000000..61e9861 --- /dev/null +++ b/src/ast_tool.c @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xf86.h" +#include "xf86_ansic.h" +#include "xf86_OSproc.h" +#include "xf86Resources.h" +#include "xf86RAC.h" +#include "xf86cmap.h" +#include "compiler.h" +#include "mibstore.h" +#include "vgaHW.h" +#include "mipointer.h" +#include "micmap.h" + +#include "fb.h" +#include "regionstr.h" +#include "xf86xv.h" +#include "Xv.h" +#include "vbe.h" + +#include "xf86PciInfo.h" +#include "xf86Pci.h" + +/* framebuffer offscreen manager */ +#include "xf86fbman.h" + +/* include xaa includes */ +#include "xaa.h" +#include "xaarop.h" + +/* H/W cursor support */ +#include "xf86Cursor.h" + +/* Driver specific headers */ +#include "ast.h" + +/* Prototype type declaration*/ +Bool ASTMapMem(ScrnInfoPtr pScrn); +Bool ASTUnmapMem(ScrnInfoPtr pScrn); +Bool ASTMapMMIO(ScrnInfoPtr pScrn); +void ASTUnmapMMIO(ScrnInfoPtr pScrn); + +Bool +ASTMapMem(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + + + pAST->FBVirtualAddr = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_FRAMEBUFFER, + pAST->PciTag, + pAST->FBPhysAddr, pAST->FbMapSize); + + if (!pAST->FBVirtualAddr) + return FALSE; + + return TRUE; +} + +Bool +ASTUnmapMem(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + + xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pAST->FBVirtualAddr, + pAST->FbMapSize); + + pAST->FBVirtualAddr = 0; + + return TRUE; +} + +Bool +ASTMapMMIO(ScrnInfoPtr pScrn) +{ + int mmioFlags; + ASTRecPtr pAST = ASTPTR(pScrn); + +#if !defined(__alpha__) + mmioFlags = VIDMEM_MMIO | VIDMEM_READSIDEEFFECT; +#else + mmioFlags = VIDMEM_MMIO | VIDMEM_READSIDEEFFECT | VIDMEM_SPARSE; +#endif + + pAST->MMIOVirtualAddr = xf86MapPciMem(pScrn->scrnIndex, mmioFlags, + pAST->PciTag, + pAST->MMIOPhysAddr, pAST->MMIOMapSize); + if (!pAST->MMIOVirtualAddr) + return FALSE; + + return TRUE; +} + +void +ASTUnmapMMIO(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + + xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pAST->MMIOVirtualAddr, + pAST->MMIOMapSize); + pAST->MMIOVirtualAddr = 0; + +} + + diff --git a/src/ast_vgatool.c b/src/ast_vgatool.c new file mode 100644 index 0000000..92013c9 --- /dev/null +++ b/src/ast_vgatool.c @@ -0,0 +1,240 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xf86.h" +#include "xf86_ansic.h" +#include "xf86_OSproc.h" +#include "xf86Resources.h" +#include "xf86RAC.h" +#include "xf86cmap.h" +#include "compiler.h" +#include "mibstore.h" +#include "vgaHW.h" +#include "mipointer.h" +#include "micmap.h" + +#include "fb.h" +#include "regionstr.h" +#include "xf86xv.h" +#include "Xv.h" +#include "vbe.h" + +#include "xf86PciInfo.h" +#include "xf86Pci.h" + +/* framebuffer offscreen manager */ +#include "xf86fbman.h" + +/* include xaa includes */ +#include "xaa.h" +#include "xaarop.h" + +/* H/W cursor support */ +#include "xf86Cursor.h" + +/* Driver specific headers */ +#include "ast.h" + +/* Prototype type declaration*/ +void vASTOpenKey(ScrnInfoPtr pScrn); +Bool bASTRegInit(ScrnInfoPtr pScrn); +ULONG GetVRAMInfo(ScrnInfoPtr pScrn); +void vAST1000DisplayOn(ASTRecPtr pAST); +void vAST1000DisplayOff(ASTRecPtr pAST); +void vSetStartAddressCRT1(ASTRecPtr pAST, ULONG base); +void vASTLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices, LOCO *colors, VisualPtr pVisual); +void ASTDisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags); + +void +vASTOpenKey(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + + SetIndexReg(CRTC_PORT,0x80, 0xA8); + +} + +Bool +bASTRegInit(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + + /* Enable MMIO */ + SetIndexRegMask(CRTC_PORT,0xA1, 0xFF, 0x04); + + return (TRUE); + +} + +ULONG +GetVRAMInfo(ScrnInfoPtr pScrn) +{ + ASTRecPtr pAST = ASTPTR(pScrn); + UCHAR jReg; + + GetIndexRegMask(CRTC_PORT, 0xAA, 0xFF, jReg); + + switch (jReg & 0x03) + { + case 0x00: + return (VIDEOMEM_SIZE_08M); + case 0x01: + return (VIDEOMEM_SIZE_16M); + case 0x02: + return (VIDEOMEM_SIZE_32M); + case 0x03: + return (VIDEOMEM_SIZE_64M); + } + + return (DEFAULT_VIDEOMEM_SIZE); + +} + + +void +vSetStartAddressCRT1(ASTRecPtr pAST, ULONG base) +{ + SetIndexReg(CRTC_PORT,0x0D, (UCHAR) (base & 0xFF)); + SetIndexReg(CRTC_PORT,0x0C, (UCHAR) ((base >> 8) & 0xFF)); + SetIndexReg(CRTC_PORT,0xAF, (UCHAR) ((base >> 16) & 0xFF)); + +} + +void +vAST1000DisplayOff(ASTRecPtr pAST) +{ + SetIndexRegMask(SEQ_PORT,0x01, 0xDF, 0x20); + +} + + +void +vAST1000DisplayOn(ASTRecPtr pAST) +{ + + SetIndexRegMask(SEQ_PORT,0x01, 0xDF, 0x00); + +} + + +void +vASTLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices, LOCO *colors, + VisualPtr pVisual) +{ + + ASTRecPtr pAST = ASTPTR(pScrn); + int i, j, index; + UCHAR DACIndex, DACR, DACG, DACB; + + switch (pScrn->bitsPerPixel) { + case 15: + for(i=0; irgbBits); + DACG = colors[index].green << (8- pScrn->rgbBits); + DACB = colors[index].blue << (8- pScrn->rgbBits); + + VGA_LOAD_PALETTE_INDEX (DACIndex, DACR, DACG, DACB); + } + } + break; + + case 16: + for(i=0; irgbBits); + DACG = colors[index].green << (8- pScrn->rgbBits); + DACB = colors[index/2].blue << (8- pScrn->rgbBits); + + VGA_LOAD_PALETTE_INDEX (DACIndex, DACR, DACG, DACB); + } + } + break; + + case 24: + for(i=0; i> (8 - pScrn->rgbBits); + DACG = colors[index].green >> (8 - pScrn->rgbBits); + DACB = colors[index].blue >> (8 - pScrn->rgbBits); + + VGA_LOAD_PALETTE_INDEX (DACIndex, DACR, DACG, DACB); + } + + } /* end of switch */ + +} /* end of vASTLoadPalette */ + +void +ASTDisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags) +{ + ASTRecPtr pAST; + UCHAR SEQ01, CRB6; + + pAST = ASTPTR(pScrn); + SEQ01=CRB6=0; + + switch (PowerManagementMode) { + case DPMSModeOn: + /* Screen: On; HSync: On, VSync: On */ + SEQ01 = 0x00; + CRB6 = 0x00; + break; + case DPMSModeStandby: + /* Screen: Off; HSync: Off, VSync: On */ + SEQ01 = 0x20; + CRB6 = 0x01; + break; + case DPMSModeSuspend: + /* Screen: Off; HSync: On, VSync: Off */ + SEQ01 = 0x20; + CRB6 = 0x02; + break; + case DPMSModeOff: + /* Screen: Off; HSync: Off, VSync: Off */ + SEQ01 = 0x20; + CRB6 = 0x03; + break; + } + + SetIndexRegMask(SEQ_PORT,0x01, 0xDF, SEQ01); + SetIndexRegMask(CRTC_PORT,0xB6, 0xFC, CRB6); + + +} diff --git a/src/ast_vgatool.h b/src/ast_vgatool.h new file mode 100644 index 0000000..8a4f683 --- /dev/null +++ b/src/ast_vgatool.h @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2005 ASPEED Technology Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the authors not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/* VRAM Size Definition */ +#define VIDEOMEM_SIZE_08M 0x00800000 +#define VIDEOMEM_SIZE_16M 0x01000000 +#define VIDEOMEM_SIZE_32M 0x02000000 +#define VIDEOMEM_SIZE_64M 0x04000000 + +#define AR_PORT_WRITE (pAST->RelocateIO + 0x40) +#define MISC_PORT_WRITE (pAST->RelocateIO + 0x42) +#define SEQ_PORT (pAST->RelocateIO + 0x44) +#define DAC_INDEX_WRITE (pAST->RelocateIO + 0x48) +#define DAC_DATA (pAST->RelocateIO + 0x49) +#define GR_PORT (pAST->RelocateIO + 0x4E) +#define CRTC_PORT (pAST->RelocateIO + 0x54) +#define INPUT_STATUS1_READ (pAST->RelocateIO + 0x5A) + +#define GetReg(base) inb(base) +#define SetReg(base,val) outb(base,val) +#define GetIndexReg(base,index,val) do { \ + outb(base,index); \ + val = inb(base+1); \ + } while (0) +#define SetIndexReg(base,index, val) do { \ + outb(base,index); \ + outb(base+1,val); \ + } while (0) +#define GetIndexRegMask(base,index, and, val) do { \ + outb(base,index); \ + val = (inb(base+1) & and); \ + } while (0) +#define SetIndexRegMask(base,index, and, val) do { \ + UCHAR __Temp; \ + outb(base,index); \ + __Temp = (inb((base)+1)&(and))|(val); \ + SetIndexReg(base,index,__Temp); \ + } while (0) + +#define VGA_LOAD_PALETTE_INDEX(index, red, green, blue) \ +{ \ + UCHAR __junk; \ + SetReg(DAC_INDEX_WRITE,(UCHAR)(index)); \ + __junk = GetReg(SEQ_PORT); \ + SetReg(DAC_DATA,(UCHAR)(red)); \ + __junk = GetReg(SEQ_PORT); \ + SetReg(DAC_DATA,(UCHAR)(green)); \ + __junk = GetReg(SEQ_PORT); \ + SetReg(DAC_DATA,(UCHAR)(blue)); \ + __junk = GetReg(SEQ_PORT); \ +} -- cgit v1.2.3