/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/nsc/nsc_gx2_driver.c,v 1.9tsi Exp $ */ /* * $Workfile: nsc_gx2_driver.c $ * $Revision: 1.2 $ * $Author: mrg $ * * File Contents: This is the main module configures the interfacing * with the X server. The individual modules will be * loaded based upon the options selected from the * XF86Config. This file also has modules for finding * supported modes, turning on the modes based on options. * * Project: Geode Xfree Frame buffer device driver. * */ /* * NSC_LIC_ALTERNATIVE_PREAMBLE * * Revision 1.0 * * National Semiconductor Alternative GPL-BSD License * * National Semiconductor Corporation licenses this software * ("Software"): * * National Xfree frame buffer driver * * under one of the two following licenses, depending on how the * Software is received by the Licensee. * * If this Software is received as part of the Linux Framebuffer or * other GPL licensed software, then the GPL license designated * NSC_LIC_GPL applies to this Software; in all other circumstances * then the BSD-style license designated NSC_LIC_BSD shall apply. * * END_NSC_LIC_ALTERNATIVE_PREAMBLE */ /* NSC_LIC_BSD * * National Semiconductor Corporation Open Source License for * * National Xfree frame buffer driver * * (BSD License with Export Notice) * * Copyright (c) 1999-2001 * National Semiconductor Corporation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * * Neither the name of the National Semiconductor Corporation nor * the names of its contributors may be used to endorse or promote * products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * NATIONAL SEMICONDUCTOR CORPORATION OR CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE, * INTELLECTUAL PROPERTY INFRINGEMENT, OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. * * EXPORT LAWS: THIS LICENSE ADDS NO RESTRICTIONS TO THE EXPORT LAWS OF * YOUR JURISDICTION. It is licensee's responsibility to comply with * any export regulations applicable in licensee's jurisdiction. Under * CURRENT (2001) U.S. export regulations this software * is eligible for export from the U.S. and can be downloaded by or * otherwise exported or reexported worldwide EXCEPT to U.S. embargoed * destinations which include Cuba, Iraq, Libya, North Korea, Iran, * Syria, Sudan, Afghanistan and any other country to which the U.S. * has embargoed goods and services. * * END_NSC_LIC_BSD */ /* NSC_LIC_GPL * * National Semiconductor Corporation Gnu General Public License for * * National Xfree frame buffer driver * * (GPL License with Export Notice) * * Copyright (c) 1999-2001 * National Semiconductor Corporation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted under the terms of the GNU General * Public License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version * * In addition to the terms of the GNU General Public License, neither * the name of the National Semiconductor Corporation nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * NATIONAL SEMICONDUCTOR CORPORATION OR CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE, * INTELLECTUAL PROPERTY INFRINGEMENT, OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. See the GNU General Public License for more details. * * EXPORT LAWS: THIS LICENSE ADDS NO RESTRICTIONS TO THE EXPORT LAWS OF * YOUR JURISDICTION. It is licensee's responsibility to comply with * any export regulations applicable in licensee's jurisdiction. Under * CURRENT (2001) U.S. export regulations this software * is eligible for export from the U.S. and can be downloaded by or * otherwise exported or reexported worldwide EXCEPT to U.S. embargoed * destinations which include Cuba, Iraq, Libya, North Korea, Iran, * Syria, Sudan, Afghanistan and any other country to which the U.S. * has embargoed goods and services. * * You should have received a copy of the GNU General Public License * along with this file; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * END_NSC_LIC_GPL */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #define DEBUG(x) #define GEODE_TRACE 0 /* Includes that are used by all drivers */ #include "xf86.h" #include "xf86_OSproc.h" #include "xf86Resources.h" /* We may want inb() and outb() */ #include "compiler.h" /* We may want to access the PCI config space */ #include "xf86PciInfo.h" #include "xf86Pci.h" #define INT10_SUPPORT 1 /* Colormap handling stuff */ #include "xf86cmap.h" #define RC_MAX_DEPTH 24 /* Frame buffer stuff */ #include "fb.h" #include "shadowfb.h" /* Machine independent stuff */ #include "mipointer.h" #include "mibank.h" #include "micmap.h" #include "vgaHW.h" #include "vbe.h" /* Check for some extensions */ #ifdef XFreeXDGA #define _XF86_DGA_SERVER_ #include #endif /* XFreeXDGA */ #include "globals.h" #include "opaque.h" #define DPMS_SERVER #include /* Our private include file (this also includes the durango headers) */ #include "nsc.h" #if !defined(STB_X) #include "nsc_gx2_vga.c" #endif /* STB_X */ #if GEODE_TRACE /* ANSI C does not allow var arg macros */ #define GeodeDebug(args) DebugPort(DCount++);ErrorF args #else #define GeodeDebug(args) #endif extern SymTabRec GeodeChipsets[]; extern PciChipsets GeodePCIchipsets[]; extern OptionInfoRec GeodeOptions[]; /* Forward definitions */ static Bool GX2PreInit(ScrnInfoPtr, int); static Bool GX2ScreenInit(int, ScreenPtr, int, char **); static Bool GX2EnterVT(int, int); static void GX2LeaveVT(int, int); static void GX2FreeScreen(int, int); void GX2AdjustFrame(int, int, int, int); Bool GX2SwitchMode(int, DisplayModePtr, int); static ModeStatus GX2ValidMode(int, DisplayModePtr, Bool, int); static void GX2LoadPalette(ScrnInfoPtr pScreenInfo, int numColors, int *indizes, LOCO * colors, VisualPtr pVisual); static Bool GX2MapMem(ScrnInfoPtr); static Bool GX2UnmapMem(ScrnInfoPtr); static void gx2_set_DvLineSize(unsigned int pitch); extern Bool GX2AccelInit(ScreenPtr pScreen); extern Bool GX2HWCursorInit(ScreenPtr pScreen); extern void GX2HideCursor(ScrnInfoPtr pScreenInfo); extern void GX2ShowCursor(ScrnInfoPtr pScreenInfo); extern void GX2PointerMoved(int index, int x, int y); extern void GX2RefreshArea(ScrnInfoPtr pScrn, int num, BoxPtr pbox); extern void GX2RefreshArea8(ScrnInfoPtr pScrn, int num, BoxPtr pbox); extern void GX2RefreshArea16(ScrnInfoPtr pScrn, int num, BoxPtr pbox); extern void GX2RefreshArea24(ScrnInfoPtr pScrn, int num, BoxPtr pbox); extern void GX2RefreshArea32(ScrnInfoPtr pScrn, int num, BoxPtr pbox); extern void GX2InitVideo(ScreenPtr pScreen); extern Bool GX2DGAInit(ScreenPtr pScreen); extern void GX2LoadCursorImage(ScrnInfoPtr pScreenInfo, unsigned char *src); #if !defined(STB_X) extern unsigned char *XpressROMPtr; #endif /* STB_X */ /* Existing Processor Models */ #define GX1 0x1 #define GX2 0x2 #define GX2_CRT 0x6 #define GX2_TFT 0xA /* List of symbols from other modules that this module references.The purpose * is that to avoid unresolved symbol warnings */ extern const char *nscVgahwSymbols[]; extern const char *nscVbeSymbols[]; extern const char *nscInt10Symbols[]; extern const char *nscFbSymbols[]; extern const char *nscXaaSymbols[]; extern const char *nscRamdacSymbols[]; extern const char *nscShadowSymbols[]; void GX2SetupChipsetFPtr(ScrnInfoPtr pScrn); GeodePtr GX2GetRec(ScrnInfoPtr pScreenInfo); void get_flatpanel_info(const char *options, int *W, int *H, int *D, int *C, int *T); void gx2_clear_screen(int width, int height); void EnableDACPower(void); void redcloud_gfx_2_vga_fix(void); void GX2SetupChipsetFPtr(ScrnInfoPtr pScrn) { GeodeDebug(("GX2SetupChipsetFPtr!\n")); pScrn->PreInit = GX2PreInit; pScrn->ScreenInit = GX2ScreenInit; pScrn->SwitchMode = GX2SwitchMode; pScrn->AdjustFrame = GX2AdjustFrame; pScrn->EnterVT = GX2EnterVT; pScrn->LeaveVT = GX2LeaveVT; pScrn->FreeScreen = GX2FreeScreen; pScrn->ValidMode = GX2ValidMode; } /*---------------------------------------------------------------------------- * GX2GetRec. * * Description :This function allocate an GeodeRec and hooked into * pScreenInfo str driverPrivate member of ScreeenInfo * structure. * Parameters. * pScreenInfo :Pointer handle to the screenonfo structure. * * Returns :allocated pScreeninfo structure. * * Comments :none * *---------------------------------------------------------------------------- */ GeodePtr GX2GetRec(ScrnInfoPtr pScreenInfo) { if (!pScreenInfo->driverPrivate) { GeodePtr pGeode; pGeode = pScreenInfo->driverPrivate = xnfcalloc(sizeof(GeodeRec), 1); #if INT10_SUPPORT pGeode->vesa = xcalloc(sizeof(VESARec), 1); #endif } return GEODEPTR(pScreenInfo); } /*---------------------------------------------------------------------------- * GX2FreeRec. * * Description :This function deallocate an GeodeRec and freed from * pScreenInfo str driverPrivate member of ScreeenInfo * structure. * Parameters. * pScreenInfo :Pointer handle to the screenonfo structure. * * Returns :none * * Comments :none * *---------------------------------------------------------------------------- */ static void GX2FreeRec(ScrnInfoPtr pScreenInfo) { if (pScreenInfo->driverPrivate == NULL) { return; } xfree(pScreenInfo->driverPrivate); pScreenInfo->driverPrivate = NULL; } /*---------------------------------------------------------------------------- * GX2SaveScreen. * * Description :This is todo the screen blanking * * Parameters. * pScreen :Handle to ScreenPtr structure. * mode :mode is used by vgaHWSaveScren to check blnak os on. * * Returns :TRUE on success and FALSE on failure. * * Comments :none *---------------------------------------------------------------------------- */ static Bool GX2SaveScreen(ScreenPtr pScreen, int mode) { #if !defined(STB_X) ScrnInfoPtr pScreenInfo = xf86Screens[pScreen->myNum]; GeodeDebug(("GX2SaveScreen!\n")); if (!pScreenInfo->vtSema) return vgaHWSaveScreen(pScreen, mode); #endif /* STB_X */ return TRUE; } /*---------------------------------------------------------------------------- * get_flatpanel_info. * * Description :This gets the values of the flatpanel attached. * * Parameters: * options : Pointer to the display options. * W: Pointer to the width of the panel * H: Pointer to the height of the panel * D: Pointer to the depth of the panel. * C: Pointer to the color of the panel. * T: Pointer to the type of the panel. * Returns : none. * * Comments :none *------------------------------------------------------------------------ */ void get_flatpanel_info(const char *options, int *W, int *H, int *D, int *C, int *T) { char *pnl_opt; pnl_opt = strtok((char *)options, ":"); *W = strtoul(pnl_opt, NULL, 0); pnl_opt = strtok(NULL, ":"); *H = strtoul(pnl_opt, NULL, 0); pnl_opt = strtok(NULL, ":"); *D = strtoul(pnl_opt, NULL, 0); pnl_opt = strtok(NULL, ":"); *C = strtoul(pnl_opt, NULL, 0); pnl_opt = strtok(NULL, ":"); *T = strtoul(pnl_opt, NULL, 0); *C = (*C) ? PNL_COLOR_PANEL : PNL_MONO_PANEL; switch (*T) { case 0: *T = PNL_SSTN; break; case 1: *T = PNL_DSTN; break; case 2: default: *T = PNL_TFT; break; } if ((*W != 640) && (*W != 800) && (*W != 1024)) *W = 640; if ((*H != 480) && (*H != 600) && (*H != 768)) *H = 480; } static void GX2ProbeDDC(ScrnInfoPtr pScrn, int index) { vbeInfoPtr pVbe; if (xf86LoadSubModule(pScrn, "vbe")) { pVbe = VBEInit(NULL, index); ConfiguredMonitor = vbeDoEDID(pVbe, NULL); vbeFree(pVbe); } } /*---------------------------------------------------------------------------- * GX2PreInit. * * Description :This function is called only once ate teh server startup * * Parameters. * pScreenInfo :Handle to ScreenPtr structure. * flags :flags may be used to check the probeed one with config. * * Returns :TRUE on success and FALSE on failure. * * Comments :none. *---------------------------------------------------------------------------- */ static Bool GX2PreInit(ScrnInfoPtr pScreenInfo, int flags) { static ClockRange GeodeClockRange = { NULL, 25175, 229500, 0, FALSE, TRUE, 1, 1, 0 }; MessageType from; int i = 0; GeodePtr pGeode; #if defined(STB_X) GAL_ADAPTERINFO sAdapterInfo; #endif /* STB_X */ unsigned int PitchInc = 0, minPitch = 0, maxPitch = 0; unsigned int minHeight = 0, maxHeight = 0; unsigned int SupportFlags; const char *s; char **modes; #if INT10_SUPPORT VESAPtr pVesa; #endif DCount = 10; GeodeDebug(("GX2PreInit!\n")); /* Allocate driver private structure */ if (!(pGeode = GX2GetRec(pScreenInfo))) return FALSE; /* This is the general case */ for (i = 0; i < pScreenInfo->numEntities; i++) { pGeode->pEnt = xf86GetEntityInfo(pScreenInfo->entityList[i]); if (pGeode->pEnt->resources) return FALSE; pGeode->Chipset = pGeode->pEnt->chipset; pScreenInfo->chipset = (char *)xf86TokenToString(GeodeChipsets, pGeode->pEnt->chipset); } if (flags & PROBE_DETECT) { GX2ProbeDDC(pScreenInfo, pGeode->pEnt->index); return TRUE; } #if INT10_SUPPORT if (!xf86LoadSubModule(pScreenInfo, "int10")) return FALSE; xf86LoaderReqSymLists(nscInt10Symbols, NULL); #endif pGeode->FBVGAActive = 0; /* KFB will Knock of VGA */ #if !defined(STB_X) /* If the vgahw module would be needed it would be loaded here */ if (!xf86LoadSubModule(pScreenInfo, "vgahw")) { return FALSE; } xf86LoaderReqSymLists(nscVgahwSymbols, NULL); #endif /* STB_X */ GeodeDebug(("GX2PreInit(1)!\n")); /* Do the durango hardware detection */ #if defined(STB_X) if (!Gal_initialize_interface()) { GeodeDebug(("GALintialize fail GX2PreInit(1.00)!\n")); return FALSE; } if (Gal_get_adapter_info(&sAdapterInfo)) { pGeode->cpu_version = sAdapterInfo.dwCPUVersion; /* find the base chipset core. Currently there can be only one * chip active at any time. */ if ((pGeode->cpu_version & 0xFF) == GFX_CPU_REDCLOUD) { if (sAdapterInfo.dwCPUType) pGeode->DetectedChipSet = GX2_TFT; else pGeode->DetectedChipSet = GX2_CRT; } DEBUGMSG(1, (0, X_NONE, "Detected BaseChip %d, %d\n", pGeode->DetectedChipSet, sAdapterInfo.dwCPUType)); pGeode->vid_version = sAdapterInfo.dwVideoVersion; pGeode->FBSize = sAdapterInfo.dwFrameBufferSize; /* update the max clock from the one system suports */ GeodeClockRange.maxClock = sAdapterInfo.dwMaxSupportedPixelClock; pGeode->FBLinearAddr = sAdapterInfo.dwFrameBufferBase; #if 0 pGeode->FBBase = (unsigned char *)xf86MapVidMem(pScreenInfo->scrnIndex, VIDMEM_FRAMEBUFFER, pGeode->FBLinearAddr, pGeode->FBSize); #endif if (!GX2MapMem(pScreenInfo)) return FALSE; DEBUGMSG(1, (0, X_NONE, "CPU=%x vid %x FB %x FBAdd %X\n", pGeode->cpu_version, pGeode->vid_version, pGeode->FBSize, pGeode->FBLinearAddr)); } else { return FALSE; } #else /* STB */ pGeode->cpu_version = gfx_detect_cpu(); /* find the base chipset core. Currently there can be only one * chip active at any time. */ /* pGeode->DetectedChipSet = GX1; */ if ((pGeode->cpu_version & 0xFF) == GFX_CPU_REDCLOUD) pGeode->DetectedChipSet = GX2; GeodeDebug(("Detected BaseChip (%d)\n", pGeode->DetectedChipSet)); { Q_WORD msrValue; /* GX2 : Can have CRT or TFT only */ gfx_msr_read(RC_ID_DF, MBD_MSR_CONFIG, &msrValue); pGeode->DetectedChipSet = ((msrValue.low & RCDF_CONFIG_FMT_MASK) == RCDF_CONFIG_FMT_FP) ? GX2_TFT : GX2_CRT; GeodeDebug(("Gx2 for %s\n", ((pGeode->DetectedChipSet == GX2_TFT) ? "TFT" : "CRT"))); } GeodeDebug(("GX2PreInit(1.1)!\n")); pGeode->vid_version = gfx_detect_video(); GeodeDebug(("GX2PreInit(1.2)!\n")); pGeode->FBLinearAddr = gfx_get_frame_buffer_base(); GeodeDebug(("GX2PreInit(1.3)!\n")); pGeode->FBSize = gfx_get_frame_buffer_size(); GeodeDebug(("GX2PreInit(1.4)!\n")); /* update the max clock from the one system suports */ GeodeClockRange.maxClock = gfx_get_max_supported_pixel_clock(); GeodeDebug(("GX2PreInit(1.5)!\n")); /* SET DURANGO REGISTER POINTERS * * The method of mapping from a physical address to a linear address * * is operating system independent. Set variables to linear address. */ if (pGeode->DetectedChipSet & GX2) { pGeode->cpu_reg_size = 0x4000; pGeode->gp_reg_size = 0x4000; pGeode->vid_reg_size = 0x4000; } else { pGeode->cpu_reg_size = 0x9000; pGeode->vid_reg_size = 0x1000; } if (!GX2MapMem(pScreenInfo)) return FALSE; /* check if VGA is active */ /* This routine saves the current VGA state in Durango VGA structure */ /* check if VGA is active */ pGeode->FBVGAActive = gu2_get_vga_active(); #endif /* STB_X */ DEBUGMSG(1, (0, X_PROBED, "VGA = %d\n", pGeode->FBVGAActive)); /* Fill in the monitor field */ pScreenInfo->monitor = pScreenInfo->confScreen->monitor; GeodeDebug(("GX2PreInit(2)!\n")); SupportFlags = Support24bppFb | Support32bppFb; GeodeDebug(("GX2PreInit(2)!\n")); /* Determine depth, bpp, etc. */ if (!xf86SetDepthBpp(pScreenInfo, 0, 0, 0, SupportFlags)) { return FALSE; } else { if (!((pScreenInfo->depth == 8) || (pScreenInfo->depth == 16) || (pScreenInfo->depth == 24))) { /* Depth not supported */ DEBUGMSG(1, (pScreenInfo->scrnIndex, X_ERROR, "Given depth (%d bpp) is not supported by this driver\n", pScreenInfo->depth)); return FALSE; } } /*This must happen after pScreenInfo->display has been set * * because xf86SetWeight references it. */ if (pScreenInfo->depth > 8) { /* The defaults are OK for us */ rgb BitsPerComponent = { 0, 0, 0 }; rgb BitMask = { 0, 0, 0 }; if (pScreenInfo->depth > 16) { /* we are operating in 24 bpp, Readcloud */ BitsPerComponent.red = 8; BitsPerComponent.green = 8; BitsPerComponent.blue = 8; BitMask.red = 0xFF0000; BitMask.green = 0x00FF00; BitMask.blue = 0x0000FF; } if (!xf86SetWeight(pScreenInfo, BitsPerComponent, BitMask)) { return FALSE; } else { /* XXX Check if the returned weight is supported */ } } xf86PrintDepthBpp(pScreenInfo); GeodeDebug(("GX2PreInit(3)!\n")); if (!xf86SetDefaultVisual(pScreenInfo, -1)) return FALSE; GeodeDebug(("GX2PreInit(4)!\n")); /* The new cmap layer needs this to be initialized */ if (pScreenInfo->depth > 1) { Gamma zeros = { 0.0, 0.0, 0.0 }; if (!xf86SetGamma(pScreenInfo, zeros)) { return FALSE; } } GeodeDebug(("GX2PreInit(5)!\n")); /* We use a programmable clock */ pScreenInfo->progClock = TRUE; /*Collect all of the relevant option flags * *(fill in pScreenInfo->options) */ xf86CollectOptions(pScreenInfo, NULL); /*Process the options */ xf86ProcessOptions(pScreenInfo->scrnIndex, pScreenInfo->options, GeodeOptions); #if INT10_SUPPORT pVesa = pGeode->vesa; /* Initialize Vesa record */ if ((pVesa->pInt = xf86InitInt10(pGeode->pEnt->index)) == NULL) { xf86DrvMsg(0, X_ERROR, "Int10 initialization failed.\n"); return (FALSE); } #endif /*Set the bits per RGB for 8bpp mode */ if (pScreenInfo->depth == 8) { /* Default to 8 */ pScreenInfo->rgbBits = 8; } from = X_DEFAULT; /* * *The preferred method is to use the "hw cursor" option as a tri-state * *option, with the default set above. */ pGeode->HWCursor = TRUE; if (xf86GetOptValBool(GeodeOptions, OPTION_HW_CURSOR, &pGeode->HWCursor)) { from = X_CONFIG; } /* For compatibility, accept this too (as an override) */ if (xf86ReturnOptValBool(GeodeOptions, OPTION_SW_CURSOR, FALSE)) { from = X_CONFIG; pGeode->HWCursor = FALSE; } DEBUGMSG(1, (pScreenInfo->scrnIndex, from, "Using %s cursor\n", pGeode->HWCursor ? "HW" : "SW")); pGeode->Compression = TRUE; if (xf86ReturnOptValBool(GeodeOptions, OPTION_NOCOMPRESSION, FALSE)) { pGeode->Compression = FALSE; DEBUGMSG(1, (pScreenInfo->scrnIndex, X_CONFIG, "NoCompression\n")); } pGeode->NoAccel = FALSE; if (xf86ReturnOptValBool(GeodeOptions, OPTION_NOACCEL, FALSE)) { pGeode->NoAccel = TRUE; DEBUGMSG(1, (pScreenInfo->scrnIndex, X_CONFIG, "Acceleration \ disabled\n")); } if (!xf86GetOptValInteger(GeodeOptions, OPTION_OSM_IMG_BUFS, &(pGeode->NoOfImgBuffers))) pGeode->NoOfImgBuffers = DEFAULT_NUM_OF_BUF; /* default # of buffers */ if (pGeode->NoOfImgBuffers <= 0) pGeode->NoOfImgBuffers = 0; DEBUGMSG(1, (pScreenInfo->scrnIndex, X_CONFIG, "NoOfImgBuffers = %d\n", pGeode->NoOfImgBuffers)); pGeode->Panel = FALSE; if (xf86ReturnOptValBool(GeodeOptions, OPTION_FLATPANEL, FALSE)) { DEBUGMSG(0, (pScreenInfo->scrnIndex, X_CONFIG, "FlatPanel Selected\n")); pGeode->Panel = TRUE; } /* Force the Panel on if on a GX2 TFT part, no crt support */ if (pGeode->DetectedChipSet == GX2_TFT) { pGeode->Panel = TRUE; } /* If on a CRT and Panel flag set, disable Panel */ if ((pGeode->DetectedChipSet == GX2_CRT) && (pGeode->Panel)) pGeode->Panel = FALSE; DEBUGMSG(1, (pScreenInfo->scrnIndex, X_CONFIG, "Quering FP Bios %d\n", pGeode->Panel)); /* if FP not supported in BIOS, then turn off user option */ if (pGeode->Panel) { /* check if bios supports FP */ #if defined(STB_X) Gal_pnl_enabled_in_bios(&pGeode->Panel); Gal_pnl_info_from_bios(&pGeode->FPBX, &pGeode->FPBY, &pGeode->FPBB, &pGeode->FPBF); #else /* STB_X */ pGeode->Panel = Pnl_IsPanelEnabledInBIOS(); Pnl_GetPanelInfoFromBIOS(&pGeode->FPBX, &pGeode->FPBY, &pGeode->FPBB, &pGeode->FPBF); #endif /* STB_X */ } DEBUGMSG(1, (pScreenInfo->scrnIndex, X_CONFIG, "Quering FP Bios %d %d %d %d\n", pGeode->FPBX, pGeode->FPBY, pGeode->FPBB, pGeode->FPBF)); /* if panel not selected and Panel can be supported. * Power down the panel. */ if (!pGeode->Panel) { #if defined(STB_X) Gal_pnl_powerdown(); #else /* STB_X */ Pnl_PowerDown(); #endif /* STB_X */ } else { #if defined(STB_X) Gal_pnl_powerup(); #else Pnl_PowerUp(); #endif /* STB_X */ } pGeode->ShadowFB = FALSE; if (xf86ReturnOptValBool(GeodeOptions, OPTION_SHADOW_FB, FALSE)) { pGeode->ShadowFB = TRUE; pGeode->NoAccel = TRUE; DEBUGMSG(1, (pScreenInfo->scrnIndex, X_CONFIG, "Using \"Shadow Framebuffer\" - acceleration disabled\n")); } pGeode->Rotate = 0; if ((s = xf86GetOptValString(GeodeOptions, OPTION_ROTATE))) { DEBUGMSG(1, (pScreenInfo->scrnIndex, X_CONFIG, "Rotating - %s\n", s)); if (!xf86NameCmp(s, "CW")) { pGeode->ShadowFB = TRUE; pGeode->NoAccel = TRUE; pGeode->HWCursor = FALSE; pGeode->Rotate = 1; DEBUGMSG(1, (pScreenInfo->scrnIndex, X_CONFIG, "Rotating screen clockwise - acceleration disabled\n")); } else { if (!xf86NameCmp(s, "CCW")) { pGeode->ShadowFB = TRUE; pGeode->NoAccel = TRUE; pGeode->HWCursor = FALSE; pGeode->Rotate = -1; DEBUGMSG(1, (pScreenInfo->scrnIndex, X_CONFIG, "Rotating screen counter clockwise - acceleration \ disabled\n")); } else { DEBUGMSG(1, (pScreenInfo->scrnIndex, X_CONFIG, "\"%s\" is not a valid value for Option \"Rotate\"\n", s)); DEBUGMSG(1, (pScreenInfo->scrnIndex, X_INFO, "Valid options are \"CW\" or \"CCW\"\n")); } } } /* XXX Init further private data here */ /* * * This shouldn't happen because such problems should be caught in * * GeodeProbe(), but check it just in case. */ if (pScreenInfo->chipset == NULL) { DEBUGMSG(1, (pScreenInfo->scrnIndex, X_ERROR, "ChipID 0x%04X is not recognised\n", pGeode->Chipset)); return FALSE; } if (pGeode->Chipset < 0) { DEBUGMSG(1, (pScreenInfo->scrnIndex, X_ERROR, "Chipset \"%s\" is not recognised\n", pScreenInfo->chipset)); return FALSE; } GeodeDebug(("GX2PreInit(6)!\n")); /* * * Init the screen with some values */ #if !defined(STB_X) DEBUGMSG(1, (pScreenInfo->scrnIndex, from, "Video I/O registers at 0x%08lX\n", (unsigned long)VGAHW_GET_IOBASE())); #endif /* STB_X */ if (pScreenInfo->memPhysBase == 0) { from = X_PROBED; #if defined(STB_X) pScreenInfo->memPhysBase = sAdapterInfo.dwFrameBufferBase; #else /* STB_X */ pScreenInfo->memPhysBase = gfx_get_frame_buffer_base(); #endif /* STB_X */ } DEBUGMSG(1, (pScreenInfo->scrnIndex, from, "Linear framebuffer at 0x%08lX\n", (unsigned long)pScreenInfo->memPhysBase)); if (pGeode->pEnt->device->videoRam == 0) { from = X_PROBED; pScreenInfo->videoRam = pGeode->FBSize / 1024; } else { pScreenInfo->videoRam = pGeode->pEnt->device->videoRam; from = X_CONFIG; } DEBUGMSG(1, (pScreenInfo->scrnIndex, from, "VideoRam: %d kByte\n", (unsigned long)pScreenInfo->videoRam)); GeodeDebug(("GX2PreInit(7)!\n")); /* * * xf86ValidateModes will check that the mode HTotal and VTotal values * * don't exceed the chipset's limit if pScreenInfo->maxHValue adn * * pScreenInfo->maxVValue are set. Since our GX2ValidMode() * * already takes care of this, we don't worry about setting them here. */ /* Select valid modes from those available */ /* * * min pitch 1024, max 2048 (Pixel count) * * min height 480, max 1024 (Pixel count) */ minPitch = 1024; maxPitch = 4096; /* Can support upto 1600x1200 32Bpp */ minHeight = 480; maxHeight = 1200; /* Can support upto 1600x1200 32Bpp */ if (pScreenInfo->depth > 16) { PitchInc = 4096; } else if (pScreenInfo->depth == 16) { PitchInc = 2048; } else { PitchInc = 1024; } PitchInc <<= 3; /* in bits */ /* by default use what user sets in the XF86Config file */ modes = pScreenInfo->display->modes; i = xf86ValidateModes(pScreenInfo, pScreenInfo->monitor->Modes, modes, &GeodeClockRange, NULL, minPitch, maxPitch, PitchInc, minHeight, maxHeight, pScreenInfo->display->virtualX, pScreenInfo->display->virtualY, #if defined(STB_X) sAdapterInfo.dwFrameBufferSize, #else /* STB_X */ gfx_get_frame_buffer_size(), #endif /* STB_X */ LOOKUP_BEST_REFRESH); DEBUGMSG(1, (pScreenInfo->scrnIndex, from, "xf86ValidateModes: %d %d %d\n", pScreenInfo->virtualX, pScreenInfo->virtualY, pScreenInfo->displayWidth)); if (i == -1) { GX2FreeRec(pScreenInfo); return FALSE; } GeodeDebug(("GX2PreInit(8)!\n")); /* Prune the modes marked as invalid */ xf86PruneDriverModes(pScreenInfo); GeodeDebug(("GX2PreInit(9)!\n")); if (i == 0 || pScreenInfo->modes == NULL) { DEBUGMSG(1, (pScreenInfo->scrnIndex, X_ERROR, "No valid modes found\n")); GX2FreeRec(pScreenInfo); return FALSE; } GeodeDebug(("GX2PreInit(10)!\n")); xf86SetCrtcForModes(pScreenInfo, 0); GeodeDebug(("GX2PreInit(11)!\n")); /* Set the current mode to the first in the list */ pScreenInfo->currentMode = pScreenInfo->modes; GeodeDebug(("GX2PreInit(12)!\n")); /* Print the list of modes being used */ xf86PrintModes(pScreenInfo); GeodeDebug(("GX2PreInit(13)!\n")); /* Set the display resolution */ xf86SetDpi(pScreenInfo, 0, 0); GeodeDebug(("GX2PreInit(14)!\n")); if (xf86LoadSubModule(pScreenInfo, "fb") == NULL) { GX2FreeRec(pScreenInfo); return FALSE; } xf86LoaderReqSymLists(nscFbSymbols, NULL); GeodeDebug(("GX2PreInit(15)!\n")); if (pGeode->NoAccel == FALSE) { if (!xf86LoadSubModule(pScreenInfo, "xaa")) { GX2FreeRec(pScreenInfo); return FALSE; } xf86LoaderReqSymLists(nscXaaSymbols, NULL); } GeodeDebug(("GX2PreInit(16)!\n")); if (pGeode->HWCursor == TRUE) { if (!xf86LoadSubModule(pScreenInfo, "ramdac")) { GX2FreeRec(pScreenInfo); return FALSE; } xf86LoaderReqSymLists(nscRamdacSymbols, NULL); } GeodeDebug(("GX2PreInit(17)!\n")); /* Load shadowfb if needed */ if (pGeode->ShadowFB) { if (!xf86LoadSubModule(pScreenInfo, "shadowfb")) { GX2FreeRec(pScreenInfo); return FALSE; } xf86LoaderReqSymLists(nscShadowSymbols, NULL); } GeodeDebug(("GX2PreInit(18)!\n")); if (xf86RegisterResources(pGeode->pEnt->index, NULL, ResExclusive)) { DEBUGMSG(1, (pScreenInfo->scrnIndex, X_ERROR, "xf86RegisterResources() found resource conflicts\n")); GX2FreeRec(pScreenInfo); return FALSE; } GX2UnmapMem(pScreenInfo); GeodeDebug(("GX2PreInit ... done successfully!\n")); (void) from; return TRUE; } /*---------------------------------------------------------------------------- * GX2Restore. * * Description :This function restores the mode that was saved on server entry * Parameters. * pScreenInfo :Handle to ScreenPtr structure. * Pmode :poits to screen mode * * Returns :none. * * Comments :none. *---------------------------------------------------------------------------- */ static void GX2Restore(ScrnInfoPtr pScreenInfo) { GeodePtr pGeode; GeodeDebug(("GX2Restore!\n")); /* Get driver private structure */ if (!(pGeode = GX2GetRec(pScreenInfo))) return; if (pGeode->FBVGAActive) { vgaHWPtr pvgaHW = VGAHWPTR(pScreenInfo); vgaHWProtect(pScreenInfo, TRUE); vgaHWRestore(pScreenInfo, &pvgaHW->SavedReg, VGA_SR_ALL); vgaHWProtect(pScreenInfo, FALSE); } } /*---------------------------------------------------------------------------- * GX2CalculatePitchBytes. * * Description :This function restores the mode that was saved on server * * Parameters. * pScreenInfo :Handle to ScreenPtr structure. * Pmode :Points to screenmode * * Returns :none. * * Comments :none. *---------------------------------------------------------------------------- */ static int GX2CalculatePitchBytes(unsigned int width, unsigned int bpp) { int lineDelta = width * (bpp >> 3); if (width < 640) { /* low resolutions have both pixel and line doubling */ DEBUGMSG(1, (0, X_PROBED, "lower resolution %d %d\n", width, lineDelta)); lineDelta <<= 1; } /* needed in Rotate mode when in accel is turned off */ if (1) { /*!pGeode->NoAccel */ if (lineDelta > 4096) lineDelta = 8192; else if (lineDelta > 2048) lineDelta = 4096; else if (lineDelta > 1024) lineDelta = 2048; else lineDelta = 1024; } DEBUGMSG(1, (0, X_PROBED, "pitch %d %d\n", width, lineDelta)); return lineDelta; } /*---------------------------------------------------------------------------- * GX2GetRefreshRate. * * Description :This function restores the mode that saved on server * * Parameters. * Pmode :Pointer to the screen modes * * Returns :It returns the selected refresh rate. * * Comments :none. *---------------------------------------------------------------------------- */ static int GX2GetRefreshRate(DisplayModePtr pMode) { #define THRESHOLD 2 unsigned int i; static int validRates[] = { 50, 56, 60, 70, 72, 75, 85 }; /* Hz */ unsigned long dotClock; int refreshRate; int selectedRate; dotClock = pMode->SynthClock * 1000; refreshRate = dotClock / pMode->CrtcHTotal / pMode->CrtcVTotal; if ((pMode->CrtcHTotal < 640) && (pMode->CrtcVTotal < 480)) refreshRate >>= 2; /* double pixel and double scan */ DEBUGMSG(1, (0, X_PROBED, "dotclock %d %d\n", dotClock, refreshRate)); selectedRate = validRates[0]; for (i = 0; i < (sizeof(validRates) / sizeof(validRates[0])); i++) { if (validRates[i] < (refreshRate + THRESHOLD)) { selectedRate = validRates[i]; } } return selectedRate; } void gx2_clear_screen(int width, int height) { /* clean up the frame buffer memory */ GFX(set_solid_pattern(0)); GFX(set_raster_operation(0xF0)); GFX(pattern_fill(0, 0, width, height)); } void gx2_set_DvLineSize(unsigned int pitch) { unsigned long temp, dv_size = MDC_DV_LINE_SIZE_1024; if (pitch > 1024) { dv_size = MDC_DV_LINE_SIZE_2048; } if (pitch > 2048) { dv_size = MDC_DV_LINE_SIZE_4096; } if (pitch > 4096) { dv_size = MDC_DV_LINE_SIZE_8192; } /* WRITE DIRTY/VALID CONTROL WITH LINE LENGTH */ #if defined(STB_X) Gal_read_register(GAL_REG, MDC_DV_CTL, &temp, 4); temp = (temp & ~MDC_DV_LINE_SIZE_MASK) | dv_size; Gal_write_register(GAL_REG, MDC_DV_CTL, temp, 4); #else temp = READ_REG32(MDC_DV_CTL); WRITE_REG32(MDC_DV_CTL, (temp & ~MDC_DV_LINE_SIZE_MASK) | dv_size); #endif } /*---------------------------------------------------------------------------- * GX2SetMode. * * Description :This function sets parametrs for screen mode * * Parameters. * pScreenInfo :Pointer to the screenInfo structure. * Pmode :Pointer to the screen modes * * Returns :TRUE on success and FALSE on Failure. * * Comments :none. *---------------------------------------------------------------------------- */ static Bool GX2SetMode(ScrnInfoPtr pScreenInfo, DisplayModePtr pMode) { GeodePtr pGeode = GEODEPTR(pScreenInfo); DCount = 50; /* unsigned int compOffset, compPitch, compSize; */ GeodeDebug(("GX2SetMode!\n")); #if !defined(STB_X) DEBUGMSG(1, (0, X_NONE, "Set mode %X %X %X %X %X\n", gfx_virt_regptr, gfx_virt_gpptr, gfx_virt_spptr, gfx_virt_vidptr, gfx_virt_fbptr)); #endif /* STB_X */ /* Set the VT semaphore */ pScreenInfo->vtSema = TRUE; DEBUGMSG(1, (0, X_NONE, "Set mode")); /* The timing will be adjusted later */ GeodeDebug(("Set display mode: %dx%d-%d (%dHz) Pitch %d\n", pMode->CrtcHDisplay, pMode->CrtcVDisplay, pScreenInfo->bitsPerPixel, GX2GetRefreshRate(pMode), pGeode->Pitch)); GeodeDebug(("Before setting the mode\n")); if (1) { { /* TV not selected */ DEBUGMSG(1, (0, X_PROBED, "Setting Display for CRT or TFT\n")); if (pGeode->Panel) { DEBUGMSG(0, (0, X_PROBED, "Setting Display for TFT\n")); DEBUGMSG(1, (0, X_PROBED, "Restore Panel %d %d %d %d %d\n", pGeode->FPBX, pGeode->FPBY, pMode->CrtcHDisplay, pMode->CrtcVDisplay, pScreenInfo->bitsPerPixel)); DEBUGMSG(1, (pScreenInfo->scrnIndex, X_CONFIG, "FP Bios %d\n", pGeode->Panel)); GFX(set_fixed_timings(pGeode->FPBX, pGeode->FPBY, pMode->CrtcHDisplay, pMode->CrtcVDisplay, pScreenInfo->bitsPerPixel)); } else { /* display is crt */ DEBUGMSG(1, (0, X_PROBED, "Setting Display for CRT %dx%d-%d@%d\n", pMode->CrtcHDisplay, pMode->CrtcVDisplay, pScreenInfo->bitsPerPixel, GX2GetRefreshRate(pMode))); GFX(set_display_mode(pMode->CrtcHDisplay, pMode->CrtcVDisplay, pScreenInfo->bitsPerPixel, GX2GetRefreshRate(pMode))); /* adjust the pitch */ GFX(set_display_pitch(pGeode->Pitch)); } GFX(set_bpp(pScreenInfo->bitsPerPixel)); /* enable crt */ GFX(set_crt_enable(CRT_ENABLE)); } GFX(set_display_offset(0L)); GFX(wait_vertical_blank()); DEBUGMSG(1, (0, X_PROBED, "Display mode set\n")); /* enable compression if option selected */ if (pGeode->Compression) { DEBUGMSG(1, (0, X_PROBED, "Compression mode set %d\n", pGeode->Compression)); /* set the compression parameters,and it will be turned on later. */ gx2_set_DvLineSize(pGeode->Pitch); #if defined(STB_X) Gal_set_compression_parameters(GAL_COMPRESSION_ALL, pGeode->CBOffset, pGeode->CBPitch, pGeode->CBSize); /* set the compression buffer, all parameters already set */ Gal_set_compression_enable(GAL_COMPRESSION_ENABLE); #else /* STB_X */ gfx_set_compression_offset(pGeode->CBOffset); gfx_set_compression_pitch(pGeode->CBPitch); gfx_set_compression_size(pGeode->CBSize); /* set the compression buffer, all parameters already set */ gfx_set_compression_enable(1); #endif /* STB_X */ } if (pGeode->HWCursor) { /* Load blank cursor */ GX2LoadCursorImage(pScreenInfo, NULL); GFX(set_cursor_position(pGeode->CursorStartOffset, 0, 0, 0, 0)); GFX(set_cursor_enable(1)); } } else { GeodeDebug(("GX2Restore ... ")); GX2Restore(pScreenInfo); GeodeDebug(("done.\n")); } GeodeDebug(("done.\n")); /* Reenable the hardware cursor after the mode switch */ if (pGeode->HWCursor == TRUE) { GeodeDebug(("GX2ShowCursor ... ")); GX2ShowCursor(pScreenInfo); GeodeDebug(("done.\n")); } /* Restore the contents in the screen info */ GeodeDebug(("After setting the mode\n")); return TRUE; } /*---------------------------------------------------------------------------- * GX2EnterGraphics. * * Description :This function will intiallize the displaytiming structure for nextmode and switch to VGA mode. * * Parameters. * pScreen :Screen information will be stored in this structure. * pScreenInfo :Pointer to the screenInfo structure. * * Returns :TRUE on success and FALSE on Failure. * * Comments :gfx_vga_mode_switch() will start and end the * switching based on the arguments 0 or 1.soft_vga * is disabled in this function. *---------------------------------------------------------------------------- */ static Bool GX2EnterGraphics(ScreenPtr pScreen, ScrnInfoPtr pScreenInfo) { GeodePtr pGeode = GX2GetRec(pScreenInfo); #if defined(STB_X) Gal_get_display_timing(&pGeode->FBgfxdisplaytiming); /* Save Display offset */ Gal_get_display_offset(&(pGeode->FBDisplayOffset)); /* Save the current Compression state */ Gal_get_compression_enable(&(pGeode->FBCompressionEnable)); Gal_get_compression_parameters(GAL_COMPRESSION_ALL, &(pGeode->FBCompressionOffset), &(pGeode->FBCompressionPitch), &(pGeode->FBCompressionSize)); /* Save Cursor offset */ { unsigned short x, y, xhot, yhot; Gal_get_cursor_position(&(pGeode->FBCursorOffset), &x, &y, &xhot, &yhot); } /* Save the Panel state */ Gal_pnl_save(); #else /* STB_X */ /* Save CRT State */ pGeode->FBgfxdisplaytiming.dwDotClock = gfx_get_clock_frequency(); pGeode->FBgfxdisplaytiming.wPitch = gfx_get_display_pitch(); pGeode->FBgfxdisplaytiming.wBpp = gfx_get_display_bpp(); pGeode->FBgfxdisplaytiming.wHTotal = gfx_get_htotal(); pGeode->FBgfxdisplaytiming.wHActive = gfx_get_hactive(); pGeode->FBgfxdisplaytiming.wHSyncStart = gfx_get_hsync_start(); pGeode->FBgfxdisplaytiming.wHSyncEnd = gfx_get_hsync_end(); pGeode->FBgfxdisplaytiming.wHBlankStart = gfx_get_hblank_start(); pGeode->FBgfxdisplaytiming.wHBlankEnd = gfx_get_hblank_end(); pGeode->FBgfxdisplaytiming.wVTotal = gfx_get_vtotal(); pGeode->FBgfxdisplaytiming.wVActive = gfx_get_vactive(); pGeode->FBgfxdisplaytiming.wVSyncStart = gfx_get_vsync_start(); pGeode->FBgfxdisplaytiming.wVSyncEnd = gfx_get_vsync_end(); pGeode->FBgfxdisplaytiming.wVBlankStart = gfx_get_vblank_start(); pGeode->FBgfxdisplaytiming.wVBlankEnd = gfx_get_vblank_end(); pGeode->FBgfxdisplaytiming.wPolarity = gfx_get_sync_polarities(); /* Save Display offset */ pGeode->FBDisplayOffset = gfx_get_display_offset(); /* Save the current Compression state */ pGeode->FBCompressionEnable = gfx_get_compression_enable(); pGeode->FBCompressionOffset = gfx_get_compression_offset(); pGeode->FBCompressionPitch = gfx_get_compression_pitch(); pGeode->FBCompressionSize = gfx_get_compression_size(); /* Save Cursor offset */ pGeode->FBCursorOffset = gfx_get_cursor_offset(); /* Save the Panel state */ Pnl_SavePanelState(); /* only if comming from VGA */ if (pGeode->FBVGAActive) { unsigned short sequencer; vgaHWPtr pvgaHW = VGAHWPTR(pScreenInfo); /* Map VGA aperture */ if (!vgaHWMapMem(pScreenInfo)) return FALSE; /* Unlock VGA registers */ vgaHWUnlock(pvgaHW); /* Save the current state and setup the current mode */ vgaHWSave(pScreenInfo, &VGAHWPTR(pScreenInfo)->SavedReg, VGA_SR_ALL); /* DISABLE VGA SEQUENCER */ /* This allows the VGA state machine to terminate. We must delay */ /* such that there are no pending MBUS requests. */ gfx_outb(MDC_SEQUENCER_INDEX, MDC_SEQUENCER_CLK_MODE); sequencer = gfx_inb(MDC_SEQUENCER_DATA); sequencer |= MDC_CLK_MODE_SCREEN_OFF; gfx_outb(MDC_SEQUENCER_DATA, sequencer); gfx_delay_milliseconds(1); /* BLANK THE VGA DISPLAY */ gfx_outw(MDC_SEQUENCER_INDEX, MDC_SEQUENCER_RESET); sequencer = gfx_inb(MDC_SEQUENCER_DATA); sequencer &= ~MDC_RESET_VGA_DISP_ENABLE; gfx_outb(MDC_SEQUENCER_DATA, sequencer); gfx_delay_milliseconds(1); } #endif /* STB */ if (!GX2SetMode(pScreenInfo, pScreenInfo->currentMode)) { return FALSE; } /* clear the frame buffer, for annoying noise during mode switch */ gx2_clear_screen(pScreenInfo->currentMode->CrtcHDisplay, pScreenInfo->currentMode->CrtcVDisplay); return TRUE; } #if !defined(STB_X) void EnableDACPower(void) { /* enable the DAC POWER */ gfx_write_vid32(RCDF_VID_MISC, gfx_read_vid32(RCDF_VID_MISC) & RCDF_GAMMA_BYPASS_BOTH); } void redcloud_gfx_2_vga_fix(void) { /* enable the DAC POWER */ EnableDACPower(); #if 0 int i; /* set the character width to 9 */ gfx_outb(0x3C4, 0x1); gfx_outb(0x3C5, 0x2); /* clear the gfx mode bit in VGA Attribute controller */ gfx_inb(0x3DA); gfx_outb(0x3C0, 0x30); gfx_outb(0x3C0, 0xC); /* Re init the EGA Palaette */ for (i = 0; i < 16; i++) { gfx_inb(0x3DA); gfx_outb(0x3C0, i); gfx_outb(0x3C0, i); } /* Re init the Overscan color to black */ gfx_inb(0x3DA); gfx_outb(0x3C0, 0x11); gfx_outb(0x3C0, 0x0); /* Re Enable all the 4 color planes */ gfx_inb(0x3DA); gfx_outb(0x3C0, 0x12); gfx_outb(0x3C0, 0xF); /* Clear Pixel Panning in VGA Attribute controller */ gfx_inb(0x3DA); gfx_outb(0x3C0, 0x33); gfx_outb(0x3C0, 0x8); /* ??????????????????????? */ gfx_outb(0x3C0, 0x20); gfx_outb(0x3C0, 0x20); #endif } #endif /* STB_X */ /*---------------------------------------------------------------------------- * GX2LeaveGraphics: * * Description :This function will restore the displaymode parameters * and switches the VGA mode * * Parameters. * pScreen :Screen information will be stored in this structure. * pScreenInfo :Pointer to the screenInfo structure. * * * Returns :none. * * Comments : gfx_vga_mode_switch() will start and end the switching * based on the arguments 0 or 1.soft_vga is disabled in * this function. *---------------------------------------------------------------------------- */ static void GX2LeaveGraphics(ScrnInfoPtr pScreenInfo) { GeodePtr pGeode = GX2GetRec(pScreenInfo); /* Restore VG registers */ #if defined(STB_X) Gal_set_display_timing(&pGeode->FBgfxdisplaytiming); Gal_set_display_offset(pGeode->FBDisplayOffset); /* Restore Cursor */ Gal_set_cursor_position(pGeode->FBCursorOffset, 0, 0, 0, 0); /* Restore the previous Compression state */ if (pGeode->FBCompressionEnable) { Gal_set_compression_parameters(GAL_COMPRESSION_ALL, pGeode->FBCompressionOffset, pGeode->FBCompressionPitch, pGeode->FBCompressionSize); Gal_set_compression_enable(GAL_COMPRESSION_ENABLE); } #else /* STB_X */ gfx_set_display_timings(pGeode->FBgfxdisplaytiming.wBpp, pGeode->FBgfxdisplaytiming.wPolarity, pGeode->FBgfxdisplaytiming.wHActive, pGeode->FBgfxdisplaytiming.wHBlankStart, pGeode->FBgfxdisplaytiming.wHSyncStart, pGeode->FBgfxdisplaytiming.wHSyncEnd, pGeode->FBgfxdisplaytiming.wHBlankEnd, pGeode->FBgfxdisplaytiming.wHTotal, pGeode->FBgfxdisplaytiming.wVActive, pGeode->FBgfxdisplaytiming.wVBlankStart, pGeode->FBgfxdisplaytiming.wVSyncStart, pGeode->FBgfxdisplaytiming.wVSyncEnd, pGeode->FBgfxdisplaytiming.wVBlankEnd, pGeode->FBgfxdisplaytiming.wVTotal, pGeode->FBgfxdisplaytiming.dwDotClock); gfx_set_compression_enable(0); /* Restore the previous Compression state */ if (pGeode->FBCompressionEnable) { gfx_set_compression_offset(pGeode->FBCompressionOffset); gfx_set_compression_pitch(pGeode->FBCompressionPitch); gfx_set_compression_size(pGeode->FBCompressionSize); gfx_set_compression_enable(1); } gfx_set_display_pitch(pGeode->FBgfxdisplaytiming.wPitch); gfx_set_display_offset(pGeode->FBDisplayOffset); /* Restore Cursor */ gfx_set_cursor_position(pGeode->FBCursorOffset, 0, 0, 0, 0); GeodeDebug(("FBVGAActive %d\n", pGeode->FBVGAActive)); if (pGeode->FBVGAActive) { pGeode->vesa->pInt->num = 0x10; pGeode->vesa->pInt->ax = 0x3; pGeode->vesa->pInt->bx = 0; xf86ExecX86int10(pGeode->vesa->pInt); gfx_delay_milliseconds(3); EnableDACPower(); } #endif /* STB_X */ } /*---------------------------------------------------------------------------- * GX2CloseScreen. * * Description :This function will restore the original mode * and also it unmap video memory * * Parameters. * ScrnIndex :Screen index value of the screen will be closed. * pScreen :Pointer to the screen structure. * * * Returns :TRUE on success and FALSE on Failure. * * Comments :none. *---------------------------------------------------------------------------- */ static Bool GX2CloseScreen(int scrnIndex, ScreenPtr pScreen) { ScrnInfoPtr pScreenInfo = xf86Screens[scrnIndex]; GeodePtr pGeode = GEODEPTR(pScreenInfo); if (pGeode->ShadowPtr) xfree(pGeode->ShadowPtr); DEBUGMSG(0, (scrnIndex, X_PROBED, "GX2CloseScreen %d\n", pScreenInfo->vtSema)); if (pScreenInfo->vtSema) GX2LeaveGraphics(pScreenInfo); if (pGeode->AccelInfoRec) XAADestroyInfoRec(pGeode->AccelInfoRec); if (pGeode->AccelImageWriteBufferOffsets) { xfree(pGeode->AccelImageWriteBufferOffsets); pGeode->AccelImageWriteBufferOffsets = 0x0; } /* free the allocated off screen area */ xf86FreeOffscreenArea(pGeode->AccelImgArea); xf86FreeOffscreenArea(pGeode->CompressionArea); pScreenInfo->vtSema = FALSE; GX2UnmapMem(pScreenInfo); if (pGeode && (pScreen->CloseScreen = pGeode->CloseScreen)) { pGeode->CloseScreen = NULL; return ((*pScreen->CloseScreen) (scrnIndex, pScreen)); } return TRUE; } /*---------------------------------------------------------------------------- * GX2DPMSSet. * * Description :This function sets geode into Power Management * Signalling mode. * * Parameters. * pScreenInfo :Pointer to screen info strucrure. * mode :Specifies the power management mode. * * Returns :none. * * Comments :none. *---------------------------------------------------------------------------- */ static void GX2DPMSSet(ScrnInfoPtr pScreenInfo, int mode, int flags) { GeodePtr pGeode; pGeode = GEODEPTR(pScreenInfo); GeodeDebug(("GX2DPMSSet!\n")); /* Check if we are actively controlling the display */ if (!pScreenInfo->vtSema) { ErrorF("GX2DPMSSet called when we not controlling the VT!\n"); return; } switch (mode) { case DPMSModeOn: /* Screen: On; HSync: On; VSync: On */ GFX(set_crt_enable(CRT_ENABLE)); #if defined(STB_X) if (pGeode->Panel) Gal_pnl_powerup(); #else /* STB_X */ if (pGeode->Panel) Pnl_PowerUp(); #endif /* STB_X */ break; case DPMSModeStandby: /* Screen: Off; HSync: Off; VSync: On */ GFX(set_crt_enable(CRT_STANDBY)); #if defined(STB_X) if (pGeode->Panel) Gal_pnl_powerdown(); #else /* STB_X */ if (pGeode->Panel) Pnl_PowerDown(); #endif /* STB_X */ break; case DPMSModeSuspend: /* Screen: Off; HSync: On; VSync: Off */ GFX(set_crt_enable(CRT_SUSPEND)); #if defined(STB_X) if (pGeode->Panel) Gal_pnl_powerdown(); #else /* STB_X */ if (pGeode->Panel) Pnl_PowerDown(); #endif /* STB_X */ break; case DPMSModeOff: /* Screen: Off; HSync: Off; VSync: Off */ GFX(set_crt_enable(CRT_DISABLE)); #if defined(STB_X) if (pGeode->Panel) Gal_pnl_powerdown(); #else /* STB_X */ if (pGeode->Panel) Pnl_PowerDown(); #endif /* STB_X */ break; } } /*---------------------------------------------------------------------------- * GX2ScreenInit. * * Description :This function will be called at the each ofserver * generation. * * Parameters. * scrnIndex :Specfies the screenindex value during generation. * pScreen :Pointer to screen info strucrure. * argc :parameters for command line arguments count * argv :command line arguments if any it is not used. * * Returns :none. * * Comments :none. *---------------------------------------------------------------------------- */ static Bool GX2ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv) { ScrnInfoPtr pScreenInfo = xf86Screens[pScreen->myNum]; GeodePtr pGeode; int i; Bool Inited = FALSE; unsigned char *FBStart; unsigned int req_offscreenmem; int width, height, displayWidth; VisualPtr visual; BoxRec AvailBox; RegionRec OffscreenRegion; DCount = 30; GeodeDebug(("GX2ScreenInit!\n")); /* Get driver private */ pGeode = GX2GetRec(pScreenInfo); GeodeDebug(("GX2ScreenInit(0)!\n")); /* * * Allocate a vgaHWRec */ GeodeDebug(("FBVGAActive %d\n", pGeode->FBVGAActive)); if (pGeode->FBVGAActive) { if (!vgaHWGetHWRec(pScreenInfo)) return FALSE; if (!vgaHWMapMem(pScreenInfo)) return FALSE; vgaHWGetIOBase(VGAHWPTR(pScreenInfo)); } if (!GX2MapMem(pScreenInfo)) return FALSE; pGeode->Pitch = GX2CalculatePitchBytes(pScreenInfo->virtualX, pScreenInfo->bitsPerPixel); /* SET UP GRAPHICS MEMORY AVAILABLE FOR PIXMAP CACHE */ AvailBox.x1 = 0; AvailBox.y1 = pScreenInfo->virtualY; AvailBox.x2 = pScreenInfo->displayWidth; AvailBox.y2 = (pGeode->FBSize / pGeode->Pitch); pGeode->CursorSize = 16 * 64; /* 64x64 */ if (pGeode->HWCursor) { /* Compute cursor buffer */ /* Default cursor offset, end of the frame buffer */ pGeode->CursorStartOffset = pGeode->FBSize - pGeode->CursorSize; AvailBox.y2 -= 1; } DEBUGMSG(1, (scrnIndex, X_PROBED, "Memory manager initialized to (%d,%d) (%d,%d) %d %d %d\n", AvailBox.x1, AvailBox.y1, AvailBox.x2, AvailBox.y2, pGeode->Pitch, pScreenInfo->displayWidth, pScreenInfo->bitsPerPixel)); /* set the offscreen offset accordingly */ if (pGeode->Compression) { pGeode->CBPitch = 544; pGeode->CBSize = 544; req_offscreenmem = pScreenInfo->virtualY * pGeode->CBPitch; req_offscreenmem += pGeode->Pitch - 1; req_offscreenmem /= pGeode->Pitch; pGeode->CBOffset = AvailBox.y1 * pGeode->Pitch; AvailBox.y1 += req_offscreenmem; } DEBUGMSG(1, (scrnIndex, X_PROBED, "Memory manager initialized to (%d,%d) (%d,%d)\n", AvailBox.x1, AvailBox.y1, AvailBox.x2, AvailBox.y2)); if (!pGeode->NoAccel) { if (pGeode->NoOfImgBuffers > 0) { if (pGeode->NoOfImgBuffers <= (AvailBox.y2 - AvailBox.y1)) { pGeode->AccelImageWriteBufferOffsets = xalloc(sizeof(unsigned long) * pGeode->NoOfImgBuffers); pGeode->AccelImageWriteBufferOffsets[0] = ((unsigned char *)pGeode->FBBase) + (AvailBox.y1 * pGeode->Pitch); for (i = 1; i < pGeode->NoOfImgBuffers; i++) { pGeode->AccelImageWriteBufferOffsets[i] = pGeode->AccelImageWriteBufferOffsets[i - 1] + pGeode->Pitch; } for (i = 0; i < pGeode->NoOfImgBuffers; i++) { DEBUGMSG(1, (scrnIndex, X_PROBED, "memory %d %x\n", i, pGeode->AccelImageWriteBufferOffsets[i])); } AvailBox.y1 += pGeode->NoOfImgBuffers; } else { xf86DrvMsg(scrnIndex, X_ERROR, "Unable to reserve scanline area\n"); } } DEBUGMSG(1, (scrnIndex, X_PROBED, "Memory manager initialized to (%d,%d) (%d,%d)\n", AvailBox.x1, AvailBox.y1, AvailBox.x2, AvailBox.y2)); REGION_INIT(pScreen, &OffscreenRegion, &AvailBox, 2); if (!xf86InitFBManagerRegion(pScreen, &OffscreenRegion)) { xf86DrvMsg(scrnIndex, X_ERROR, "Memory manager initialization to (%d,%d) (%d,%d) failed\n", AvailBox.x1, AvailBox.y1, AvailBox.x2, AvailBox.y2); } else { xf86DrvMsg(scrnIndex, X_INFO, "Memory manager initialized to (%d,%d) (%d,%d)\n", AvailBox.x1, AvailBox.y1, AvailBox.x2, AvailBox.y2); } REGION_UNINIT(pScreen, &OffscreenRegion); } /* Initialise graphics mode */ if (!GX2EnterGraphics(pScreen, pScreenInfo)) return FALSE; GX2AdjustFrame(scrnIndex, pScreenInfo->frameX0, pScreenInfo->frameY0, 0); GeodeDebug(("GX2ScreenInit(1)!\n")); /* Reset visual list */ miClearVisualTypes(); GeodeDebug(("GX2ScreenInit(2)!\n")); /* Setup the visual we support */ if (pScreenInfo->bitsPerPixel > 8) { DEBUGMSG(1, (scrnIndex, X_PROBED, "miSetVisualTypes %d %X %X %X\n", pScreenInfo->depth, TrueColorMask, pScreenInfo->rgbBits, pScreenInfo->defaultVisual)); if (!miSetVisualTypes(pScreenInfo->depth, TrueColorMask, pScreenInfo->rgbBits, pScreenInfo->defaultVisual)) { return FALSE; } } else { if (!miSetVisualTypes(pScreenInfo->depth, miGetDefaultVisualMask(pScreenInfo->depth), pScreenInfo->rgbBits, pScreenInfo->defaultVisual)) { return FALSE; } } GeodeDebug(("GX2ScreenInit(3)!\n")); /* Set for RENDER extensions */ miSetPixmapDepths(); /* Call the framebuffer layer's ScreenInit function, and fill in other * * pScreen fields. */ width = pScreenInfo->virtualX; height = pScreenInfo->virtualY; displayWidth = pScreenInfo->displayWidth; if (pGeode->Rotate) { width = pScreenInfo->virtualY; height = pScreenInfo->virtualX; } if (pGeode->ShadowFB) { pGeode->ShadowPitch = BitmapBytePad(pScreenInfo->bitsPerPixel * width); pGeode->ShadowPtr = xalloc(pGeode->ShadowPitch * height); displayWidth = pGeode->ShadowPitch / (pScreenInfo->bitsPerPixel >> 3); FBStart = pGeode->ShadowPtr; } else { pGeode->ShadowPtr = NULL; FBStart = pGeode->FBBase; DEBUGMSG(1, (0, X_PROBED, "FBStart %X \n", FBStart)); } switch (pScreenInfo->bitsPerPixel) { case 8: case 16: case 24: case 32: Inited = fbScreenInit(pScreen, FBStart, width, height, pScreenInfo->xDpi, pScreenInfo->yDpi, displayWidth, pScreenInfo->bitsPerPixel); break; default: xf86DrvMsg(scrnIndex, X_ERROR, "Internal error: invalid bpp (%d) in ScreenInit\n", pScreenInfo->bitsPerPixel); Inited = FALSE; break; } if (!Inited) return FALSE; GeodeDebug(("GX2ScreenInit(4)!\n")); xf86SetBlackWhitePixels(pScreen); if (!pGeode->ShadowFB) { GX2DGAInit(pScreen); } GeodeDebug(("GX2ScreenInit(5)!\n")); if (pScreenInfo->bitsPerPixel > 8) { /* Fixup RGB ordering */ visual = pScreen->visuals + pScreen->numVisuals; while (--visual >= pScreen->visuals) { if ((visual->class | DynamicClass) == DirectColor) { visual->offsetRed = pScreenInfo->offset.red; visual->offsetGreen = pScreenInfo->offset.green; visual->offsetBlue = pScreenInfo->offset.blue; visual->redMask = pScreenInfo->mask.red; visual->greenMask = pScreenInfo->mask.green; visual->blueMask = pScreenInfo->mask.blue; } } } /* must be after RGB ordering fixed */ fbPictureInit(pScreen, 0, 0); GeodeDebug(("GX2ScreenInit(6)!\n")); if (!pGeode->NoAccel) { GX2AccelInit(pScreen); } GeodeDebug(("GX2ScreenInit(7)!\n")); xf86SetBackingStore(pScreen); GeodeDebug(("GX2ScreenInit(8)!\n")); /* Initialise software cursor */ miDCInitialize(pScreen, xf86GetPointerScreenFuncs()); /* Initialize HW cursor layer. * * Must follow software cursor initialization */ if (pGeode->HWCursor) { if (!GX2HWCursorInit(pScreen)) xf86DrvMsg(pScreenInfo->scrnIndex, X_ERROR, "Hardware cursor initialization failed\n"); } GeodeDebug(("GX2ScreenInit(9)!\n")); /* Setup default colourmap */ if (!miCreateDefColormap(pScreen)) { return FALSE; } GeodeDebug(("GX2ScreenInit(10)!\n")); /* Initialize colormap layer. * * Must follow initialization of the default colormap */ if (!xf86HandleColormaps(pScreen, 256, 8, GX2LoadPalette, NULL, CMAP_PALETTED_TRUECOLOR | CMAP_RELOAD_ON_MODE_SWITCH)) { return FALSE; } GeodeDebug(("GX2ScreenInit(11)!\n")); if (pGeode->ShadowFB) { RefreshAreaFuncPtr refreshArea = GX2RefreshArea; if (pGeode->Rotate) { if (!pGeode->PointerMoved) { pGeode->PointerMoved = pScreenInfo->PointerMoved; pScreenInfo->PointerMoved = GX2PointerMoved; } switch (pScreenInfo->bitsPerPixel) { case 8: refreshArea = GX2RefreshArea8; break; case 16: refreshArea = GX2RefreshArea16; break; case 24: refreshArea = GX2RefreshArea24; break; case 32: refreshArea = GX2RefreshArea32; break; } } ShadowFBInit(pScreen, refreshArea); } xf86DPMSInit(pScreen, GX2DPMSSet, 0); GeodeDebug(("GX2ScreenInit(12)!\n")); pScreenInfo->memPhysBase = (unsigned long)pGeode->FBBase; pScreenInfo->fbOffset = 0; GeodeDebug(("GX2ScreenInit(13)!\n")); GX2InitVideo(pScreen); /* needed for video */ /* Wrap the screen's CloseScreen vector and set its * SaveScreen vector */ pGeode->CloseScreen = pScreen->CloseScreen; pScreen->CloseScreen = GX2CloseScreen; pScreen->SaveScreen = GX2SaveScreen; GeodeDebug(("GX2ScreenInit(14)!\n")); /* Report any unused options */ if (serverGeneration == 1) { xf86ShowUnusedOptions(pScreenInfo->scrnIndex, pScreenInfo->options); } GeodeDebug(("GX2ScreenInit(15)!\n")); return TRUE; } /*---------------------------------------------------------------------------- * GX2SwitchMode. * * Description :This function will switches the screen mode * * Parameters: * scrnIndex :Specfies the screen index value. * pMode :pointer to the mode structure. * flags :may be used for status check?. * * Returns :Returns TRUE on success and FALSE on failure. * * Comments :none. *---------------------------------------------------------------------------- */ Bool GX2SwitchMode(int scrnIndex, DisplayModePtr pMode, int flags) { GeodeDebug(("GX2SwitchMode!\n")); return GX2SetMode(xf86Screens[scrnIndex], pMode); } /*---------------------------------------------------------------------------- * GX2AdjustFrame. * * Description :This function is used to intiallize the start * address of the memory. * Parameters. * scrnIndex :Specfies the screen index value. * x :x co-ordinate value interms of pixels. * y :y co-ordinate value interms of pixels. * * Returns :none. * * Comments :none. *---------------------------------------------------------------------------- */ void GX2AdjustFrame(int scrnIndex, int x, int y, int flags) { ScrnInfoPtr pScreenInfo = xf86Screens[scrnIndex]; GeodePtr pGeode = GX2GetRec(pScreenInfo); unsigned long offset; /* y offset */ offset = (unsigned long)y *(unsigned long)pGeode->Pitch; /* x offset */ offset += x * (pScreenInfo->bitsPerPixel >> 3); GFX(set_display_offset(offset)); } /*---------------------------------------------------------------------------- * GX2EnterVT. * * Description :This is called when VT switching back to the X server * * Parameters. * scrnIndex :Specfies the screen index value. * flags :Not used inside the function. * * Returns :none. * * Comments :none. *---------------------------------------------------------------------------- */ static Bool GX2EnterVT(int scrnIndex, int flags) { GeodeDebug(("GX2EnterVT!\n")); return GX2EnterGraphics(NULL, xf86Screens[scrnIndex]); } /*---------------------------------------------------------------------------- * GX2LeaveVT. * * Description :This is called when VT switching X server text mode. * * Parameters. * scrnIndex :Specfies the screen index value. * flags :Not used inside the function. * * Returns :none. * * Comments :none. *---------------------------------------------------------------------------- */ static void GX2LeaveVT(int scrnIndex, int flags) { GeodeDebug(("GX2LeaveVT!\n")); GX2LeaveGraphics(xf86Screens[scrnIndex]); } /*---------------------------------------------------------------------------- * GX2FreeScreen. * * Description :This is called to free any persistent data structures. * * Parameters. * scrnIndex :Specfies the screen index value. * flags :Not used inside the function. * * Returns :none. * * Comments :This will be called only when screen being deleted.. *---------------------------------------------------------------------------- */ static void GX2FreeScreen(int scrnIndex, int flags) { GeodeDebug(("GX2FreeScreen!\n")); if (xf86LoaderCheckSymbol("vgaHWFreeHWRec")) vgaHWFreeHWRec(xf86Screens[scrnIndex]); GX2FreeRec(xf86Screens[scrnIndex]); } /*---------------------------------------------------------------------------- * GX2ValidMode. * * Description :This function checks if a mode is suitable for selected * chipset. * Parameters. * scrnIndex :Specfies the screen index value. * pMode :Pointer to the screen mode structure.. * verbose :not used for implementation. * flags :not used for implementation * * Returns :MODE_OK if the specified mode is supported or * MODE_NO_INTERLACE. * Comments :none. *---------------------------------------------------------------------------- */ static ModeStatus GX2ValidMode(int scrnIndex, DisplayModePtr pMode, Bool Verbose, int flags) { unsigned int total_memory_required; ScrnInfoPtr pScreenInfo = xf86Screens[scrnIndex]; int ret = -1; GeodePtr pGeode = GX2GetRec(pScreenInfo); DEBUGMSG(1, (0, X_NONE, "GeodeValidateMode: %dx%d %d %d\n", pMode->CrtcHDisplay, pMode->CrtcVDisplay, pScreenInfo->bitsPerPixel, GX2GetRefreshRate(pMode))); { DEBUGMSG(1, (0, X_NONE, "CRT mode\n")); if (pMode->Flags & V_INTERLACE) return MODE_NO_INTERLACE; #if defined(STB_X) Gal_is_display_mode_supported(pMode->CrtcHDisplay, pMode->CrtcVDisplay, pScreenInfo->bitsPerPixel, GX2GetRefreshRate(pMode), &ret); #else /* STB_X */ ret = gfx_is_display_mode_supported(pMode->CrtcHDisplay, pMode->CrtcVDisplay, pScreenInfo->bitsPerPixel, GX2GetRefreshRate(pMode)); #endif /* STB_X */ } if (ret < 0) return MODE_NOMODE; total_memory_required = GX2CalculatePitchBytes(pMode->CrtcHDisplay, pScreenInfo->bitsPerPixel) * pMode->CrtcVDisplay; DEBUGMSG(1, (0, X_NONE, "Total Mem %X %X\n", total_memory_required, pGeode->FBSize)); if (total_memory_required > pGeode->FBSize) return MODE_MEM; return MODE_OK; } /*---------------------------------------------------------------------------- * GX2LoadPalette. * * Description :This function sets the palette entry used for graphics data * * Parameters. * pScreenInfo:Points the screeninfo structure. * numColors:Specifies the no of colors it supported. * indizes :This is used get index value . * LOCO :to be added. * pVisual :to be added. * * Returns :MODE_OK if the specified mode is supported or * MODE_NO_INTERLACE. * Comments :none. *---------------------------------------------------------------------------- */ static void GX2LoadPalette(ScrnInfoPtr pScreenInfo, int numColors, int *indizes, LOCO * colors, VisualPtr pVisual) { int i, index, color; for (i = 0; i < numColors; i++) { index = indizes[i] & 0xFF; color = (((unsigned long)(colors[index].red & 0xFF)) << 16) | (((unsigned long)(colors[index].green & 0xFF)) << 8) | ((unsigned long)(colors[index].blue & 0xFF)); DEBUGMSG(0, (0, X_NONE, "GX2LoadPalette: %d %d %X\n", numColors, index, color)); GFX(set_display_palette_entry(index, color)); } } static Bool GX2MapMem(ScrnInfoPtr pScreenInfo) { GeodePtr pGeode = GEODEPTR(pScreenInfo); #if defined(STB_X) pGeode->FBBase = (unsigned char *)xf86MapVidMem(pScreenInfo->scrnIndex, VIDMEM_FRAMEBUFFER, pGeode->FBLinearAddr, pGeode->FBSize); #else gfx_virt_regptr = (unsigned char *)xf86MapVidMem(pScreenInfo->scrnIndex, VIDMEM_MMIO, (unsigned int) gfx_get_cpu_register_base (), pGeode->cpu_reg_size); if (pGeode->DetectedChipSet & GX2) { gfx_virt_gpptr = (unsigned char *)xf86MapVidMem(pScreenInfo->scrnIndex, VIDMEM_MMIO, (unsigned int) gfx_get_graphics_register_base (), pGeode->gp_reg_size); } else { gfx_virt_spptr = gfx_virt_regptr; } gfx_virt_vidptr = (unsigned char *)xf86MapVidMem(pScreenInfo->scrnIndex, VIDMEM_MMIO, (unsigned int) gfx_get_vid_register_base (), pGeode->vid_reg_size); gfx_virt_fbptr = (unsigned char *)xf86MapVidMem(pScreenInfo->scrnIndex, VIDMEM_FRAMEBUFFER, pGeode->FBLinearAddr, pGeode->FBSize); pGeode->FBBase = gfx_virt_fbptr; DEBUGMSG(1, (0, X_NONE, "Set mode %X %X %X %X %X\n", gfx_virt_regptr, gfx_virt_gpptr, gfx_virt_spptr, gfx_virt_vidptr, gfx_virt_fbptr)); /* CHECK IF REGISTERS WERE MAPPED SUCCESSFULLY */ if ((!gfx_virt_regptr) || (!gfx_virt_gpptr) || (!gfx_virt_vidptr) || (!gfx_virt_fbptr)) { DEBUGMSG(1, (0, X_NONE, "Could not map hardware registers.\n")); return (FALSE); } /* Map the XpressROM ptr to read what platform are we on */ XpressROMPtr = (unsigned char *)xf86MapVidMem(pScreenInfo->scrnIndex, VIDMEM_FRAMEBUFFER, 0xF0000, 0x10000); DEBUGMSG(1, (0, X_NONE, "adapter info %x %x %x %x, %X\n", pGeode->cpu_version, pGeode->vid_version, pGeode->FBSize, pGeode->FBBase, XpressROMPtr)); #endif return TRUE; } /* * Unmap the framebuffer and MMIO memory. */ static Bool GX2UnmapMem(ScrnInfoPtr pScreenInfo) { #if !defined(STB_X) GeodePtr pGeode = GEODEPTR(pScreenInfo); /* unmap all the memory map's */ xf86UnMapVidMem(pScreenInfo->scrnIndex, gfx_virt_regptr, pGeode->cpu_reg_size); if (pGeode->DetectedChipSet & GX2) { xf86UnMapVidMem(pScreenInfo->scrnIndex, gfx_virt_gpptr, pGeode->gp_reg_size); } xf86UnMapVidMem(pScreenInfo->scrnIndex, gfx_virt_vidptr, pGeode->vid_reg_size); xf86UnMapVidMem(pScreenInfo->scrnIndex, gfx_virt_fbptr, pGeode->FBSize); xf86UnMapVidMem(pScreenInfo->scrnIndex, XpressROMPtr, 0x10000); #endif /* STB_X */ return TRUE; } /* End of file */