diff options
Diffstat (limited to 'src/gx_driver.c')
| -rw-r--r-- | src/gx_driver.c | 1636 |
1 files changed, 1636 insertions, 0 deletions
diff --git a/src/gx_driver.c b/src/gx_driver.c new file mode 100644 index 0000000..1a8eff4 --- /dev/null +++ b/src/gx_driver.c @@ -0,0 +1,1636 @@ +/* Copyright (c) 2003-2006 Advanced Micro Devices, Inc. + * + * Portioned modeled from xf86-video-intel/src/i830_driver.c + * Copyright 2001 VA Linux Systems Inc., Fremont, California. + * Copyright \ufffd 2002 by David Dawes + + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Neither the name of the Advanced Micro Devices, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> + +#include "xf86.h" +#include "xf86_OSproc.h" +#include "xf86Resources.h" +#include "xf86cmap.h" +#include "compiler.h" +#include "mipointer.h" +#include "shadow.h" +#include <X11/extensions/randr.h> +#include "fb.h" +#include "miscstruct.h" +#include "micmap.h" +#include "vbe.h" +#include "fb.h" +#include "randrstr.h" + +#include "geode.h" +#include "gfx_defs.h" +#include "gfx_regs.h" +#include "panel.h" + +/* Bring in VGA functions */ +#include "gx_vga.c" + +#define GX_MIN_PITCH 1024 +#define GX_MAX_PITCH 8192 +#define GX_MAX_WIDTH 1600 +#define GX_MIN_HEIGHT 400 +#define GX_MAX_HEIGHT 1200 +#define GX_CB_PITCH 544 +#define GX_CB_SIZE 544 + +#define GX_CPU_REG_SIZE 0x4000 +#define GX_GP_REG_SIZE 0x4000 +#define GX_VID_REG_SIZE 0x4000 + +extern OptionInfoRec GX_GeodeOptions[]; + +extern const char *amdVgahwSymbols[]; +extern const char *amdVbeSymbols[]; +extern const char *amdInt10Symbols[]; +extern const char *amdFbSymbols[]; +extern const char *amdXaaSymbols[]; +extern const char *amdExaSymbols[]; +extern const char *amdRamdacSymbols[]; + +unsigned char *XpressROMPtr; + +static inline void +gx_enable_dac_power(void) +{ + gfx_write_vid32(RCDF_VID_MISC, + gfx_read_vid32(RCDF_VID_MISC) & RCDF_GAMMA_BYPASS_BOTH); +} + +static inline void +gx_disable_dac_power(void) +{ + gfx_write_vid32(RCDF_VID_MISC, + RCDF_DAC_POWER_DOWN | RCDF_ANALOG_POWER_DOWN | + (gfx_read_vid32(RCDF_VID_MISC) & RCDF_GAMMA_BYPASS_BOTH)); +} + + + + +static void +GXInitEXAMemory(ScrnInfoPtr pScrni, unsigned int *offset, unsigned int *avail) +{ + GeodePtr pGeode = GEODEPTR(pScrni); + + if (pGeode->exaBfrSz > 0 && pGeode->exaBfrSz <= *avail) { + pGeode->exaBfrOffset = *offset; + *offset += pGeode->exaBfrOffset; + *avail -= pGeode->exaBfrOffset; + } +} + +static void +GXInitXAAMemory(ScrnInfoPtr pScrni, unsigned int *offset, unsigned int *avail) +{ + GeodePtr pGeode = GEODEPTR(pScrni); + unsigned int size, i, pitch; + + /* XXX - FIXME - What if we are out of room? Then what? */ + /* For now, we NULL them all out. */ + + if (pGeode->NoOfImgBuffers > 0) { + size = pGeode->displayPitch * pGeode->NoOfImgBuffers; + if (size <= *avail) { + for (i = 0; i < pGeode->NoOfImgBuffers; i++) { + pGeode->AccelImageWriteBuffers[i] = pGeode->FBBase + *offset; + *offset += pGeode->displayPitch; + *avail -= pGeode->displayPitch; + } + } else { + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Not enough memory for image write buffers.\n"); + + for (i = 0; i < pGeode->NoOfImgBuffers; i++) + pGeode->AccelImageWriteBuffers[i] = NULL; + } + } + + if (pGeode->NoOfColorExpandLines > 0) { + pitch = ((pGeode->displayPitch + 31) >> 5) << 2; + size = pitch * pGeode->NoOfColorExpandLines; + + if (size <= *avail) { + for (i = 0; i < pGeode->NoOfColorExpandLines; i++) { + pGeode->AccelColorExpandBuffers[i] = pGeode->FBBase + *offset; + *offset += pitch; + *avail -= pitch; + } + } else { + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Not enough memory for color expansion buffers.\n"); + + for (i = 0; i < pGeode->NoOfImgBuffers; i++) + pGeode->AccelColorExpandBuffers[i] = NULL; + } + } +} + +static Bool +GXAllocateMemory(ScreenPtr pScrn, ScrnInfoPtr pScrni, int rotate) +{ + GeodePtr pGeode = GEODEPTR(pScrni); + + unsigned int fboffset, fbavail; + unsigned int size; + unsigned int bytpp = (pScrni->bitsPerPixel + 7) / 8; + BOOL ret = TRUE; + + if (pGeode->tryCompression) + pGeode->displayPitch = + GeodeCalculatePitchBytes(pScrni->virtualX, pScrni->bitsPerPixel); + else + pGeode->displayPitch = + ((pScrni->virtualX + 3) & ~3) * (pScrni->bitsPerPixel >> 3); + + pGeode->Pitch = pGeode->displayPitch; + pGeode->displayWidth = pGeode->displayPitch / bytpp; + pScrni->displayWidth = pGeode->displayWidth; + + fbavail = pGeode->FBAvail - 0x4000; + + pGeode->displayOffset = fboffset = 0; + pGeode->displaySize = pScrni->virtualY * pGeode->displayPitch; + + fbavail -= pGeode->displaySize; + fboffset += pGeode->displaySize; + + if (pGeode->tryCompression) { + size = pScrni->virtualY * GX_CB_PITCH; + + if (size <= fbavail) { + pGeode->CBData.compression_offset = fboffset; + + fboffset += size; + fbavail -= size; + + pGeode->Compression = TRUE; + } else { + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Not enough memory for compression\n"); + pGeode->Compression = FALSE; + } + } + + if (pGeode->tryHWCursor) { + pGeode->CursorSize = 1024; + + if (pGeode->CursorSize <= fbavail) { + pGeode->CursorStartOffset = fboffset; + fboffset += pGeode->CursorSize; + fbavail -= pGeode->CursorSize; + pGeode->HWCursor = TRUE; + } else { + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Not enough memory for the hardware cursor\n"); + pGeode->HWCursor = FALSE; + } + } + + if (!pGeode->NoAccel) { + if (pGeode->useEXA) + GXInitEXAMemory(pScrni, &fboffset, &fbavail); + else + GXInitXAAMemory(pScrni, &fboffset, &fbavail); + } + + pGeode->shadowSize = 0; + + if (rotate != RR_Rotate_0) { + if (rotate & (RR_Rotate_90 | RR_Rotate_270)) + size = pGeode->displayPitch * pScrni->virtualX; + else + size = pGeode->displayPitch * pScrni->virtualY; + + if (size <= fbavail) { + pGeode->shadowOffset = fboffset; + pGeode->shadowSize = size; + + fboffset += size; + fbavail -= size; + } else { + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Not enough memory for the shadow framebuffer\n"); + ret = FALSE; + } + } + + /* XAA always exists - we can't remove it on demand like we can with EXA. + So we assume the worse, and only give XAA enough offspace room to + account for any eventuality that RandR might throw at us. */ + + if (!pGeode->NoAccel) { + + if (pGeode->useEXA && pGeode->pExa) { + ExaDriverPtr pExa = pGeode->pExa; + + pExa->offScreenBase = fboffset; + pExa->memorySize = fboffset + fbavail; + } + + if (!pGeode->useEXA) { + + if (!xf86FBManagerRunning(pScrn)) { + + unsigned int offset = fboffset; + unsigned int avail = fbavail; + RegionRec OffscreenRegion; + BoxRec AvailBox; + + /* Assume the shadow FB exists even if it doesnt */ + + if (pGeode->shadowSize == 0) { + size = (pScrn->width * bytpp) * pScrni->virtualX; + offset += size; + avail -= size; + } + + AvailBox.x1 = 0; + AvailBox.y1 = + (offset + pGeode->displayPitch - + 1) / pGeode->displayPitch; + + AvailBox.x2 = pGeode->displayWidth; + AvailBox.y2 = (offset + avail) / pGeode->displayPitch; + + if (AvailBox.y1 < AvailBox.y2) { + REGION_INIT(pScrn, &OffscreenRegion, &AvailBox, 2); + + if (!xf86InitFBManagerRegion(pScrn, &OffscreenRegion)) + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Memory manager initialization failed.\n"); + + REGION_UNINIT(pScrn, &OffscreenRegion); + } else + xf86DrvMsg(pScrni->scrnIndex, X_INFO, + "Cache disabled - no offscreen memory available.\n"); + } else + xf86DrvMsg(pScrni->scrnIndex, X_INFO, + "XAA offscreen memory has already been allocated.\n"); + } + } + return ret; +} + +static Bool +GXSaveScreen(ScreenPtr pScrn, int mode) +{ + ScrnInfoPtr pScrni = xf86Screens[pScrn->myNum]; + GeodePtr pGeode = GEODEPTR(pScrni); + + if (pGeode->useVGA && !pScrni->vtSema) + return vgaHWSaveScreen(pScrn, mode); + + return TRUE; +} + + + +/* Common function - used by the LX too */ +#ifdef XSERVER_LIBPCIACCESS +static inline void * map_pci_mem(ScrnInfoPtr pScrni, int vram, + struct pci_device *dev, + int bar, int size) +{ + void *ptr; + void** result = (void**)&ptr; + int map_size = size ? size : dev->regions[bar].size; + + int err = pci_device_map_range(dev, + dev->regions[bar].base_addr, + map_size, + PCI_DEV_MAP_FLAG_WRITABLE | + (vram ? PCI_DEV_MAP_FLAG_WRITE_COMBINE : 0), + result); + + if (err) + return NULL; + return ptr; +} +#endif + + +extern unsigned long gfx_gx2_scratch_base; + +static Bool +GXMapMem(ScrnInfoPtr pScrni) +{ + GeodeRec *pGeode = GEODEPTR(pScrni); + int index = pScrni->scrnIndex; + + pciVideoPtr pci = xf86GetPciInfoForEntity(pGeode->pEnt->index); + +#ifndef XSERVER_LIBPCIACCESS + gfx_virt_regptr = (unsigned char *)xf86MapVidMem(index, VIDMEM_MMIO, + pci->memBase[2], pci->size[2]); + + gfx_virt_gpptr = (unsigned char *)xf86MapVidMem(index, VIDMEM_MMIO, + pci->memBase[1], pci->size[1]); + + gfx_virt_vidptr = (unsigned char *)xf86MapVidMem(index, VIDMEM_MMIO, + pci->memBase[3], pci->size[3]); + + gfx_virt_fbptr = (unsigned char *)xf86MapVidMem(index, VIDMEM_FRAMEBUFFER, + pci->memBase[0], pGeode->FBAvail); +#else + gfx_virt_regptr = map_pci_mem(pScrni, 0, pci, 2, 0); + gfx_virt_gpptr = map_pci_mem(pScrni, 0, pci, 1, 0); + gfx_virt_vidptr = map_pci_mem(pScrni, 0, pci, 3, 0); + gfx_virt_fbptr = map_pci_mem(pScrni, 1, pci, 0, pGeode->FBAvail); +#endif + + gfx_gx2_scratch_base = pGeode->FBAvail - 0x4000; + + XpressROMPtr = xf86MapVidMem(index, VIDMEM_FRAMEBUFFER, 0xF0000, 0x10000); + + pGeode->FBBase = gfx_virt_fbptr; + + if ((!gfx_virt_regptr) || (!gfx_virt_gpptr) || + (!gfx_virt_vidptr) || (!gfx_virt_fbptr)) + return FALSE; + + if (!pGeode->NoAccel && pGeode->useEXA) + pGeode->pExa->memoryBase = pGeode->FBBase; + + xf86DrvMsg(index, X_INFO, "Found Geode %x %p\n", + pGeode->FBAvail, pGeode->FBBase); + + return TRUE; +} + +/* Check to see if VGA exists - we map the space and look for a + signature - if it doesn't match exactly, then we assume no VGA. +*/ + +static Bool +GXCheckVGA(ScrnInfoPtr pScrni) { + + unsigned char *ptr; + const char *vgasig = "IBM VGA Compatible"; + int ret; + + ptr = xf86MapVidMem(pScrni->scrnIndex, VIDMEM_FRAMEBUFFER, 0xC001E, strlen(vgasig)); + + if (ptr == NULL) + return FALSE; + + ret = memcmp(ptr, vgasig, strlen(vgasig)); + xf86UnMapVidMem(pScrni->scrnIndex, (pointer) ptr, strlen(vgasig)); + + return ret ? FALSE : TRUE; +} + +static Bool +GXPreInit(ScrnInfoPtr pScrni, int flags) +{ + GeodePtr pGeode; + ClockRangePtr GeodeClockRange; + OptionInfoRec *GeodeOptions = &GX_GeodeOptions[0]; + int ret; + QQ_WORD msrValue; + EntityInfoPtr pEnt; + rgb defaultWeight = { 0, 0, 0 }; + int modecnt; + char *s, *panelgeo; + Bool useVGA; + + if (pScrni->numEntities != 1) + return FALSE; + + pEnt = xf86GetEntityInfo(pScrni->entityList[0]); + if (pEnt->resources) + return FALSE; + + pGeode = pScrni->driverPrivate = xnfcalloc(sizeof(GeodeRec), 1); + + if (pGeode == NULL) + return FALSE; + + useVGA = GXCheckVGA(pScrni); + + if (flags & PROBE_DETECT) { + if (useVGA) + GeodeProbeDDC(pScrni, pEnt->index); + return TRUE; + } + + /* Probe for VGA */ + pGeode->useVGA = useVGA; + pGeode->pEnt = pEnt; + + if (pGeode->useVGA) { + if (!xf86LoadSubModule(pScrni, "vgahw") || !vgaHWGetHWRec(pScrni)) + pGeode->useVGA = FALSE; + +#if INT10_SUPPORT + pGeode->vesa = xcalloc(sizeof(VESARec), 1); +#endif + } + + gfx_msr_init(); + + ret = gfx_msr_read(RC_ID_DF, MBD_MSR_CONFIG, &msrValue); + + if (!ret) { + pGeode->Output = + ((msrValue.low & RCDF_CONFIG_FMT_MASK) == + RCDF_CONFIG_FMT_FP) ? OUTPUT_PANEL : OUTPUT_CRT; + } + + /* Fill in the monitor information */ + pScrni->monitor = pScrni->confScreen->monitor; + + if (!xf86SetDepthBpp(pScrni, 16, 16, 16, Support24bppFb | Support32bppFb)) + return FALSE; + + switch (pScrni->depth) { + case 8: + pScrni->rgbBits = 8; + case 16: + case 24: + case 32: + break; + default: + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "The driver does not support %d as a depth.\n", pScrni->depth); + return FALSE; + } + + xf86PrintDepthBpp(pScrni); + + if (!xf86SetWeight(pScrni, defaultWeight, defaultWeight)) + return FALSE; + + if (!xf86SetDefaultVisual(pScrni, -1)) + return FALSE; + + /* + * If the driver can do gamma correction, it should call xf86SetGamma() + * here. + */ + { + Gamma zeros = { 0.0, 0.0, 0.0 }; + + if (!xf86SetGamma(pScrni, zeros)) { + return FALSE; + } + } + + pScrni->progClock = TRUE; + xf86CollectOptions(pScrni, NULL); + xf86ProcessOptions(pScrni->scrnIndex, pScrni->options, GeodeOptions); + + /* Set up our various options that may get reversed as we go on */ + + pGeode->FBVGAActive = FALSE; + pGeode->tryHWCursor = TRUE; + pGeode->tryCompression = TRUE; + + pGeode->NoAccel = FALSE; + pGeode->useEXA = TRUE; + + pGeode->Panel = (pGeode->Output & OUTPUT_PANEL) ? TRUE : FALSE; + + pGeode->NoOfImgBuffers = DEFAULT_IMG_LINE_BUFS; + pGeode->NoOfColorExpandLines = DEFAULT_CLR_LINE_BUFS; + pGeode->exaBfrSz = DEFAULT_EXA_SCRATCH_BFRSZ; + + xf86GetOptValBool(GeodeOptions, GX_OPTION_HW_CURSOR, + &pGeode->tryHWCursor); + + if (!xf86GetOptValInteger(GeodeOptions, GX_OPTION_FBSIZE, + (int *)&(pGeode->FBAvail))) + pGeode->FBAvail = 0; + + /* For compatability - allow SWCursor too */ + + if (xf86ReturnOptValBool(GeodeOptions, GX_OPTION_SW_CURSOR, FALSE)) + pGeode->tryHWCursor = FALSE; + + if (xf86ReturnOptValBool(GeodeOptions, GX_OPTION_NOCOMPRESSION, FALSE)) + pGeode->tryCompression = FALSE; + + if (xf86ReturnOptValBool(GeodeOptions, GX_OPTION_NOACCEL, FALSE)) + pGeode->NoAccel = TRUE; + + pGeode->rotation = RR_Rotate_0; + + if ((s = xf86GetOptValString(GeodeOptions, GX_OPTION_ROTATE))) { + + if (!xf86NameCmp(s, "LEFT")) + pGeode->rotation = RR_Rotate_90; + else if (!xf86NameCmp(s, "INVERT")) + pGeode->rotation = RR_Rotate_180; + else if (!xf86NameCmp(s, "CCW")) + pGeode->rotation = RR_Rotate_270; + else + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Invalid rotation %s.\n", s); + } + + xf86GetOptValInteger(GeodeOptions, GX_OPTION_OSM_IMG_BUFS, + &(pGeode->NoOfImgBuffers)); + + if (pGeode->NoOfImgBuffers <= 0) + pGeode->NoOfImgBuffers = 0; + + xf86GetOptValInteger(GeodeOptions, GX_OPTION_OSM_CLR_BUFS, + &(pGeode->NoOfColorExpandLines)); + + if (pGeode->NoOfColorExpandLines <= 0) + pGeode->NoOfColorExpandLines = 0; + + xf86GetOptValInteger(GeodeOptions, GX_OPTION_OSM_CLR_BUFS, + (int *)&(pGeode->exaBfrSz)); + + if (pGeode->exaBfrSz <= 0) + pGeode->exaBfrSz = 0; + + if (pGeode->Panel == TRUE) { + if (xf86ReturnOptValBool(GeodeOptions, GX_OPTION_NOPANEL, FALSE)) + pGeode->Panel = FALSE; + } + + panelgeo = xf86GetOptValString(GeodeOptions, GX_OPTION_PANEL_GEOMETRY); + + if ((s = xf86GetOptValString(GeodeOptions, GX_OPTION_ACCEL_METHOD))) { + if (!xf86NameCmp(s, "XAA")) + pGeode->useEXA = FALSE; + else if (xf86NameCmp(s, "EXA")) + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Unknown accleration method %s. Defaulting to EXA.\n", s); + } + + xf86DrvMsg(pScrni->scrnIndex, X_INFO, + "Using %s acceleration architecture\n", + pGeode->useEXA ? "EXA" : "XAA"); + + /* Set up the panel */ + + if (pGeode->Panel) { + if (panelgeo != NULL) { + if (GeodeGetFPGeometry(panelgeo, &pGeode->PanelX, &pGeode->PanelY)) + pGeode->Panel = FALSE; + } +#ifdef PNL_SUP + else { + int b, f; + + /* The bitdepth and refresh isn't used anywhere else in the driver */ + + if ((pGeode->Panel = Pnl_IsPanelEnabledInBIOS())) + Pnl_GetPanelInfoFromBIOS(&pGeode->PanelX, &pGeode->PanelY, &b, + &f); + } +#endif + } + + /* Set up the VGA */ + + if (pGeode->useVGA) { +#if INT10_SUPPORT + VESARec *pVesa; + + if (!xf86LoadSubModule(pScrni, "int10")) + return FALSE; + xf86LoaderReqSymLists(amdInt10Symbols, NULL); + + pVesa = pGeode->vesa; + + if ((pVesa->pInt = xf86InitInt10(pGeode->pEnt->index)) == NULL) { + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Unable to initialize 1NT10 support\n"); + pGeode->useVGA = FALSE; + } +#endif + } + + /* First try to get the framebuffer size from the framebuffer, + * and if that fails, revert all the way back to the legacy + * method + */ + + if (pGeode->FBAvail == 0) { + if (GeodeGetSizeFromFB(&pGeode->FBAvail)) + pGeode->FBAvail = gfx_get_frame_buffer_size(); + } + + if (pScrni->memPhysBase == 0) + pScrni->memPhysBase = gfx_get_frame_buffer_base(); + + pScrni->fbOffset = 0; + + if (pGeode->pEnt->device->videoRam == 0) + pScrni->videoRam = pGeode->FBAvail / 1024; + else + pScrni->videoRam = pGeode->pEnt->device->videoRam; + + pGeode->maxWidth = GX_MAX_WIDTH; + pGeode->maxHeight = GX_MAX_HEIGHT; + + GeodeClockRange = (ClockRangePtr) xnfcalloc(sizeof(ClockRange), 1); + GeodeClockRange->next = NULL; + GeodeClockRange->minClock = 25175; + GeodeClockRange->maxClock = 229500; + GeodeClockRange->clockIndex = -1; + GeodeClockRange->interlaceAllowed = TRUE; + GeodeClockRange->doubleScanAllowed = FALSE; + + if (pGeode->useVGA) + pScrni->monitor->DDC = GeodeDoDDC(pScrni, pGeode->pEnt->index); + else + pScrni->monitor->DDC = NULL; + + /* I'm still not 100% sure this uses the right values */ + + modecnt = xf86ValidateModes(pScrni, + pScrni->monitor->Modes, + pScrni->display->modes, + GeodeClockRange, + NULL, GX_MIN_PITCH, GX_MAX_PITCH, + 32, GX_MIN_HEIGHT, GX_MAX_HEIGHT, + pScrni->display->virtualX, + pScrni->display->virtualY, pGeode->FBAvail, LOOKUP_BEST_REFRESH); + + if (modecnt <= 0) { + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, "No valid modes were found\n"); + return FALSE; + } + + xf86PruneDriverModes(pScrni); + + if (pScrni->modes == NULL) { + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, "No valid modes were found\n"); + return FALSE; + } + + xf86SetCrtcForModes(pScrni, 0); + pScrni->currentMode = pScrni->modes; + + xf86PrintModes(pScrni); + xf86SetDpi(pScrni, 0, 0); + + /* Load the modules we'll need */ + + if (xf86LoadSubModule(pScrni, "fb") == NULL) { + return FALSE; + } + + xf86LoaderReqSymLists(amdFbSymbols, NULL); + + if (pGeode->NoAccel == FALSE) { + const char *module = (pGeode->useEXA) ? "exa" : "xaa"; + const char **symbols = (pGeode->useEXA) ? + &amdExaSymbols[0] : &amdXaaSymbols[0]; + + if (!xf86LoadSubModule(pScrni, module)) { + return FALSE; + } + + xf86LoaderReqSymLists(symbols, NULL); + } + + if (pGeode->tryHWCursor == TRUE) { + if (!xf86LoadSubModule(pScrni, "ramdac")) { + return FALSE; + } + + xf86LoaderReqSymLists(amdRamdacSymbols, NULL); + } + + if (xf86RegisterResources(pGeode->pEnt->index, NULL, ResExclusive)) { + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Couldn't register the resources.\n"); + return FALSE; + } + + return TRUE; +} + +static void +GXRestore(ScrnInfoPtr pScrni) +{ + GeodeRec *pGeode = GEODEPTR(pScrni); + + if (pGeode->useVGA && pGeode->FBVGAActive) { + vgaHWPtr pvgaHW = VGAHWPTR(pScrni); + + vgaHWProtect(pScrni, TRUE); + vgaHWRestore(pScrni, &pvgaHW->SavedReg, VGA_SR_ALL); + vgaHWProtect(pScrni, FALSE); + } +} + +static Bool +GXUnmapMem(ScrnInfoPtr pScrni) +{ + GeodeRec *pGeode = GEODEPTR(pScrni); + + /* unmap all the memory map's */ + + xf86UnMapVidMem(pScrni->scrnIndex, gfx_virt_regptr, GX_CPU_REG_SIZE); + xf86UnMapVidMem(pScrni->scrnIndex, gfx_virt_gpptr, GX_GP_REG_SIZE); + xf86UnMapVidMem(pScrni->scrnIndex, gfx_virt_vidptr, GX_VID_REG_SIZE); + xf86UnMapVidMem(pScrni->scrnIndex, gfx_virt_fbptr, pGeode->FBAvail); + return TRUE; +} + +static void +GXSetDvLineSize(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 */ + + temp = READ_REG32(MDC_DV_CTL); + WRITE_REG32(MDC_DV_CTL, (temp & ~MDC_DV_LINE_SIZE_MASK) | dv_size); +} + +/* XXX - this is nothing like the original function - not sure exactly what the purpose is for this quite yet */ + +static void +GXAdjustFrame(int scrnIndex, int x, int y, int flags) +{ + ScrnInfoPtr pScrni = xf86Screens[scrnIndex]; + GeodeRec *pGeode = GEODEPTR(pScrni); + unsigned long offset; + + offset = + pGeode->FBOffset + y * pGeode->Pitch + + x * (pScrni->bitsPerPixel >> 3); + + gfx_set_display_offset(offset); +} + +static Bool +GXSetVideoMode(ScrnInfoPtr pScrni, DisplayModePtr pMode) +{ + GeodeRec *pGeode = GEODEPTR(pScrni); + int flags = 0; + int custom = 0; + + pScrni->vtSema = TRUE; + + gx_disable_dac_power(); + + if (pMode->Flags & V_NHSYNC) + flags |= 1; + if (pMode->Flags & V_NVSYNC) + flags |= 2; + + /* Check to see if we should use custom or built-in timings */ + + if (pGeode->Panel) + custom = (pMode->type & M_T_USERDEF); + else + custom = !(pMode->type & (M_T_BUILTIN | M_T_DEFAULT)); + + /* If we're not doing a custom mode, then just set the fixed timings, + * otherwise, do the whole shooting match */ + + if (!custom) { + GFX(set_fixed_timings(pGeode->PanelX, pGeode->PanelY, + pMode->CrtcHDisplay, pMode->CrtcVDisplay, + pScrni->bitsPerPixel)); + } else { + if (pGeode->Panel) + GFX(set_panel_present(pGeode->PanelX, pGeode->PanelY, + pMode->CrtcHDisplay, pMode->CrtcVDisplay, + pScrni->bitsPerPixel)); + + GFX(set_display_timings(pScrni->bitsPerPixel, flags, + pMode->CrtcHDisplay, pMode->CrtcHBlankStart, + pMode->CrtcHSyncStart, pMode->CrtcHSyncEnd, + pMode->CrtcHBlankEnd, pMode->CrtcHTotal, + pMode->CrtcVDisplay, pMode->CrtcVBlankStart, + pMode->CrtcVSyncStart, pMode->CrtcVSyncEnd, + pMode->CrtcVBlankEnd, pMode->CrtcVTotal, + (int)((pMode->SynthClock / 1000.0) * 0x10000))); + } + + GFX(set_crt_enable(CRT_ENABLE)); + GFX(set_display_pitch(pGeode->displayPitch)); + GFX(set_display_offset(0L)); + GFX(wait_vertical_blank()); + + if (pGeode->Compression) { + GXSetDvLineSize(pGeode->Pitch); + + gfx_set_compression_offset(pGeode->CBData.compression_offset); + gfx_set_compression_pitch(GX_CB_PITCH); + gfx_set_compression_size(GX_CB_SIZE); + + gfx_set_compression_enable(1); + } + + if (pGeode->HWCursor && !(pMode->Flags & V_DBLSCAN)) { + GXLoadCursorImage(pScrni, NULL); + GFX(set_cursor_position(pGeode->CursorStartOffset, 0, 0, 0, 0)); + GXShowCursor(pScrni); + } else { + GFX(set_cursor_enable(0)); + pGeode->HWCursor = FALSE; + } + + GXAdjustFrame(pScrni->scrnIndex, pScrni->frameX0, pScrni->frameY0, 0); + gx_enable_dac_power(); + + return TRUE; +} + +static Bool +GXSwitchMode(int index, DisplayModePtr pMode, int flags) +{ + ScrnInfoPtr pScrni = xf86Screens[index]; + GeodeRec *pGeode = GEODEPTR(pScrni); + int ret = TRUE; + int rotate; + + /* Syn the engine and shutdown the DAC momentarily */ + + gfx_wait_until_idle(); + + /* Set up the memory for the new mode */ + rotate = GXGetRotation(pScrni->pScreen); + ret = GXAllocateMemory(pScrni->pScreen, pScrni, rotate); + + if (ret) { + if (pGeode->curMode != pMode) + ret = GXSetVideoMode(pScrni, pMode); + } + + if (ret) + ret = GXRotate(pScrni, pMode); + + /* Go back the way it was */ + + if (ret == FALSE) { + if (!GXSetVideoMode(pScrni, pGeode->curMode)) + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Could not restore the previous mode\n"); + } else + pGeode->curMode = pMode; + + return ret; +} + +static void +GXLeaveGraphics(ScrnInfoPtr pScrni) +{ + GeodeRec *pGeode = GEODEPTR(pScrni); + + gfx_wait_until_idle(); + + /* Restore VG registers */ + 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); + + if (pGeode->useVGA) { + pGeode->vesa->pInt->num = 0x10; + pGeode->vesa->pInt->ax = 0x0 | pGeode->FBBIOSMode; + pGeode->vesa->pInt->bx = 0; + xf86ExecX86int10(pGeode->vesa->pInt); + gfx_delay_milliseconds(3); + } + + GXRestore(pScrni); + + gx_enable_dac_power(); +} + +static Bool +GXCloseScreen(int scrnIndex, ScreenPtr pScrn) +{ + ScrnInfoPtr pScrni = xf86Screens[scrnIndex]; + GeodeRec *pGeode = GEODEPTR(pScrni); + + if (pScrni->vtSema) + GXLeaveGraphics(pScrni); + + if (pGeode->AccelInfoRec) + XAADestroyInfoRec(pGeode->AccelInfoRec); + + if (pGeode->AccelImageWriteBuffers) { + xfree(pGeode->AccelImageWriteBuffers[0]); + xfree(pGeode->AccelImageWriteBuffers); + pGeode->AccelImageWriteBuffers = NULL; + } + + if (pGeode->AccelColorExpandBuffers) { + xfree(pGeode->AccelColorExpandBuffers); + pGeode->AccelColorExpandBuffers = NULL; + } + + if (pGeode->pExa) { + exaDriverFini(pScrn); + xfree(pGeode->pExa); + pGeode->pExa = NULL; + } + + pScrni->vtSema = FALSE; + + GXUnmapMem(pScrni); + + + pScrni->PointerMoved = pGeode->PointerMoved; + pScrn->CloseScreen = pGeode->CloseScreen; + + if (pScrn->CloseScreen) + return (*pScrn->CloseScreen)(scrnIndex, pScrn); + + return TRUE; +} + +static Bool +GXEnterGraphics(ScreenPtr pScrn, ScrnInfoPtr pScrni) +{ + GeodeRec *pGeode = GEODEPTR(pScrni); + + if (!GXMapMem(pScrni)) + return FALSE; + + if (pGeode->useVGA) + pGeode->FBVGAActive = gu2_get_vga_active(); + + gfx_wait_until_idle(); + + /* Save off the current state (should this be somewhere else)? */ + + 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(); + + pGeode->FBDisplayOffset = gfx_get_display_offset(); + + if (pGeode->useVGA) { + vgaHWPtr pvgaHW = VGAHWPTR(pScrni); + pGeode->FBBIOSMode = pvgaHW->readCrtc(pvgaHW, 0x040); + } + + pGeode->FBCompressionEnable = gfx_get_compression_enable(); + pGeode->FBCompressionOffset = gfx_get_compression_offset(); + pGeode->FBCompressionPitch = gfx_get_compression_pitch(); + pGeode->FBCompressionSize = gfx_get_compression_size(); + +#ifdef PNL_SUP + Pnl_SavePanelState(); +#endif + + /* Turn off the VGA */ + + if (pGeode->useVGA && pGeode->FBVGAActive) { + unsigned short sequencer; + vgaHWPtr pvgaHW = VGAHWPTR(pScrni); + + /* Map VGA aperture */ + if (!vgaHWMapMem(pScrni)) + return FALSE; + + /* Unlock VGA registers */ + vgaHWUnlock(pvgaHW); + + /* Save the current state and setup the current mode */ + vgaHWSave(pScrni, &VGAHWPTR(pScrni)->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); + } + + /* Set up the memory */ + /* XXX - FIXME - when we alow inital rotation, it should be here */ + GXAllocateMemory(pScrn, pScrni, pGeode->rotation); + + /* Clear the framebuffer */ + memset(pGeode->FBBase + pGeode->displayOffset, 0, pGeode->displaySize); + + /* Set up the video mode */ + GXSetVideoMode(pScrni, pScrni->currentMode); + pGeode->curMode = pScrni->currentMode; + + return TRUE; +} + +static void +GXLoadPalette(ScrnInfoPtr pScrni, + 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)); + + GFX(set_display_palette_entry(index, color)); + } +} + +#ifdef DPMSExtension +static void +GXPanelPower(int enable) +{ + unsigned long power = READ_VID32(RCDF_POWER_MANAGEMENT); + + if (enable != 0) + power |= RCDF_PM_PANEL_POWER_ON; + else + power &= ~RCDF_PM_PANEL_POWER_ON; + + WRITE_VID32(RCDF_POWER_MANAGEMENT, power); +} + +static void +GXDPMSSet(ScrnInfoPtr pScrni, int mode, int flags) +{ + GeodeRec *pGeode; + + pGeode = GEODEPTR(pScrni); + + if (!pScrni->vtSema) + return; + + switch (mode) { + case DPMSModeOn: + /* Screen: On; HSync: On; VSync: On */ + GFX(set_crt_enable(CRT_ENABLE)); +#if defined(PNL_SUP) + if (pGeode->Panel) { + Pnl_PowerUp(); + GXPanelPower(1); + } +#endif + break; + + case DPMSModeStandby: + /* Screen: Off; HSync: Off; VSync: On */ + GFX(set_crt_enable(CRT_STANDBY)); +#if defined(PNL_SUP) + if (pGeode->Panel) { + Pnl_PowerDown(); + GXPanelPower(0); + } +#endif + break; + + case DPMSModeSuspend: + /* Screen: Off; HSync: On; VSync: Off */ + GFX(set_crt_enable(CRT_SUSPEND)); +#if defined(PNL_SUP) + if (pGeode->Panel) { + Pnl_PowerDown(); + GXPanelPower(0); + } +#endif + break; + + case DPMSModeOff: + /* Screen: Off; HSync: Off; VSync: Off */ + GFX(set_crt_enable(CRT_DISABLE)); +#if defined(PNL_SUP) + if (pGeode->Panel) { + Pnl_PowerDown(); + GXPanelPower(0); + } +#endif + break; + } +} +#endif + +static Bool +GXCreateScreenResources(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrni = xf86Screens[pScreen->myNum]; + GeodeRec *pGeode = GEODEPTR(pScrni); + + pScreen->CreateScreenResources = pGeode->CreateScreenResources; + if (!(*pScreen->CreateScreenResources) (pScreen)) + return FALSE; + + if (xf86LoaderCheckSymbol("GXRandRSetConfig") + && pGeode->rotation != RR_Rotate_0) { + Rotation(*GXRandRSetConfig) (ScreenPtr pScreen, Rotation rr, int rate, + RRScreenSizePtr pSize) = NULL; + + RRScreenSize p; + Rotation requestedRotation = pGeode->rotation; + + pGeode->rotation = RR_Rotate_0; + + /* Just setup enough for an initial rotate */ + + p.width = pScreen->width; + p.height = pScreen->height; + p.mmWidth = pScreen->mmWidth; + p.mmHeight = pScreen->mmHeight; + + GXRandRSetConfig = LoaderSymbol("GXRandRSetConfig"); + if (GXRandRSetConfig) { + pGeode->starting = TRUE; + (*GXRandRSetConfig) (pScreen, requestedRotation, 0, &p); + pGeode->starting = FALSE; + } + } + + return TRUE; +} + +static Bool +GXScreenInit(int scrnIndex, ScreenPtr pScrn, int argc, char **argv) +{ + ScrnInfoPtr pScrni = xf86Screens[scrnIndex]; + GeodeRec *pGeode = GEODEPTR(pScrni); + XF86ModReqInfo shadowReq; + int maj, min, ret, rotate; + + pGeode->starting = TRUE; + + /* If we are using VGA then go ahead and map the memory */ + + if (pGeode->useVGA) { + + if (!vgaHWMapMem(pScrni)) + return FALSE; + + vgaHWGetIOBase(VGAHWPTR(pScrni)); + } + + if (!pGeode->NoAccel) { + + if (pGeode->useEXA) { + + if (!(pGeode->pExa = xnfcalloc(sizeof(ExaDriverRec), 1))) { + xf86DrvMsg(scrnIndex, X_ERROR, + "Couldn't allocate the EXA structure.\n"); + pGeode->NoAccel = TRUE; + } else { + ExaDriverPtr pExa = pGeode->pExa; + + /* THis is set in GXAllocMem */ + pExa->memoryBase = 0; + + /* This is set in GXAllocateMemory */ + pExa->memorySize = 0; + + pExa->pixmapOffsetAlign = 32; + pExa->pixmapPitchAlign = 32; + pExa->flags = EXA_OFFSCREEN_PIXMAPS; + pExa->maxX = pGeode->maxWidth - 1; + pExa->maxY = pGeode->maxHeight - 1; + } + } else { + pGeode->AccelImageWriteBuffers = + xcalloc(sizeof(pGeode->AccelImageWriteBuffers[0]), + pGeode->NoOfImgBuffers); + pGeode->AccelColorExpandBuffers = + xcalloc(sizeof(pGeode->AccelColorExpandBuffers[0]), + pGeode->NoOfColorExpandLines); + } + } + + /* XXX FIXME - Take down any of the structures on failure? */ + + if (!GXEnterGraphics(pScrn, pScrni)) + return FALSE; + + miClearVisualTypes(); + + /* XXX Again - take down anything? */ + + if (pScrni->bitsPerPixel > 8) { + if (!miSetVisualTypes(pScrni->depth, + TrueColorMask, pScrni->rgbBits, pScrni->defaultVisual)) { + return FALSE; + } + } else { + if (!miSetVisualTypes(pScrni->depth, + miGetDefaultVisualMask(pScrni->depth), + pScrni->rgbBits, pScrni->defaultVisual)) { + return FALSE; + } + } + + miSetPixmapDepths(); + + /* Point at the visible area to start */ + + ret = fbScreenInit(pScrn, pGeode->FBBase + pGeode->displayOffset, + pScrni->virtualX, pScrni->virtualY, + pScrni->xDpi, pScrni->yDpi, pGeode->displayWidth, + pScrni->bitsPerPixel); + + if (!ret) + return FALSE; + + xf86SetBlackWhitePixels(pScrn); + + /* Set up the color ordering */ + + if (pScrni->bitsPerPixel > 8) { + VisualPtr visual = pScrn->visuals + pScrn->numVisuals; + + while (--visual >= pScrn->visuals) { + if ((visual->class | DynamicClass) == DirectColor) { + visual->offsetRed = pScrni->offset.red; + visual->offsetGreen = pScrni->offset.green; + visual->offsetBlue = pScrni->offset.blue; + visual->redMask = pScrni->mask.red; + visual->greenMask = pScrni->mask.green; + visual->blueMask = pScrni->mask.blue; + } + } + } + + /* Must follow the color ordering */ + fbPictureInit(pScrn, 0, 0); + + if (!pGeode->NoAccel) + GXAccelInit(pScrn); + + miInitializeBackingStore(pScrn); + xf86SetBackingStore(pScrn); + + /* Set up the soft cursor */ + miDCInitialize(pScrn, xf86GetPointerScreenFuncs()); + + /* Set up the HW cursor - must follow the soft cursor init */ + + if (pGeode->tryHWCursor) { + if (!GXHWCursorInit(pScrn)) + xf86DrvMsg(scrnIndex, X_ERROR, + "Hardware cursor initialization failed.\n"); + } + + /* Set up the color map */ + + if (!miCreateDefColormap(pScrn)) + return FALSE; + + if (pScrni->bitsPerPixel == 8) { + /* Must follow initialization of the default colormap */ + + if (!xf86HandleColormaps(pScrn, 256, 8, + GXLoadPalette, NULL, + CMAP_PALETTED_TRUECOLOR | CMAP_RELOAD_ON_MODE_SWITCH)) { + return FALSE; + } + } +#ifdef DPMSExtension + xf86DPMSInit(pScrn, GXDPMSSet, 0); +#endif + + GXInitVideo(pScrn); + + /* Set up RandR */ + + xf86DisableRandR(); /* We provide our own RandR goodness */ + + /* Try to set up the shadow FB for rotation */ + + memset(&shadowReq, 0, sizeof(shadowReq)); + shadowReq.majorversion = 1; + shadowReq.minorversion = 1; + + if (LoadSubModule(pScrni->module, "shadow", + NULL, NULL, NULL, &shadowReq, &maj, &min)) { + + rotate = RR_Rotate_0 | RR_Rotate_90 | RR_Rotate_180 | RR_Rotate_270; + shadowSetup(pScrn); + } else { + LoaderErrorMsg(NULL, "shadow", maj, min); + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Error loading shadow - rotation not available.\n"); + + if (pGeode->rotation != RR_Rotate_0) + xf86DrvMsg(pScrni->scrnIndex, X_ERROR, + "Reverting back to normal rotation.\n"); + + rotate = pGeode->rotation = RR_Rotate_0; + } + + GXRandRInit(pScrn, rotate); + + pGeode->PointerMoved = pScrni->PointerMoved; + pScrni->PointerMoved = GeodePointerMoved; + + pGeode->CreateScreenResources = pScrn->CreateScreenResources; + pScrn->CreateScreenResources = GXCreateScreenResources; + + pGeode->CloseScreen = pScrn->CloseScreen; + pScrn->CloseScreen = GXCloseScreen; + pScrn->SaveScreen = GXSaveScreen; + + if (serverGeneration == 1) + xf86ShowUnusedOptions(pScrni->scrnIndex, pScrni->options); + + pGeode->starting = FALSE; + + return TRUE; +} + +static int +GXValidMode(int scrnIndex, DisplayModePtr pMode, Bool Verbose, int flags) +{ + ScrnInfoPtr pScrni = xf86Screens[scrnIndex]; + GeodeRec *pGeode = GEODEPTR(pScrni); + int p, ret; + int custom = 0; + + if (pGeode->Panel) + custom = (pMode->type & M_T_USERDEF); + else + custom = (pMode->type & (M_T_BUILTIN | M_T_DEFAULT)); + + /* Use the durango lookup for !custom modes */ + + if (!custom) { + if (pGeode->Panel) { + if (pMode->CrtcHDisplay > pGeode->PanelX || + pMode->CrtcVDisplay > pGeode->PanelY || + gfx_is_panel_mode_supported(pGeode->PanelX, pGeode->PanelY, + pMode->CrtcHDisplay, pMode->CrtcVDisplay, + pScrni->bitsPerPixel) < 0) { + + return MODE_BAD; + } + } + + ret = gfx_is_display_mode_supported(pMode->CrtcHDisplay, + pMode->CrtcVDisplay, + pScrni->bitsPerPixel, + GeodeGetRefreshRate(pMode)); + if (ret < 0) + return MODE_BAD; + } + + if (pMode->Flags & V_INTERLACE) + return MODE_NO_INTERLACE; + + if (pGeode->tryCompression) + p = GeodeCalculatePitchBytes(pMode->CrtcHDisplay, pScrni->bitsPerPixel); + else + p = ((pMode->CrtcHDisplay + 3) & ~3) * (pScrni->bitsPerPixel >> 3); + + if (p * pMode->CrtcVDisplay > pGeode->FBAvail) + return MODE_MEM; + + return MODE_OK; +} + +/* XXX - Way more to do here */ + +static Bool +GXEnterVT(int scrnIndex, int flags) +{ + return GXEnterGraphics(NULL, xf86Screens[scrnIndex]); +} + +static void +GXLeaveVT(int scrnIndex, int flags) +{ + ScrnInfoPtr pScrni = xf86Screens[scrnIndex]; + GeodeRec *pGeode = GEODEPTR(pScrni); + + pGeode->PrevDisplayOffset = gfx_get_display_offset(); + GXLeaveGraphics(xf86Screens[scrnIndex]); +} + +void +GXSetupChipsetFPtr(ScrnInfoPtr pScrn) +{ + pScrn->PreInit = GXPreInit; + pScrn->ScreenInit = GXScreenInit; + pScrn->SwitchMode = GXSwitchMode; + pScrn->AdjustFrame = GXAdjustFrame; + pScrn->EnterVT = GXEnterVT; + pScrn->LeaveVT = GXLeaveVT; + pScrn->FreeScreen = GeodeFreeScreen; + pScrn->ValidMode = GXValidMode; +} + +/* ====== Common functions ====== + * These are all the common functions that we use for both GX and LX - They live here + * because most of them came along for the GX first, and then were adapted to the LX. + * We could move these to a common function, but there is no hurry + * ============================== */ + + +void +GeodePointerMoved(int index, int x, int y) +{ + ScrnInfoPtr pScrni = xf86Screens[index]; + GeodeRec *pGeode = GEODEPTR(pScrni); + + int newX = x, newY = y; + + switch (pGeode->rotation) { + case RR_Rotate_0: + break; + case RR_Rotate_90: + newX = y; + newY = pScrni->pScreen->width - x - 1; + break; + case RR_Rotate_180: + newX = pScrni->pScreen->width - x - 1; + newY = pScrni->pScreen->height - y - 1; + break; + case RR_Rotate_270: + newX = pScrni->pScreen->height - y - 1; + newY = x; + break; + } + + (*pGeode->PointerMoved)(index, newX, newY); +} + +void +GeodeProbeDDC(ScrnInfoPtr pScrni, int index) +{ + vbeInfoPtr pVbe; + + if (xf86LoadSubModule(pScrni, "vbe")) { + pVbe = VBEInit(NULL, index); + ConfiguredMonitor = vbeDoEDID(pVbe, NULL); + vbeFree(pVbe); + } +} + +xf86MonPtr +GeodeDoDDC(ScrnInfoPtr pScrni, int index) +{ + vbeInfoPtr pVbe; + xf86MonPtr info = NULL; + + if (xf86LoadSubModule(pScrni, "vbe") && + (pVbe = VBEInit(NULL, index))) { + xf86LoaderReqSymLists(amdVbeSymbols, NULL); + info = vbeDoEDID(pVbe, NULL); + xf86PrintEDID(info); + xf86SetDDCproperties(pScrni, info); + vbeFree(pVbe); + } else + xf86DrvMsg(pScrni->scrnIndex, X_INFO, + "We cannot do DDC without VBE.\n"); + + return info; +} + +int +GeodeGetFPGeometry(const char *str, int *width, int *height) +{ + + int ret = sscanf(str, "%dx%d", width, height); + + return (ret == 2) ? 0 : 1; +} + +static void +GeodeFreeRec(ScrnInfoPtr pScrni) +{ + if (pScrni->driverPrivate != NULL) { + xfree(pScrni->driverPrivate); + pScrni->driverPrivate = NULL; + } +} + +void +GeodeFreeScreen(int scrnIndex, int flags) +{ + GeodeRec *pGeode = GEODEPTR(xf86Screens[scrnIndex]); + + if (pGeode == NULL) + return; + + if (pGeode->useVGA) { + if (xf86LoaderCheckSymbol("vgaHWFreeHWRec")) + vgaHWFreeHWRec(xf86Screens[scrnIndex]); + } + + GeodeFreeRec(xf86Screens[scrnIndex]); +} + +int +GeodeCalculatePitchBytes(unsigned int width, unsigned int bpp) +{ + + int delta = width * (bpp >> 3); + + /* Less then 640 has doubling enabled */ + + if (width < 640) + delta <<= 1; + + /* Calculate the pitch (compression rquires a power of 2) */ + + if (delta > 4096) + delta = 8192; + else if (delta > 2048) + delta = 4096; + else if (delta > 1024) + delta = 2048; + else + delta = 1024; + + return delta; +} + |