xf86-video-intel: 2 commits - src/legacy/i810
Dave Airlie
airlied at kemper.freedesktop.org
Wed May 23 00:42:25 PDT 2012
src/legacy/i810/i810_driver.c | 630 +++++++++++++++++++++---------------------
src/legacy/i810/i810_video.c | 56 +--
2 files changed, 343 insertions(+), 343 deletions(-)
New commits:
commit c9ce6ae8a6fc7b1a91aef1e59640c39024d0426d
Author: Dave Airlie <airlied at redhat.com>
Date: Wed May 23 08:33:20 2012 +0100
legacy/i810: rename pScreen->screen
For consistency before moving to new APIs.
This just changes the files where the API changes will touch.
Signed-off-by: Dave Airlie <airlied at redhat.com>
diff --git a/src/legacy/i810/i810_driver.c b/src/legacy/i810/i810_driver.c
index 76f36f2..60053d8 100644
--- a/src/legacy/i810/i810_driver.c
+++ b/src/legacy/i810/i810_driver.c
@@ -78,12 +78,12 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "../legacy.h"
static Bool I810PreInit(ScrnInfoPtr scrn, int flags);
-static Bool I810ScreenInit(int Index, ScreenPtr pScreen, int argc,
+static Bool I810ScreenInit(int Index, ScreenPtr screen, int argc,
char **argv);
static Bool I810EnterVT(int scrnIndex, int flags);
static void I810LeaveVT(int scrnIndex, int flags);
-static Bool I810CloseScreen(int scrnIndex, ScreenPtr pScreen);
-static Bool I810SaveScreen(ScreenPtr pScreen, Bool unblank);
+static Bool I810CloseScreen(int scrnIndex, ScreenPtr screen);
+static Bool I810SaveScreen(ScreenPtr screen, Bool unblank);
static void I810FreeScreen(int scrnIndex, int flags);
static void I810DisplayPowerManagementSet(ScrnInfoPtr scrn,
int PowerManagermentMode,
@@ -1570,14 +1570,14 @@ I810AllocateFront(ScrnInfoPtr scrn)
}
static Bool
-I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
+I810ScreenInit(int scrnIndex, ScreenPtr screen, int argc, char **argv)
{
ScrnInfoPtr scrn;
vgaHWPtr hwp;
I810Ptr pI810;
VisualPtr visual;
- scrn = xf86Screens[pScreen->myNum];
+ scrn = xf86Screens[screen->myNum];
pI810 = I810PTR(scrn);
hwp = VGAHWPTR(scrn);
@@ -1623,7 +1623,7 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
pI810->directRenderingEnabled = !pI810->directRenderingDisabled;
if (pI810->directRenderingEnabled==TRUE)
- pI810->directRenderingEnabled = I810DRIScreenInit(pScreen);
+ pI810->directRenderingEnabled = I810DRIScreenInit(screen);
#else
pI810->directRenderingEnabled = FALSE;
@@ -1648,10 +1648,10 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
if (!I810ModeInit(scrn, scrn->currentMode))
return FALSE;
- I810SaveScreen(pScreen, FALSE);
+ I810SaveScreen(screen, FALSE);
I810AdjustFrame(scrnIndex, scrn->frameX0, scrn->frameY0, 0);
- if (!fbScreenInit(pScreen, pI810->FbBase + scrn->fbOffset,
+ if (!fbScreenInit(screen, pI810->FbBase + scrn->fbOffset,
scrn->virtualX, scrn->virtualY,
scrn->xDpi, scrn->yDpi,
scrn->displayWidth, scrn->bitsPerPixel))
@@ -1659,8 +1659,8 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
if (scrn->bitsPerPixel > 8) {
/* Fixup RGB ordering */
- visual = pScreen->visuals + pScreen->numVisuals;
- while (--visual >= pScreen->visuals) {
+ visual = screen->visuals + screen->numVisuals;
+ while (--visual >= screen->visuals) {
if ((visual->class | DynamicClass) == DirectColor) {
visual->offsetRed = scrn->offset.red;
visual->offsetGreen = scrn->offset.green;
@@ -1672,14 +1672,14 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
}
}
- fbPictureInit(pScreen, NULL, 0);
+ fbPictureInit(screen, NULL, 0);
- xf86SetBlackWhitePixels(pScreen);
+ xf86SetBlackWhitePixels(screen);
#ifdef HAVE_DRI1
if (pI810->LpRing->mem.Start == 0 && pI810->directRenderingEnabled) {
pI810->directRenderingEnabled = FALSE;
- I810DRICloseScreen(pScreen);
+ I810DRICloseScreen(screen);
}
if (!pI810->directRenderingEnabled) {
@@ -1692,10 +1692,10 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
#endif
#ifdef XFreeXDGA
- I810DGAInit(pScreen);
+ I810DGAInit(screen);
#endif
- if (!xf86InitFBManager(pScreen, &(pI810->FbMemBox))) {
+ if (!xf86InitFBManager(screen, &(pI810->FbMemBox))) {
xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Failed to init memory manager\n");
return FALSE;
@@ -1705,7 +1705,7 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
if (pI810->LpRing->mem.Size != 0) {
I810SetRingRegs(scrn);
- if (!I810AccelInit(pScreen)) {
+ if (!I810AccelInit(screen)) {
xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Hardware acceleration initialization failed\n");
} else /* PK added 16.02.2004 */
@@ -1713,57 +1713,57 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
}
}
- miInitializeBackingStore(pScreen);
- xf86SetBackingStore(pScreen);
- xf86SetSilkenMouse(pScreen);
+ miInitializeBackingStore(screen);
+ xf86SetBackingStore(screen);
+ xf86SetSilkenMouse(screen);
- miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
+ miDCInitialize(screen, xf86GetPointerScreenFuncs());
if (!xf86ReturnOptValBool(pI810->Options, OPTION_SW_CURSOR, FALSE)) {
- if (!I810CursorInit(pScreen)) {
+ if (!I810CursorInit(screen)) {
xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Hardware cursor initialization failed\n");
}
}
- if (!miCreateDefColormap(pScreen))
+ if (!miCreateDefColormap(screen))
return FALSE;
/* Use driver specific palette load routines for Direct Color support. -jens */
if (scrn->bitsPerPixel == 16) {
if (scrn->depth == 15) {
- if (!xf86HandleColormaps(pScreen, 256, 8, I810LoadPalette15, NULL,
+ if (!xf86HandleColormaps(screen, 256, 8, I810LoadPalette15, NULL,
CMAP_PALETTED_TRUECOLOR |
CMAP_RELOAD_ON_MODE_SWITCH))
return FALSE;
} else {
- if (!xf86HandleColormaps(pScreen, 256, 8, I810LoadPalette16, NULL,
+ if (!xf86HandleColormaps(screen, 256, 8, I810LoadPalette16, NULL,
CMAP_PALETTED_TRUECOLOR |
CMAP_RELOAD_ON_MODE_SWITCH))
return FALSE;
}
} else {
- if (!xf86HandleColormaps(pScreen, 256, 8, I810LoadPalette24, NULL,
+ if (!xf86HandleColormaps(screen, 256, 8, I810LoadPalette24, NULL,
CMAP_PALETTED_TRUECOLOR |
CMAP_RELOAD_ON_MODE_SWITCH))
return FALSE;
}
- xf86DPMSInit(pScreen, I810DisplayPowerManagementSet, 0);
+ xf86DPMSInit(screen, I810DisplayPowerManagementSet, 0);
- I810InitVideo(pScreen);
+ I810InitVideo(screen);
#ifdef HAVE_DRI1
if (pI810->directRenderingEnabled) {
/* Now that mi, fb, drm and others have done their thing,
* complete the DRI setup.
*/
- pI810->directRenderingEnabled = I810DRIFinishScreenInit(pScreen);
+ pI810->directRenderingEnabled = I810DRIFinishScreenInit(screen);
}
#ifdef XvMCExtension
if ((pI810->directRenderingEnabled) && (pI810->numSurfaces)) {
/* Initialize the hardware motion compensation code */
- I810InitMC(pScreen);
+ I810InitMC(screen);
}
#endif
#endif
@@ -1774,9 +1774,9 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
xf86DrvMsg(scrn->scrnIndex, X_WARNING, "Direct rendering disabled\n");
}
- pScreen->SaveScreen = I810SaveScreen;
- pI810->CloseScreen = pScreen->CloseScreen;
- pScreen->CloseScreen = I810CloseScreen;
+ screen->SaveScreen = I810SaveScreen;
+ pI810->CloseScreen = screen->CloseScreen;
+ screen->CloseScreen = I810CloseScreen;
if (serverGeneration == 1)
xf86ShowUnusedOptions(scrn->scrnIndex, scrn->options);
@@ -1957,7 +1957,7 @@ I810LeaveVT(int scrnIndex, int flags)
}
static Bool
-I810CloseScreen(int scrnIndex, ScreenPtr pScreen)
+I810CloseScreen(int scrnIndex, ScreenPtr screen)
{
ScrnInfoPtr scrn = xf86Screens[scrnIndex];
vgaHWPtr hwp = VGAHWPTR(scrn);
@@ -1975,7 +1975,7 @@ I810CloseScreen(int scrnIndex, ScreenPtr pScreen)
}
#ifdef HAVE_DRI1
if (pI810->directRenderingEnabled) {
- I810DRICloseScreen(pScreen);
+ I810DRICloseScreen(screen);
pI810->directRenderingEnabled = FALSE;
}
#endif
@@ -2021,8 +2021,8 @@ I810CloseScreen(int scrnIndex, ScreenPtr pScreen)
pI810->LpRing = NULL;
scrn->vtSema = FALSE;
- pScreen->CloseScreen = pI810->CloseScreen;
- return (*pScreen->CloseScreen) (scrnIndex, pScreen);
+ screen->CloseScreen = pI810->CloseScreen;
+ return (*screen->CloseScreen) (scrnIndex, screen);
}
static void
@@ -2047,9 +2047,9 @@ I810ValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
}
static Bool
-I810SaveScreen(ScreenPtr pScreen, Bool unblack)
+I810SaveScreen(ScreenPtr screen, Bool unblack)
{
- return vgaHWSaveScreen(pScreen, unblack);
+ return vgaHWSaveScreen(screen, unblack);
}
static void
diff --git a/src/legacy/i810/i810_video.c b/src/legacy/i810/i810_video.c
index a0e6acd..5a568a6 100644
--- a/src/legacy/i810/i810_video.c
+++ b/src/legacy/i810/i810_video.c
@@ -152,17 +152,17 @@ static Atom xvBrightness, xvContrast, xvColorKey;
#define RGB15ToColorKey(c) \
(((c & 0x7c00) << 9) | ((c & 0x03E0) << 6) | ((c & 0x001F) << 3))
-void I810InitVideo(ScreenPtr pScreen)
+void I810InitVideo(ScreenPtr screen)
{
- ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ ScrnInfoPtr pScrn = xf86Screens[screen->myNum];
XF86VideoAdaptorPtr *adaptors, *newAdaptors = NULL;
XF86VideoAdaptorPtr newAdaptor = NULL;
int num_adaptors;
if (pScrn->bitsPerPixel != 8)
{
- newAdaptor = I810SetupImageVideo(pScreen);
- I810InitOffscreenImages(pScreen);
+ newAdaptor = I810SetupImageVideo(screen);
+ I810InitOffscreenImages(screen);
}
num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);
@@ -185,7 +185,7 @@ void I810InitVideo(ScreenPtr pScreen)
}
if(num_adaptors)
- xf86XVScreenInit(pScreen, adaptors, num_adaptors);
+ xf86XVScreenInit(screen, adaptors, num_adaptors);
if(newAdaptors)
free(newAdaptors);
@@ -375,9 +375,9 @@ static void I810ResetVideo(ScrnInfoPtr pScrn)
static XF86VideoAdaptorPtr
-I810SetupImageVideo(ScreenPtr pScreen)
+I810SetupImageVideo(ScreenPtr screen)
{
- ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ ScrnInfoPtr pScrn = xf86Screens[screen->myNum];
I810Ptr pI810 = I810PTR(pScrn);
XF86VideoAdaptorPtr adapt;
I810PortPrivPtr pPriv;
@@ -423,12 +423,12 @@ I810SetupImageVideo(ScreenPtr pScreen)
pPriv->currentBuf = 0;
/* gotta uninit this someplace */
- REGION_NULL(pScreen, &pPriv->clip);
+ REGION_NULL(screen, &pPriv->clip);
pI810->adaptor = adapt;
- pI810->BlockHandler = pScreen->BlockHandler;
- pScreen->BlockHandler = I810BlockHandler;
+ pI810->BlockHandler = screen->BlockHandler;
+ screen->BlockHandler = I810BlockHandler;
xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");
xvContrast = MAKE_ATOM("XV_CONTRAST");
@@ -522,7 +522,7 @@ I810StopVideo(ScrnInfoPtr pScrn, pointer data, Bool shutdown)
I810OverlayRegPtr overlay = (I810OverlayRegPtr) (pI810->FbBase + pI810->OverlayStart);
- REGION_EMPTY(pScrn->pScreen, &pPriv->clip);
+ REGION_EMPTY(pScrn->screen, &pPriv->clip);
if(shutdown) {
if(pPriv->videoStatus & CLIENT_VIDEO_ON) {
@@ -579,7 +579,7 @@ I810SetPortAttribute(
break;
}
OVERLAY_UPDATE(pI810->OverlayPhysical);
- REGION_EMPTY(pScrn->pScreen, &pPriv->clip);
+ REGION_EMPTY(pScrn->screen, &pPriv->clip);
} else return BadMatch;
return Success;
@@ -928,7 +928,7 @@ I810AllocateMemory(
FBLinearPtr linear,
int size
){
- ScreenPtr pScreen;
+ ScreenPtr screen;
FBLinearPtr new_linear;
if(linear) {
@@ -941,21 +941,21 @@ I810AllocateMemory(
xf86FreeOffscreenLinear(linear);
}
- pScreen = screenInfo.screens[pScrn->scrnIndex];
+ screen = screenInfo.screens[pScrn->scrnIndex];
- new_linear = xf86AllocateOffscreenLinear(pScreen, size, 4,
+ new_linear = xf86AllocateOffscreenLinear(screen, size, 4,
NULL, NULL, NULL);
if(!new_linear) {
int max_size;
- xf86QueryLargestOffscreenLinear(pScreen, &max_size, 4,
+ xf86QueryLargestOffscreenLinear(screen, &max_size, 4,
PRIORITY_EXTREME);
if(max_size < size) return NULL;
- xf86PurgeUnlockedOffscreenAreas(pScreen);
- new_linear = xf86AllocateOffscreenLinear(pScreen, size, 4,
+ xf86PurgeUnlockedOffscreenAreas(screen);
+ new_linear = xf86AllocateOffscreenLinear(screen, size, 4,
NULL, NULL, NULL);
}
@@ -995,7 +995,7 @@ I810PutImage(
dstBox.y2 = drw_y + drw_h;
I810ClipVideo(&dstBox, &x1, &x2, &y1, &y2,
- REGION_EXTENTS(pScrn->pScreen, clipBoxes), width, height);
+ REGION_EXTENTS(pScrn->screen, clipBoxes), width, height);
if((x1 >= x2) || (y1 >= y2))
return Success;
@@ -1081,8 +1081,8 @@ I810PutImage(
}
/* update cliplist */
- if(!REGION_EQUAL(pScrn->pScreen, &pPriv->clip, clipBoxes)) {
- REGION_COPY(pScrn->pScreen, &pPriv->clip, clipBoxes);
+ if(!REGION_EQUAL(pScrn->screen, &pPriv->clip, clipBoxes)) {
+ REGION_COPY(pScrn->screen, &pPriv->clip, clipBoxes);
/* draw these */
xf86XVFillKeyHelperDrawable(pDraw, pPriv->colorKey, clipBoxes);
}
@@ -1151,17 +1151,17 @@ I810BlockHandler (
pointer pTimeout,
pointer pReadmask
){
- ScreenPtr pScreen = screenInfo.screens[i];
+ ScreenPtr screen = screenInfo.screens[i];
ScrnInfoPtr pScrn = xf86Screens[i];
I810Ptr pI810 = I810PTR(pScrn);
I810PortPrivPtr pPriv = GET_PORT_PRIVATE(pScrn);
I810OverlayRegPtr overlay = (I810OverlayRegPtr) (pI810->FbBase + pI810->OverlayStart);
- pScreen->BlockHandler = pI810->BlockHandler;
+ screen->BlockHandler = pI810->BlockHandler;
- (*pScreen->BlockHandler) (i, blockData, pTimeout, pReadmask);
+ (*screen->BlockHandler) (i, blockData, pTimeout, pReadmask);
- pScreen->BlockHandler = I810BlockHandler;
+ screen->BlockHandler = I810BlockHandler;
if(pPriv->videoStatus & TIMER_MASK) {
UpdateCurrentTime();
@@ -1382,7 +1382,7 @@ I810DisplaySurface(
pPriv->isOn = TRUE;
/* we've prempted the XvImage stream so set its free timer */
if(pI810Priv->videoStatus & CLIENT_VIDEO_ON) {
- REGION_EMPTY(pScrn->pScreen, & pI810Priv->clip);
+ REGION_EMPTY(pScrn->screen, & pI810Priv->clip);
UpdateCurrentTime();
pI810Priv->videoStatus = FREE_TIMER;
pI810Priv->freeTime = currentTime.milliseconds + FREE_DELAY;
@@ -1394,7 +1394,7 @@ I810DisplaySurface(
static void
-I810InitOffscreenImages(ScreenPtr pScreen)
+I810InitOffscreenImages(ScreenPtr screen)
{
XF86OffscreenImagePtr offscreenImages;
@@ -1417,6 +1417,6 @@ I810InitOffscreenImages(ScreenPtr pScreen)
offscreenImages[0].num_attributes = 1;
offscreenImages[0].attributes = Attributes;
- xf86XVRegisterOffscreenImages(pScreen, offscreenImages, 1);
+ xf86XVRegisterOffscreenImages(screen, offscreenImages, 1);
}
commit 70ee0f84f5b9c6c13a0338f8b2757e587c849c14
Author: Dave Airlie <airlied at redhat.com>
Date: Wed May 23 08:31:52 2012 +0100
legacy/i810: rename pScrn->scrn
This is need to make the compat api stuff easier to implement.
Signed-off-by: Dave Airlie <airlied at redhat.com>
diff --git a/src/legacy/i810/i810_driver.c b/src/legacy/i810/i810_driver.c
index 02da574..76f36f2 100644
--- a/src/legacy/i810/i810_driver.c
+++ b/src/legacy/i810/i810_driver.c
@@ -77,7 +77,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "../legacy.h"
-static Bool I810PreInit(ScrnInfoPtr pScrn, int flags);
+static Bool I810PreInit(ScrnInfoPtr scrn, int flags);
static Bool I810ScreenInit(int Index, ScreenPtr pScreen, int argc,
char **argv);
static Bool I810EnterVT(int scrnIndex, int flags);
@@ -85,7 +85,7 @@ static void I810LeaveVT(int scrnIndex, int flags);
static Bool I810CloseScreen(int scrnIndex, ScreenPtr pScreen);
static Bool I810SaveScreen(ScreenPtr pScreen, Bool unblank);
static void I810FreeScreen(int scrnIndex, int flags);
-static void I810DisplayPowerManagementSet(ScrnInfoPtr pScrn,
+static void I810DisplayPowerManagementSet(ScrnInfoPtr scrn,
int PowerManagermentMode,
int flags);
static ModeStatus I810ValidMode(int scrnIndex, DisplayModePtr mode,
@@ -152,24 +152,24 @@ int I830EntityIndex = -1;
*
*/
static Bool
-I810GetRec(ScrnInfoPtr pScrn)
+I810GetRec(ScrnInfoPtr scrn)
{
- if (pScrn->driverPrivate)
+ if (scrn->driverPrivate)
return TRUE;
- pScrn->driverPrivate = xnfcalloc(sizeof(I810Rec), 1);
+ scrn->driverPrivate = xnfcalloc(sizeof(I810Rec), 1);
return TRUE;
}
static void
-I810FreeRec(ScrnInfoPtr pScrn)
+I810FreeRec(ScrnInfoPtr scrn)
{
- if (!pScrn)
+ if (!scrn)
return;
- if (!pScrn->driverPrivate)
+ if (!scrn->driverPrivate)
return;
- free(pScrn->driverPrivate);
- pScrn->driverPrivate = NULL;
+ free(scrn->driverPrivate);
+ scrn->driverPrivate = NULL;
}
struct pci_device *
@@ -188,11 +188,11 @@ intel_host_bridge (void)
}
static void
-I810ProbeDDC(ScrnInfoPtr pScrn, int index)
+I810ProbeDDC(ScrnInfoPtr scrn, int index)
{
vbeInfoPtr pVbe;
- if (xf86LoadSubModule(pScrn, "vbe")) {
+ if (xf86LoadSubModule(scrn, "vbe")) {
pVbe = VBEInit(NULL, index);
ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
vbeFree(pVbe);
@@ -200,24 +200,24 @@ I810ProbeDDC(ScrnInfoPtr pScrn, int index)
}
static xf86MonPtr
-I810DoDDC(ScrnInfoPtr pScrn, int index)
+I810DoDDC(ScrnInfoPtr scrn, int index)
{
vbeInfoPtr pVbe;
xf86MonPtr MonInfo = NULL;
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
/* Honour Option "noDDC" */
if (xf86ReturnOptValBool(pI810->Options, OPTION_NO_DDC, FALSE)) {
return MonInfo;
}
- if (xf86LoadSubModule(pScrn, "vbe") && (pVbe = VBEInit(NULL, index))) {
+ if (xf86LoadSubModule(scrn, "vbe") && (pVbe = VBEInit(NULL, index))) {
MonInfo = vbeDoEDID(pVbe, NULL);
xf86PrintEDID(MonInfo);
- xf86SetDDCproperties(pScrn, MonInfo);
+ xf86SetDDCproperties(scrn, MonInfo);
vbeFree(pVbe);
} else {
- xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ xf86DrvMsg(scrn->scrnIndex, X_INFO,
"this driver cannot do DDC without VBE\n");
}
@@ -232,7 +232,7 @@ I810DoDDC(ScrnInfoPtr pScrn, int index)
*
*/
static Bool
-I810PreInit(ScrnInfoPtr pScrn, int flags)
+I810PreInit(ScrnInfoPtr scrn, int flags)
{
I810Ptr pI810;
ClockRangePtr clockRanges;
@@ -244,89 +244,89 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
Bool enable;
struct intel_chipset chipset;
- if (pScrn->numEntities != 1)
+ if (scrn->numEntities != 1)
return FALSE;
/* Allocate driverPrivate */
- if (!I810GetRec(pScrn))
+ if (!I810GetRec(scrn))
return FALSE;
- pI810 = I810PTR(pScrn);
+ pI810 = I810PTR(scrn);
- pI810->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
+ pI810->pEnt = xf86GetEntityInfo(scrn->entityList[0]);
if (pI810->pEnt->location.type != BUS_PCI)
return FALSE;
if (flags & PROBE_DETECT) {
- I810ProbeDDC(pScrn, pI810->pEnt->index);
+ I810ProbeDDC(scrn, pI810->pEnt->index);
return TRUE;
}
/* The vgahw module should be loaded here when needed */
- if (!xf86LoadSubModule(pScrn, "vgahw"))
+ if (!xf86LoadSubModule(scrn, "vgahw"))
return FALSE;
/* Allocate a vgaHWRec */
- if (!vgaHWGetHWRec(pScrn))
+ if (!vgaHWGetHWRec(scrn))
return FALSE;
pI810->PciInfo = xf86GetPciInfoForEntity(pI810->pEnt->index);
- /* Set pScrn->monitor */
- pScrn->monitor = pScrn->confScreen->monitor;
+ /* Set scrn->monitor */
+ scrn->monitor = scrn->confScreen->monitor;
flags24 = Support24bppFb | PreferConvert32to24 | SupportConvert32to24;
- if (!xf86SetDepthBpp(pScrn, 16, 0, 16, flags24)) {
+ if (!xf86SetDepthBpp(scrn, 16, 0, 16, flags24)) {
return FALSE;
} else {
- switch (pScrn->depth) {
+ switch (scrn->depth) {
case 8:
case 15:
case 16:
case 24:
break;
default:
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Given depth (%d) is not supported by i810 driver\n",
- pScrn->depth);
+ scrn->depth);
return FALSE;
}
}
- xf86PrintDepthBpp(pScrn);
+ xf86PrintDepthBpp(scrn);
- switch (pScrn->bitsPerPixel) {
+ switch (scrn->bitsPerPixel) {
case 8:
case 16:
case 24:
break;
default:
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Given bpp (%d) is not supported by i810 driver\n",
- pScrn->bitsPerPixel);
+ scrn->bitsPerPixel);
return FALSE;
}
- if (!xf86SetWeight(pScrn, defaultWeight, defaultWeight))
+ if (!xf86SetWeight(scrn, defaultWeight, defaultWeight))
return FALSE;
- if (!xf86SetDefaultVisual(pScrn, -1))
+ if (!xf86SetDefaultVisual(scrn, -1))
return FALSE;
/* We use a programmable clock */
- pScrn->progClock = TRUE;
+ scrn->progClock = TRUE;
- pI810->cpp = pScrn->bitsPerPixel / 8;
+ pI810->cpp = scrn->bitsPerPixel / 8;
/* Process the options */
- xf86CollectOptions(pScrn, NULL);
+ xf86CollectOptions(scrn, NULL);
if (!(pI810->Options = malloc(sizeof(I810Options))))
return FALSE;
memcpy(pI810->Options, I810Options, sizeof(I810Options));
- xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pI810->Options);
+ xf86ProcessOptions(scrn->scrnIndex, scrn->options, pI810->Options);
- pScrn->rgbBits = 8;
+ scrn->rgbBits = 8;
if (xf86ReturnOptValBool(pI810->Options, OPTION_DAC_6BIT, FALSE))
- pScrn->rgbBits = 6;
+ scrn->rgbBits = 6;
if (xf86ReturnOptValBool(pI810->Options, OPTION_SHOW_CACHE, FALSE))
pI810->showCache = TRUE;
@@ -335,7 +335,7 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
/* 6-BIT dac isn't reasonable for modes with > 8bpp */
if (xf86ReturnOptValBool(pI810->Options, OPTION_DAC_6BIT, FALSE) &&
- pScrn->bitsPerPixel > 8) {
+ scrn->bitsPerPixel > 8) {
OptionInfoPtr ptr;
ptr = xf86TokenToOptinfo(pI810->Options, OPTION_DAC_6BIT);
@@ -346,8 +346,8 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
pI810->noAccel = TRUE;
if (!pI810->noAccel) {
- if (!xf86LoadSubModule(pScrn, "xaa")) {
- I810FreeRec(pScrn);
+ if (!xf86LoadSubModule(scrn, "xaa")) {
+ I810FreeRec(scrn);
return FALSE;
}
}
@@ -358,11 +358,11 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
if (!pI810->directRenderingDisabled) {
if (pI810->noAccel) {
- xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "DRI is disabled because it "
+ xf86DrvMsg(scrn->scrnIndex, X_WARNING, "DRI is disabled because it "
"needs 2D acceleration.\n");
pI810->directRenderingDisabled=TRUE;
- } else if (pScrn->depth!=16) {
- xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "DRI is disabled because it "
+ } else if (scrn->depth!=16) {
+ xf86DrvMsg(scrn->scrnIndex, X_WARNING, "DRI is disabled because it "
"runs only at 16-bit depth.\n");
pI810->directRenderingDisabled=TRUE;
}
@@ -373,49 +373,49 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
/* after xf86ProcessOptions,
* because it is controlled by options [no]vbe and [no]ddc
*/
- I810DoDDC(pScrn, pI810->pEnt->index);
+ I810DoDDC(scrn, pI810->pEnt->index);
- intel_detect_chipset(pScrn, pI810->PciInfo, &chipset);
+ intel_detect_chipset(scrn, pI810->PciInfo, &chipset);
/*
* Set the Chipset and ChipRev, allowing config file entries to
* override.
*/
if (pI810->pEnt->device->chipset && *pI810->pEnt->device->chipset) {
- pScrn->chipset = pI810->pEnt->device->chipset;
+ scrn->chipset = pI810->pEnt->device->chipset;
from = X_CONFIG;
} else if (pI810->pEnt->device->chipID >= 0) {
- pScrn->chipset = (char *)xf86TokenToString(intel_chipsets,
+ scrn->chipset = (char *)xf86TokenToString(intel_chipsets,
pI810->pEnt->device->chipID);
from = X_CONFIG;
- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipID override: 0x%04X\n",
+ xf86DrvMsg(scrn->scrnIndex, X_CONFIG, "ChipID override: 0x%04X\n",
pI810->pEnt->device->chipID);
} else {
from = X_PROBED;
- pScrn->chipset = (char *)xf86TokenToString(intel_chipsets,
+ scrn->chipset = (char *)xf86TokenToString(intel_chipsets,
DEVICE_ID(pI810->PciInfo));
}
if (pI810->pEnt->device->chipRev >= 0) {
- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipRev override: %d\n",
+ xf86DrvMsg(scrn->scrnIndex, X_CONFIG, "ChipRev override: %d\n",
pI810->pEnt->device->chipRev);
}
- xf86DrvMsg(pScrn->scrnIndex, from, "Chipset: \"%s\"\n",
- (pScrn->chipset != NULL) ? pScrn->chipset : "Unknown i810");
+ xf86DrvMsg(scrn->scrnIndex, from, "Chipset: \"%s\"\n",
+ (scrn->chipset != NULL) ? scrn->chipset : "Unknown i810");
pI810->LinearAddr = pI810->PciInfo->regions[0].base_addr;
- xf86DrvMsg(pScrn->scrnIndex, from, "Linear framebuffer at 0x%lX\n",
+ xf86DrvMsg(scrn->scrnIndex, from, "Linear framebuffer at 0x%lX\n",
(unsigned long)pI810->LinearAddr);
pI810->MMIOAddr = pI810->PciInfo->regions[1].base_addr;
- xf86DrvMsg(pScrn->scrnIndex, from, "IO registers at addr 0x%lX\n",
+ xf86DrvMsg(scrn->scrnIndex, from, "IO registers at addr 0x%lX\n",
(unsigned long)pI810->MMIOAddr);
/* AGP GART support is required. Don't proceed any further if it isn't
* present.
*/
if (!xf86AgpGARTSupported()) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"AGP GART support is not available. Make sure your kernel has\n"
"\tagpgart support or that the agpgart kernel module is loaded.\n");
return FALSE;
@@ -442,40 +442,40 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
*
* Changed to 8 Meg so we can have acceleration by default (Mark).
*/
- mem = I810CheckAvailableMemory(pScrn);
+ mem = I810CheckAvailableMemory(scrn);
if (pI810->directRenderingDisabled || mem < 131072) /* < 128 MB */
- pScrn->videoRam = 8192;
+ scrn->videoRam = 8192;
else if (mem < 196608)
- pScrn->videoRam = 16384; /* < 192 MB */
+ scrn->videoRam = 16384; /* < 192 MB */
else
- pScrn->videoRam = 24576;
+ scrn->videoRam = 24576;
from = X_DEFAULT;
if (pI810->pEnt->device->videoRam) {
- pScrn->videoRam = pI810->pEnt->device->videoRam;
+ scrn->videoRam = pI810->pEnt->device->videoRam;
from = X_CONFIG;
}
- if (mem > 0 && mem < pScrn->videoRam) {
- xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "%dk of memory was requested,"
+ if (mem > 0 && mem < scrn->videoRam) {
+ xf86DrvMsg(scrn->scrnIndex, X_WARNING, "%dk of memory was requested,"
" but the\n\t maximum AGP memory available is %dk.\n",
- pScrn->videoRam, mem);
+ scrn->videoRam, mem);
from = X_PROBED;
if (mem > (6 * 1024)) {
- xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ xf86DrvMsg(scrn->scrnIndex, X_INFO,
"Reducing video memory to 4MB\n");
- pScrn->videoRam = 4096;
+ scrn->videoRam = 4096;
} else {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Less than 6MB of AGP memory"
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR, "Less than 6MB of AGP memory"
" is available. Cannot proceed.\n");
- I810FreeRec(pScrn);
+ I810FreeRec(scrn);
return FALSE;
}
}
- xf86DrvMsg(pScrn->scrnIndex, from,
- "Will alloc AGP framebuffer: %d kByte\n", pScrn->videoRam);
+ xf86DrvMsg(scrn->scrnIndex, from,
+ "Will alloc AGP framebuffer: %d kByte\n", scrn->videoRam);
/* Calculate Fixed Offsets depending on graphics aperture size */
{
@@ -502,14 +502,14 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
{
Gamma zeros = { 0.0, 0.0, 0.0 };
- if (!xf86SetGamma(pScrn, zeros)) {
+ if (!xf86SetGamma(scrn, zeros)) {
return FALSE;
}
}
pI810->MaxClock = 0;
if (pI810->pEnt->device->dacSpeeds[0]) {
- switch (pScrn->bitsPerPixel) {
+ switch (scrn->bitsPerPixel) {
case 8:
pI810->MaxClock = pI810->pEnt->device->dacSpeeds[DAC_BPP8];
break;
@@ -526,7 +526,7 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
if (!pI810->MaxClock)
pI810->MaxClock = pI810->pEnt->device->dacSpeeds[0];
} else {
- switch (pScrn->bitsPerPixel) {
+ switch (scrn->bitsPerPixel) {
case 8:
pI810->MaxClock = 203000;
break;
@@ -549,59 +549,59 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
clockRanges->interlaceAllowed = TRUE;
clockRanges->doubleScanAllowed = FALSE;
- i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
- pScrn->display->modes, clockRanges,
+ i = xf86ValidateModes(scrn, scrn->monitor->Modes,
+ scrn->display->modes, clockRanges,
#ifndef HAVE_DRI1
- 0, 320, 1600, 64 * pScrn->bitsPerPixel,
+ 0, 320, 1600, 64 * scrn->bitsPerPixel,
#else
- i810_pitches, 0, 0, 64 * pScrn->bitsPerPixel,
+ i810_pitches, 0, 0, 64 * scrn->bitsPerPixel,
#endif
200, 1200,
- pScrn->display->virtualX, pScrn->display->virtualY,
- pScrn->videoRam * 1024, LOOKUP_BEST_REFRESH);
+ scrn->display->virtualX, scrn->display->virtualY,
+ scrn->videoRam * 1024, LOOKUP_BEST_REFRESH);
if (i == -1) {
- I810FreeRec(pScrn);
+ I810FreeRec(scrn);
return FALSE;
}
- xf86PruneDriverModes(pScrn);
+ xf86PruneDriverModes(scrn);
- if (!i || !pScrn->modes) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
- I810FreeRec(pScrn);
+ if (!i || !scrn->modes) {
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR, "No valid modes found\n");
+ I810FreeRec(scrn);
return FALSE;
}
- xf86SetCrtcForModes(pScrn, INTERLACE_HALVE_V);
+ xf86SetCrtcForModes(scrn, INTERLACE_HALVE_V);
- pScrn->currentMode = pScrn->modes;
+ scrn->currentMode = scrn->modes;
- xf86PrintModes(pScrn);
+ xf86PrintModes(scrn);
- xf86SetDpi(pScrn, 0, 0);
+ xf86SetDpi(scrn, 0, 0);
- if (!xf86LoadSubModule(pScrn, "fb")) {
- I810FreeRec(pScrn);
+ if (!xf86LoadSubModule(scrn, "fb")) {
+ I810FreeRec(scrn);
return FALSE;
}
if (!xf86ReturnOptValBool(pI810->Options, OPTION_SW_CURSOR, FALSE)) {
- if (!xf86LoadSubModule(pScrn, "ramdac")) {
- I810FreeRec(pScrn);
+ if (!xf86LoadSubModule(scrn, "ramdac")) {
+ I810FreeRec(scrn);
return FALSE;
}
}
if (xf86GetOptValInteger
(pI810->Options, OPTION_COLOR_KEY, &(pI810->colorKey))) {
- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+ xf86DrvMsg(scrn->scrnIndex, X_CONFIG,
"video overlay key set to 0x%x\n", pI810->colorKey);
} else {
- pI810->colorKey = (1 << pScrn->offset.red) |
- (1 << pScrn->offset.green) |
- (((pScrn->mask.blue >> pScrn->offset.blue) -
- 1) << pScrn->offset.blue);
+ pI810->colorKey = (1 << scrn->offset.red) |
+ (1 << scrn->offset.green) |
+ (((scrn->mask.blue >> scrn->offset.blue) -
+ 1) << scrn->offset.blue);
}
pI810->allowPageFlip=FALSE;
@@ -612,14 +612,14 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
pI810->allowPageFlip = enable;
if (pI810->allowPageFlip == TRUE)
{
- if (!xf86LoadSubModule(pScrn, "shadowfb")) {
+ if (!xf86LoadSubModule(scrn, "shadowfb")) {
pI810->allowPageFlip = 0;
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Couldn't load shadowfb module:\n");
}
}
- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "page flipping %s\n",
+ xf86DrvMsg(scrn->scrnIndex, X_CONFIG, "page flipping %s\n",
enable ? "enabled" : "disabled");
}
@@ -627,20 +627,20 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
if (xf86GetOptValInteger(pI810->Options, OPTION_XVMC_SURFACES,
&(pI810->numSurfaces))) {
- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "%d XvMC Surfaces Requested.\n",
+ xf86DrvMsg(scrn->scrnIndex, X_CONFIG, "%d XvMC Surfaces Requested.\n",
pI810->numSurfaces);
if (pI810->numSurfaces > 7) {
- xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+ xf86DrvMsg(scrn->scrnIndex, X_PROBED,
"Using 7 XvMC Surfaces (Maximum Allowed).\n");
pI810->numSurfaces = 7;
}
if (pI810->numSurfaces < 6) {
- xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+ xf86DrvMsg(scrn->scrnIndex, X_PROBED,
"Using 6 XvMC Surfaces (Minimum Allowed).\n");
pI810->numSurfaces = 6;
}
} else {
- xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ xf86DrvMsg(scrn->scrnIndex, X_INFO,
"XvMC is Disabled: use XvMCSurfaces config option to enable.\n");
pI810->numSurfaces = 0;
}
@@ -648,7 +648,7 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
#ifdef HAVE_DRI1
/* Load the dri module if requested. */
if (xf86ReturnOptValBool(pI810->Options, OPTION_DRI, FALSE)) {
- xf86LoadSubModule(pScrn, "dri");
+ xf86LoadSubModule(scrn, "dri");
}
#endif
@@ -656,9 +656,9 @@ I810PreInit(ScrnInfoPtr pScrn, int flags)
}
static Bool
-I810MapMMIO(ScrnInfoPtr pScrn)
+I810MapMMIO(ScrnInfoPtr scrn)
{
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
struct pci_device *const device = pI810->PciInfo;
int err;
@@ -669,7 +669,7 @@ I810MapMMIO(ScrnInfoPtr pScrn)
(void **) &pI810->MMIOBase);
if (err)
{
- xf86DrvMsg (pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg (scrn->scrnIndex, X_ERROR,
"Unable to map mmio BAR. %s (%d)\n",
strerror (err), err);
return FALSE;
@@ -678,13 +678,13 @@ I810MapMMIO(ScrnInfoPtr pScrn)
}
static Bool
-I810MapMem(ScrnInfoPtr pScrn)
+I810MapMem(ScrnInfoPtr scrn)
{
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
struct pci_device *const device = pI810->PciInfo;
int err;
- if (!I810MapMMIO(pScrn))
+ if (!I810MapMMIO(scrn))
return FALSE;
err = pci_device_map_range (device,
@@ -694,7 +694,7 @@ I810MapMem(ScrnInfoPtr pScrn)
(void **) &pI810->FbBase);
if (err)
{
- xf86DrvMsg (pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg (scrn->scrnIndex, X_ERROR,
"Unable to map frame buffer BAR. %s (%d)\n",
strerror (err), err);
return FALSE;
@@ -706,31 +706,31 @@ I810MapMem(ScrnInfoPtr pScrn)
}
static void
-I810UnmapMMIO(ScrnInfoPtr pScrn)
+I810UnmapMMIO(ScrnInfoPtr scrn)
{
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
pci_device_unmap_range (pI810->PciInfo, pI810->MMIOBase, I810_REG_SIZE);
pI810->MMIOBase = NULL;
}
static Bool
-I810UnmapMem(ScrnInfoPtr pScrn)
+I810UnmapMem(ScrnInfoPtr scrn)
{
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
pci_device_unmap_range (pI810->PciInfo, pI810->FbBase, pI810->FbMapSize);
pI810->FbBase = NULL;
- I810UnmapMMIO(pScrn);
+ I810UnmapMMIO(scrn);
return TRUE;
}
/* Famous last words
*/
void
-I810PrintErrorState(ScrnInfoPtr pScrn)
+I810PrintErrorState(ScrnInfoPtr scrn)
{
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
ErrorF("pgetbl_ctl: 0x%lx pgetbl_err: 0x%lx\n",
(unsigned long) INREG(PGETBL_CTL), (unsigned long) INREG(PGE_ERR));
@@ -764,24 +764,24 @@ I810PrintErrorState(ScrnInfoPtr pScrn)
* mask out bits here - just read the registers.
*/
static void
-DoSave(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, I810RegPtr i810Reg,
+DoSave(ScrnInfoPtr scrn, vgaRegPtr vgaReg, I810RegPtr i810Reg,
Bool saveFonts)
{
I810Ptr pI810;
vgaHWPtr hwp;
int i;
- pI810 = I810PTR(pScrn);
- hwp = VGAHWPTR(pScrn);
+ pI810 = I810PTR(scrn);
+ hwp = VGAHWPTR(scrn);
/*
* This function will handle creating the data structure and filling
* in the generic VGA portion.
*/
if (saveFonts)
- vgaHWSave(pScrn, vgaReg, VGA_SR_MODE | VGA_SR_FONTS | VGA_SR_CMAP);
+ vgaHWSave(scrn, vgaReg, VGA_SR_MODE | VGA_SR_FONTS | VGA_SR_CMAP);
else
- vgaHWSave(pScrn, vgaReg, VGA_SR_MODE | VGA_SR_CMAP);
+ vgaHWSave(scrn, vgaReg, VGA_SR_MODE | VGA_SR_CMAP);
/*
* The port I/O code necessary to read in the extended registers
@@ -819,21 +819,21 @@ DoSave(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, I810RegPtr i810Reg,
if ((i810Reg->LprbTail & TAIL_ADDR) != (i810Reg->LprbHead & HEAD_ADDR) &&
i810Reg->LprbLen & RING_VALID) {
- I810PrintErrorState(pScrn);
+ I810PrintErrorState(scrn);
FatalError("Active ring not flushed\n");
}
}
static void
-I810Save(ScrnInfoPtr pScrn)
+I810Save(ScrnInfoPtr scrn)
{
vgaHWPtr hwp;
I810Ptr pI810;
uint32_t temp;
- hwp = VGAHWPTR(pScrn);
- pI810 = I810PTR(pScrn);
- DoSave(pScrn, &hwp->SavedReg, &pI810->SavedReg, TRUE);
+ hwp = VGAHWPTR(scrn);
+ pI810 = I810PTR(scrn);
+ DoSave(scrn, &hwp->SavedReg, &pI810->SavedReg, TRUE);
temp = INREG(MEMMODE);
temp |= 4;
@@ -905,7 +905,7 @@ i810PrintMode(vgaRegPtr vgaReg, I810RegPtr mode)
}
static void
-DoRestore(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, I810RegPtr i810Reg,
+DoRestore(ScrnInfoPtr scrn, vgaRegPtr vgaReg, I810RegPtr i810Reg,
Bool restoreFonts)
{
I810Ptr pI810;
@@ -914,15 +914,15 @@ DoRestore(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, I810RegPtr i810Reg,
unsigned int itemp;
int i;
- pI810 = I810PTR(pScrn);
- hwp = VGAHWPTR(pScrn);
+ pI810 = I810PTR(scrn);
+ hwp = VGAHWPTR(scrn);
if (I810_DEBUG & DEBUG_VERBOSE_VGA) {
ErrorF("Setting mode in I810Restore:\n");
i810PrintMode(vgaReg, i810Reg);
}
- vgaHWProtect(pScrn, TRUE);
+ vgaHWProtect(scrn, TRUE);
usleep(50000);
@@ -966,9 +966,9 @@ DoRestore(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, I810RegPtr i810Reg,
* restore clock-select bits.
*/
if (restoreFonts)
- vgaHWRestore(pScrn, vgaReg, VGA_SR_FONTS | VGA_SR_MODE | VGA_SR_CMAP);
+ vgaHWRestore(scrn, vgaReg, VGA_SR_FONTS | VGA_SR_MODE | VGA_SR_CMAP);
else
- vgaHWRestore(pScrn, vgaReg, VGA_SR_MODE | VGA_SR_CMAP);
+ vgaHWRestore(scrn, vgaReg, VGA_SR_MODE | VGA_SR_CMAP);
hwp->writeCrtc(hwp, EXT_VERT_TOTAL, i810Reg->ExtVertTotal);
hwp->writeCrtc(hwp, EXT_VERT_DISPLAY, i810Reg->ExtVertDispEnd);
@@ -1081,13 +1081,13 @@ DoRestore(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, I810RegPtr i810Reg,
if (!(vgaReg->Attribute[0x10] & 0x1)) {
usleep(50000);
if (restoreFonts)
- vgaHWRestore(pScrn, vgaReg,
+ vgaHWRestore(scrn, vgaReg,
VGA_SR_FONTS | VGA_SR_MODE | VGA_SR_CMAP);
else
- vgaHWRestore(pScrn, vgaReg, VGA_SR_MODE | VGA_SR_CMAP);
+ vgaHWRestore(scrn, vgaReg, VGA_SR_MODE | VGA_SR_CMAP);
}
- vgaHWProtect(pScrn, FALSE);
+ vgaHWProtect(scrn, FALSE);
temp = hwp->readCrtc(hwp, IO_CTNL);
temp &= ~(EXTENDED_ATTR_CNTL | EXTENDED_CRTC_CNTL);
@@ -1096,10 +1096,10 @@ DoRestore(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, I810RegPtr i810Reg,
}
static void
-I810SetRingRegs(ScrnInfoPtr pScrn)
+I810SetRingRegs(ScrnInfoPtr scrn)
{
unsigned int itemp;
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
OUTREG(LP_RING + RING_TAIL, 0);
OUTREG(LP_RING + RING_HEAD, 0);
@@ -1116,15 +1116,15 @@ I810SetRingRegs(ScrnInfoPtr pScrn)
}
static void
-I810Restore(ScrnInfoPtr pScrn)
+I810Restore(ScrnInfoPtr scrn)
{
vgaHWPtr hwp;
I810Ptr pI810;
- hwp = VGAHWPTR(pScrn);
- pI810 = I810PTR(pScrn);
+ hwp = VGAHWPTR(scrn);
+ pI810 = I810PTR(scrn);
- DoRestore(pScrn, &hwp->SavedReg, &pI810->SavedReg, TRUE);
+ DoRestore(scrn, &hwp->SavedReg, &pI810->SavedReg, TRUE);
}
/*
@@ -1141,9 +1141,9 @@ I810Restore(ScrnInfoPtr pScrn)
(double)m / ((double)n * (1 << p)) * 4 * REF_FREQ
static void
-I810CalcVCLK(ScrnInfoPtr pScrn, double freq)
+I810CalcVCLK(ScrnInfoPtr scrn, double freq)
{
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
I810RegPtr i810Reg = &pI810->ModeReg;
int m, n, p;
double f_out;
@@ -1188,7 +1188,7 @@ I810CalcVCLK(ScrnInfoPtr pScrn, double freq)
i810Reg->VideoClk2_N = (n_best - 2) & 0x3FF;
i810Reg->VideoClk2_DivisorSel = (p_best << 4);
- xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 3,
+ xf86DrvMsgVerb(scrn->scrnIndex, X_INFO, 3,
"Setting dot clock to %.1f MHz " "[ 0x%x 0x%x 0x%x ] "
"[ %d %d %d ]\n", CALC_VCLK(m_best, n_best, p_best),
i810Reg->VideoClk2_M, i810Reg->VideoClk2_N,
@@ -1196,36 +1196,36 @@ I810CalcVCLK(ScrnInfoPtr pScrn, double freq)
}
static Bool
-I810SetMode(ScrnInfoPtr pScrn, DisplayModePtr mode)
+I810SetMode(ScrnInfoPtr scrn, DisplayModePtr mode)
{
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
I810RegPtr i810Reg = &pI810->ModeReg;
- vgaRegPtr pVga = &VGAHWPTR(pScrn)->ModeReg;
+ vgaRegPtr pVga = &VGAHWPTR(scrn)->ModeReg;
double dclk = mode->Clock / 1000.0;
- switch (pScrn->bitsPerPixel) {
+ switch (scrn->bitsPerPixel) {
case 8:
- pVga->CRTC[0x13] = pScrn->displayWidth >> 3;
- i810Reg->ExtOffset = pScrn->displayWidth >> 11;
+ pVga->CRTC[0x13] = scrn->displayWidth >> 3;
+ i810Reg->ExtOffset = scrn->displayWidth >> 11;
i810Reg->PixelPipeCfg1 = DISPLAY_8BPP_MODE;
i810Reg->BitBLTControl = COLEXP_8BPP;
break;
case 16:
- if (pScrn->weight.green == 5) {
+ if (scrn->weight.green == 5) {
i810Reg->PixelPipeCfg1 = DISPLAY_15BPP_MODE;
} else {
i810Reg->PixelPipeCfg1 = DISPLAY_16BPP_MODE;
}
- pVga->CRTC[0x13] = pScrn->displayWidth >> 2;
- i810Reg->ExtOffset = pScrn->displayWidth >> 10;
+ pVga->CRTC[0x13] = scrn->displayWidth >> 2;
+ i810Reg->ExtOffset = scrn->displayWidth >> 10;
i810Reg->BitBLTControl = COLEXP_16BPP;
/* Enable Palette Programming for Direct Color visuals. -jens */
i810Reg->PixelPipeCfg2 = DISPLAY_GAMMA_ENABLE;
break;
case 24:
- pVga->CRTC[0x13] = (pScrn->displayWidth * 3) >> 3;
- i810Reg->ExtOffset = (pScrn->displayWidth * 3) >> 11;
+ pVga->CRTC[0x13] = (scrn->displayWidth * 3) >> 3;
+ i810Reg->ExtOffset = (scrn->displayWidth * 3) >> 11;
i810Reg->PixelPipeCfg1 = DISPLAY_24BPP_MODE;
i810Reg->BitBLTControl = COLEXP_24BPP;
@@ -1310,13 +1310,13 @@ I810SetMode(ScrnInfoPtr pScrn, DisplayModePtr mode)
* Calculate the VCLK that most closely matches the requested dot
* clock.
*/
- I810CalcVCLK(pScrn, dclk);
+ I810CalcVCLK(scrn, dclk);
/* Since we program the clocks ourselves, always use VCLK2. */
pVga->MiscOutReg |= 0x0C;
/* Calculate the FIFO Watermark and Burst Length. */
- i810Reg->LMI_FIFO_Watermark = I810CalcWatermark(pScrn, dclk, FALSE);
+ i810Reg->LMI_FIFO_Watermark = I810CalcWatermark(scrn, dclk, FALSE);
/* Setup the ring buffer */
i810Reg->LprbTail = 0;
@@ -1333,36 +1333,36 @@ I810SetMode(ScrnInfoPtr pScrn, DisplayModePtr mode)
}
static Bool
-I810ModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
+I810ModeInit(ScrnInfoPtr scrn, DisplayModePtr mode)
{
vgaHWPtr hwp;
I810Ptr pI810;
- hwp = VGAHWPTR(pScrn);
- pI810 = I810PTR(pScrn);
+ hwp = VGAHWPTR(scrn);
+ pI810 = I810PTR(scrn);
vgaHWUnlock(hwp);
- if (!vgaHWInit(pScrn, mode))
+ if (!vgaHWInit(scrn, mode))
return FALSE;
- pScrn->vtSema = TRUE;
+ scrn->vtSema = TRUE;
- if (!I810SetMode(pScrn, mode))
+ if (!I810SetMode(scrn, mode))
return FALSE;
#ifdef HAVE_DRI1
if (pI810->directRenderingEnabled) {
- DRILock(screenInfo.screens[pScrn->scrnIndex], 0);
+ DRILock(screenInfo.screens[scrn->scrnIndex], 0);
pI810->LockHeld = 1;
}
#endif
- DoRestore(pScrn, &hwp->ModeReg, &pI810->ModeReg, FALSE);
+ DoRestore(scrn, &hwp->ModeReg, &pI810->ModeReg, FALSE);
#ifdef HAVE_DRI1
if (pI810->directRenderingEnabled) {
- DRIUnlock(screenInfo.screens[pScrn->scrnIndex]);
+ DRIUnlock(screenInfo.screens[scrn->scrnIndex]);
pI810->LockHeld = 0;
}
#endif
@@ -1371,14 +1371,14 @@ I810ModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
}
static void
-I810LoadPalette15(ScrnInfoPtr pScrn, int numColors, int *indices,
+I810LoadPalette15(ScrnInfoPtr scrn, int numColors, int *indices,
LOCO * colors, VisualPtr pVisual)
{
vgaHWPtr hwp;
int i, j, index;
unsigned char r, g, b;
- hwp = VGAHWPTR(pScrn);
+ hwp = VGAHWPTR(scrn);
for (i = 0; i < numColors; i++) {
index = indices[i];
@@ -1395,14 +1395,14 @@ I810LoadPalette15(ScrnInfoPtr pScrn, int numColors, int *indices,
}
static void
-I810LoadPalette16(ScrnInfoPtr pScrn, int numColors, int *indices,
+I810LoadPalette16(ScrnInfoPtr scrn, int numColors, int *indices,
LOCO * colors, VisualPtr pVisual)
{
vgaHWPtr hwp;
int i, index;
unsigned char r, g, b;
- hwp = VGAHWPTR(pScrn);
+ hwp = VGAHWPTR(scrn);
/* Load all four entries in each of the 64 color ranges. -jens */
for (i = 0; i < numColors; i++) {
@@ -1459,14 +1459,14 @@ I810LoadPalette16(ScrnInfoPtr pScrn, int numColors, int *indices,
}
static void
-I810LoadPalette24(ScrnInfoPtr pScrn, int numColors, int *indices,
+I810LoadPalette24(ScrnInfoPtr scrn, int numColors, int *indices,
LOCO * colors, VisualPtr pVisual)
{
vgaHWPtr hwp;
int i, index;
unsigned char r, g, b;
- hwp = VGAHWPTR(pScrn);
+ hwp = VGAHWPTR(scrn);
for (i = 0; i < numColors; i++) {
index = indices[i];
@@ -1481,9 +1481,9 @@ I810LoadPalette24(ScrnInfoPtr pScrn, int numColors, int *indices,
}
Bool
-I810AllocateFront(ScrnInfoPtr pScrn)
+I810AllocateFront(ScrnInfoPtr scrn)
{
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
int cache_lines = -1;
if (pI810->DoneFrontAlloc)
@@ -1492,16 +1492,16 @@ I810AllocateFront(ScrnInfoPtr pScrn)
memset(&(pI810->FbMemBox), 0, sizeof(BoxRec));
/* Alloc FrontBuffer/Ring/Accel memory */
pI810->FbMemBox.x1 = 0;
- pI810->FbMemBox.x2 = pScrn->displayWidth;
+ pI810->FbMemBox.x2 = scrn->displayWidth;
pI810->FbMemBox.y1 = 0;
- pI810->FbMemBox.y2 = pScrn->virtualY;
+ pI810->FbMemBox.y2 = scrn->virtualY;
xf86GetOptValInteger(pI810->Options, OPTION_CACHE_LINES, &cache_lines);
if (cache_lines < 0) {
/* make sure there is enough for two DVD sized YUV buffers */
- cache_lines = (pScrn->depth == 24) ? 256 : 384;
- if (pScrn->displayWidth <= 1024)
+ cache_lines = (scrn->depth == 24) ? 256 : 384;
+ if (scrn->displayWidth <= 1024)
cache_lines *= 2;
}
/* Make sure there's enough space for cache_lines.
@@ -1517,9 +1517,9 @@ I810AllocateFront(ScrnInfoPtr pScrn)
{
int maxCacheLines;
- maxCacheLines = (pScrn->videoRam * 1024 /
- (pScrn->bitsPerPixel / 8) /
- pScrn->displayWidth) - pScrn->virtualY;
+ maxCacheLines = (scrn->videoRam * 1024 /
+ (scrn->bitsPerPixel / 8) /
+ scrn->displayWidth) - scrn->virtualY;
if (maxCacheLines < 0)
maxCacheLines = 0;
if (cache_lines > maxCacheLines)
@@ -1527,7 +1527,7 @@ I810AllocateFront(ScrnInfoPtr pScrn)
}
pI810->FbMemBox.y2 += cache_lines;
- xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ xf86DrvMsg(scrn->scrnIndex, X_INFO,
"Adding %i scanlines for pixmap caching\n", cache_lines);
/* Reserve room for the framebuffer and pixcache. Put at the top
@@ -1538,7 +1538,7 @@ I810AllocateFront(ScrnInfoPtr pScrn)
if (!I810AllocLow(&(pI810->FrontBuffer),
&(pI810->SysMem),
ALIGN((pI810->FbMemBox.x2 * pI810->FbMemBox.y2 * pI810->cpp), 4096))) {
- xf86DrvMsg(pScrn->scrnIndex,
+ xf86DrvMsg(scrn->scrnIndex,
X_WARNING, "Framebuffer allocation failed\n");
return FALSE;
}
@@ -1551,16 +1551,16 @@ I810AllocateFront(ScrnInfoPtr pScrn)
pI810->LpRing->tail = 0;
pI810->LpRing->space = 0;
} else {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Ring buffer allocation failed\n");
return (FALSE);
}
if (I810AllocLow(&pI810->Scratch, &(pI810->SysMem), 64 * 1024) ||
I810AllocLow(&pI810->Scratch, &(pI810->SysMem), 16 * 1024)) {
- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Allocated Scratch Memory\n");
+ xf86DrvMsg(scrn->scrnIndex, X_INFO, "Allocated Scratch Memory\n");
} else {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Scratch memory allocation failed\n");
return (FALSE);
}
@@ -1572,18 +1572,18 @@ I810AllocateFront(ScrnInfoPtr pScrn)
static Bool
I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
{
- ScrnInfoPtr pScrn;
+ ScrnInfoPtr scrn;
vgaHWPtr hwp;
I810Ptr pI810;
VisualPtr visual;
- pScrn = xf86Screens[pScreen->myNum];
- pI810 = I810PTR(pScrn);
- hwp = VGAHWPTR(pScrn);
+ scrn = xf86Screens[pScreen->myNum];
+ pI810 = I810PTR(scrn);
+ hwp = VGAHWPTR(scrn);
pI810->LpRing = calloc(sizeof(I810RingBuffer),1);
if (!pI810->LpRing) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Could not allocate lpring data structure.\n");
return FALSE;
}
@@ -1591,8 +1591,8 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
miClearVisualTypes();
/* Re-implemented Direct Color support, -jens */
- if (!miSetVisualTypes(pScrn->depth, miGetDefaultVisualMask(pScrn->depth),
- pScrn->rgbBits, pScrn->defaultVisual))
+ if (!miSetVisualTypes(scrn->depth, miGetDefaultVisualMask(scrn->depth),
+ scrn->rgbBits, scrn->defaultVisual))
return FALSE;
if (!miSetPixmapDepths())
@@ -1627,47 +1627,47 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
#else
pI810->directRenderingEnabled = FALSE;
- if (!I810AllocateGARTMemory(pScrn))
+ if (!I810AllocateGARTMemory(scrn))
return FALSE;
- if (!I810AllocateFront(pScrn))
+ if (!I810AllocateFront(scrn))
return FALSE;
#endif
- if (!I810MapMem(pScrn))
+ if (!I810MapMem(scrn))
return FALSE;
- pScrn->memPhysBase = (unsigned long)pI810->LinearAddr;
- pScrn->fbOffset = 0;
+ scrn->memPhysBase = (unsigned long)pI810->LinearAddr;
+ scrn->fbOffset = 0;
vgaHWSetMmioFuncs(hwp, pI810->MMIOBase, 0);
vgaHWGetIOBase(hwp);
- if (!vgaHWMapMem(pScrn))
+ if (!vgaHWMapMem(scrn))
return FALSE;
- I810Save(pScrn);
- if (!I810ModeInit(pScrn, pScrn->currentMode))
+ I810Save(scrn);
+ if (!I810ModeInit(scrn, scrn->currentMode))
return FALSE;
I810SaveScreen(pScreen, FALSE);
- I810AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
+ I810AdjustFrame(scrnIndex, scrn->frameX0, scrn->frameY0, 0);
- if (!fbScreenInit(pScreen, pI810->FbBase + pScrn->fbOffset,
- pScrn->virtualX, pScrn->virtualY,
- pScrn->xDpi, pScrn->yDpi,
- pScrn->displayWidth, pScrn->bitsPerPixel))
+ if (!fbScreenInit(pScreen, pI810->FbBase + scrn->fbOffset,
+ scrn->virtualX, scrn->virtualY,
+ scrn->xDpi, scrn->yDpi,
+ scrn->displayWidth, scrn->bitsPerPixel))
return FALSE;
- if (pScrn->bitsPerPixel > 8) {
+ if (scrn->bitsPerPixel > 8) {
/* Fixup RGB ordering */
visual = pScreen->visuals + pScreen->numVisuals;
while (--visual >= pScreen->visuals) {
if ((visual->class | DynamicClass) == DirectColor) {
- visual->offsetRed = pScrn->offset.red;
- visual->offsetGreen = pScrn->offset.green;
- visual->offsetBlue = pScrn->offset.blue;
- visual->redMask = pScrn->mask.red;
- visual->greenMask = pScrn->mask.green;
- visual->blueMask = pScrn->mask.blue;
+ visual->offsetRed = scrn->offset.red;
+ visual->offsetGreen = scrn->offset.green;
+ visual->offsetBlue = scrn->offset.blue;
+ visual->redMask = scrn->mask.red;
+ visual->greenMask = scrn->mask.green;
+ visual->blueMask = scrn->mask.blue;
}
}
}
@@ -1684,9 +1684,9 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
if (!pI810->directRenderingEnabled) {
pI810->DoneFrontAlloc = FALSE;
- if (!I810AllocateGARTMemory(pScrn))
+ if (!I810AllocateGARTMemory(scrn))
return FALSE;
- if (!I810AllocateFront(pScrn))
+ if (!I810AllocateFront(scrn))
return FALSE;
}
#endif
@@ -1696,20 +1696,20 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
#endif
if (!xf86InitFBManager(pScreen, &(pI810->FbMemBox))) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Failed to init memory manager\n");
return FALSE;
}
if (!xf86ReturnOptValBool(pI810->Options, OPTION_NOACCEL, FALSE)) {
if (pI810->LpRing->mem.Size != 0) {
- I810SetRingRegs(pScrn);
+ I810SetRingRegs(scrn);
if (!I810AccelInit(pScreen)) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Hardware acceleration initialization failed\n");
} else /* PK added 16.02.2004 */
- I810EmitFlush(pScrn);
+ I810EmitFlush(scrn);
}
}
@@ -1721,7 +1721,7 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
if (!xf86ReturnOptValBool(pI810->Options, OPTION_SW_CURSOR, FALSE)) {
if (!I810CursorInit(pScreen)) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Hardware cursor initialization failed\n");
}
}
@@ -1730,8 +1730,8 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
return FALSE;
/* Use driver specific palette load routines for Direct Color support. -jens */
- if (pScrn->bitsPerPixel == 16) {
- if (pScrn->depth == 15) {
+ if (scrn->bitsPerPixel == 16) {
+ if (scrn->depth == 15) {
if (!xf86HandleColormaps(pScreen, 256, 8, I810LoadPalette15, NULL,
CMAP_PALETTED_TRUECOLOR |
CMAP_RELOAD_ON_MODE_SWITCH))
@@ -1769,9 +1769,9 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
#endif
if (pI810->directRenderingEnabled) {
- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Direct rendering enabled\n");
+ xf86DrvMsg(scrn->scrnIndex, X_INFO, "Direct rendering enabled\n");
} else {
- xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "Direct rendering disabled\n");
+ xf86DrvMsg(scrn->scrnIndex, X_WARNING, "Direct rendering disabled\n");
}
pScreen->SaveScreen = I810SaveScreen;
@@ -1779,7 +1779,7 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
pScreen->CloseScreen = I810CloseScreen;
if (serverGeneration == 1)
- xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
+ xf86ShowUnusedOptions(scrn->scrnIndex, scrn->options);
return TRUE;
}
@@ -1787,9 +1787,9 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
Bool
I810SwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
{
- ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+ ScrnInfoPtr scrn = xf86Screens[scrnIndex];
#if 0
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
#endif
if (I810_DEBUG & DEBUG_VERBOSE_CURSOR)
ErrorF("I810SwitchMode %p %x\n", (void *)mode, flags);
@@ -1812,17 +1812,17 @@ I810SwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
}
# endif
if (pI810->AccelInfoRec != NULL) {
- I810RefreshRing(pScrn);
- I810Sync(pScrn);
+ I810RefreshRing(scrn);
+ I810Sync(scrn);
pI810->AccelInfoRec->NeedToSync = FALSE;
}
- I810Restore(pScrn);
+ I810Restore(scrn);
# ifdef HAVE_DRI1
if (pI810->directRenderingEnabled) {
- if (!I810DRILeave(pScrn))
+ if (!I810DRILeave(scrn))
return FALSE;
- if (!I810DRIEnter(pScrn))
+ if (!I810DRIEnter(scrn))
return FALSE;
if (I810_DEBUG & DEBUG_VERBOSE_DRI)
@@ -1832,33 +1832,33 @@ I810SwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
}
# endif
#endif
- return I810ModeInit(pScrn, mode);
+ return I810ModeInit(scrn, mode);
}
void
I810AdjustFrame(int scrnIndex, int x, int y, int flags)
{
- ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
- I810Ptr pI810 = I810PTR(pScrn);
- vgaHWPtr hwp = VGAHWPTR(pScrn);
+ ScrnInfoPtr scrn = xf86Screens[scrnIndex];
+ I810Ptr pI810 = I810PTR(scrn);
+ vgaHWPtr hwp = VGAHWPTR(scrn);
int Base;
#if 1
if (pI810->showCache) {
int lastline = pI810->FbMapSize /
- ((pScrn->displayWidth * pScrn->bitsPerPixel) / 8);
- lastline -= pScrn->currentMode->VDisplay;
+ ((scrn->displayWidth * scrn->bitsPerPixel) / 8);
+ lastline -= scrn->currentMode->VDisplay;
if (y > 0)
- y += pScrn->currentMode->VDisplay;
+ y += scrn->currentMode->VDisplay;
if (y > lastline) y = lastline;
}
#endif
- Base = (y * pScrn->displayWidth + x) >> 2;
+ Base = (y * scrn->displayWidth + x) >> 2;
if (I810_DEBUG & DEBUG_VERBOSE_CURSOR)
ErrorF("I810AdjustFrame %d,%d %x\n", x, y, flags);
- switch (pScrn->bitsPerPixel) {
+ switch (scrn->bitsPerPixel) {
case 8:
break;
case 16:
@@ -1890,20 +1890,20 @@ I810AdjustFrame(int scrnIndex, int x, int y, int flags)
static Bool
I810EnterVT(int scrnIndex, int flags)
{
- ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+ ScrnInfoPtr scrn = xf86Screens[scrnIndex];
#ifdef HAVE_DRI1
- I810Ptr pI810 = I810PTR(pScrn);
+ I810Ptr pI810 = I810PTR(scrn);
#endif
if (I810_DEBUG & DEBUG_VERBOSE_DRI)
ErrorF("\n\nENTER VT\n");
- if (!I810BindGARTMemory(pScrn)) {
+ if (!I810BindGARTMemory(scrn)) {
return FALSE;
}
#ifdef HAVE_DRI1
- if (!I810DRIEnter(pScrn)) {
+ if (!I810DRIEnter(scrn)) {
return FALSE;
}
if (pI810->directRenderingEnabled) {
@@ -1914,18 +1914,18 @@ I810EnterVT(int scrnIndex, int flags)
}
#endif
- if (!I810ModeInit(pScrn, pScrn->currentMode))
+ if (!I810ModeInit(scrn, scrn->currentMode))
return FALSE;
- I810AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
+ I810AdjustFrame(scrnIndex, scrn->frameX0, scrn->frameY0, 0);
return TRUE;
}
static void
I810LeaveVT(int scrnIndex, int flags)
{
- ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
- vgaHWPtr hwp = VGAHWPTR(pScrn);
- I810Ptr pI810 = I810PTR(pScrn);
+ ScrnInfoPtr scrn = xf86Screens[scrnIndex];
+ vgaHWPtr hwp = VGAHWPTR(scrn);
+ I810Ptr pI810 = I810PTR(scrn);
if (I810_DEBUG & DEBUG_VERBOSE_DRI)
ErrorF("\n\n\nLeave VT\n");
@@ -1940,16 +1940,16 @@ I810LeaveVT(int scrnIndex, int flags)
#endif
if (pI810->AccelInfoRec != NULL) {
- I810RefreshRing(pScrn);
- I810Sync(pScrn);
+ I810RefreshRing(scrn);
+ I810Sync(scrn);
pI810->AccelInfoRec->NeedToSync = FALSE;
}
- I810Restore(pScrn);
+ I810Restore(scrn);
- if (!I810UnbindGARTMemory(pScrn))
+ if (!I810UnbindGARTMemory(scrn))
return;
#ifdef HAVE_DRI1
- if (!I810DRILeave(pScrn))
+ if (!I810DRILeave(scrn))
return;
#endif
@@ -1959,18 +1959,18 @@ I810LeaveVT(int scrnIndex, int flags)
static Bool
I810CloseScreen(int scrnIndex, ScreenPtr pScreen)
{
- ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
- vgaHWPtr hwp = VGAHWPTR(pScrn);
- I810Ptr pI810 = I810PTR(pScrn);
+ ScrnInfoPtr scrn = xf86Screens[scrnIndex];
+ vgaHWPtr hwp = VGAHWPTR(scrn);
+ I810Ptr pI810 = I810PTR(scrn);
XAAInfoRecPtr infoPtr = pI810->AccelInfoRec;
- if (pScrn->vtSema == TRUE) {
+ if (scrn->vtSema == TRUE) {
if (pI810->AccelInfoRec != NULL) {
- I810RefreshRing(pScrn);
- I810Sync(pScrn);
+ I810RefreshRing(scrn);
+ I810Sync(scrn);
pI810->AccelInfoRec->NeedToSync = FALSE;
}
- I810Restore(pScrn);
+ I810Restore(scrn);
vgaHWLock(hwp);
}
#ifdef HAVE_DRI1
@@ -1980,14 +1980,14 @@ I810CloseScreen(int scrnIndex, ScreenPtr pScreen)
}
#endif
- if (pScrn->vtSema == TRUE) {
- I810UnbindGARTMemory(pScrn);
- I810Restore(pScrn);
+ if (scrn->vtSema == TRUE) {
+ I810UnbindGARTMemory(scrn);
+ I810Restore(scrn);
vgaHWLock(hwp);
}
- I810UnmapMem(pScrn);
- vgaHWUnmapMem(pScrn);
+ I810UnmapMem(scrn);
+ vgaHWUnmapMem(scrn);
if (pI810->ScanlineColorExpandBuffers) {
free(pI810->ScanlineColorExpandBuffers);
@@ -2020,7 +2020,7 @@ I810CloseScreen(int scrnIndex, ScreenPtr pScreen)
free(pI810->LpRing);
pI810->LpRing = NULL;
- pScrn->vtSema = FALSE;
+ scrn->vtSema = FALSE;
pScreen->CloseScreen = pI810->CloseScreen;
return (*pScreen->CloseScreen) (scrnIndex, pScreen);
}
@@ -2053,7 +2053,7 @@ I810SaveScreen(ScreenPtr pScreen, Bool unblack)
}
static void
-I810DisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode,
+I810DisplayPowerManagementSet(ScrnInfoPtr scrn, int PowerManagementMode,
int flags)
{
I810Ptr pI810;
@@ -2061,7 +2061,7 @@ I810DisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode,
int DPMSSyncSelect = 0;
vgaHWPtr hwp;
- pI810 = I810PTR(pScrn);
+ pI810 = I810PTR(scrn);
switch (PowerManagementMode) {
case DPMSModeOn:
/* Screen: On; HSync: On, VSync: On */
@@ -2085,7 +2085,7 @@ I810DisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode,
break;
}
- hwp = VGAHWPTR(pScrn);
+ hwp = VGAHWPTR(scrn);
/* Turn the screen on/off */
SEQ01 |= hwp->readSeq(hwp, 0x01) & ~0x20;
More information about the xorg-commit
mailing list