qbit/xenocara
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add compat-api.h. 1st step to get this version of the intel driver

Browse Source 
working with xserver 1.13.
This commit is contained in:
matthieu 2012-09-09 21:13:06 +00:00
parent a78478db77
commit 00e6140ee7
10 changed files with 298 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
driver/xf86-video-intel/src/Makefile.am
View File

@ -85,6 +85,7 @@ intel_drv_la_SOURCES = \
i965_video.c \
i965_render.c \
drmmode_display.c \
compat-api.h \
$(NULL)
if DRI

98
driver/xf86-video-intel/src/compat-api.h Normal file
View File

@ -0,0 +1,98 @@
/*
* Copyright 2012 Red Hat, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* 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.
*
* Author: Dave Airlie <airlied@redhat.com>
*/
/* this file provides API compat between server post 1.13 and pre it,
it should be reused inside as many drivers as possible */
#ifndef COMPAT_API_H
#define COMPAT_API_H
#ifndef GLYPH_HAS_GLYPH_PICTURE_ACCESSOR
#define GetGlyphPicture(g, s) GlyphPicture((g))[(s)->myNum]
#define SetGlyphPicture(g, s, p) GlyphPicture((g))[(s)->myNum] = p
#endif
#ifndef XF86_HAS_SCRN_CONV
#define xf86ScreenToScrn(s) xf86Screens[(s)->myNum]
#define xf86ScrnToScreen(s) screenInfo.screens[(s)->scrnIndex]
#endif
#ifndef XF86_SCRN_INTERFACE
#define SCRN_ARG_TYPE int
#define SCRN_INFO_PTR(arg1) ScrnInfoPtr scrn = xf86Screens[(arg1)]
#define SCREEN_ARG_TYPE int
#define SCREEN_PTR(arg1) ScreenPtr screen = screenInfo.screens[(arg1)]
#define SCREEN_INIT_ARGS_DECL int i, ScreenPtr screen, int argc, char **argv
#define BLOCKHANDLER_ARGS_DECL int arg, pointer blockData, pointer pTimeout, pointer pReadmask
#define BLOCKHANDLER_ARGS arg, blockData, pTimeout, pReadmask
#define CLOSE_SCREEN_ARGS_DECL int scrnIndex, ScreenPtr screen
#define CLOSE_SCREEN_ARGS scrnIndex, screen
#define ADJUST_FRAME_ARGS_DECL int arg, int x, int y, int flags
#define ADJUST_FRAME_ARGS(arg, x, y) (arg)->scrnIndex, x, y, 0
#define SWITCH_MODE_ARGS_DECL int arg, DisplayModePtr mode, int flags
#define SWITCH_MODE_ARGS(arg, m) (arg)->scrnIndex, m, 0
#define FREE_SCREEN_ARGS_DECL int arg, int flags
#define VT_FUNC_ARGS_DECL int arg, int flags
#define VT_FUNC_ARGS scrn->scrnIndex, 0
#define SCRN_OR_INDEX_ARG(x) ((x)->scrnIndex)
#else
#define SCRN_ARG_TYPE ScrnInfoPtr
#define SCRN_INFO_PTR(arg1) ScrnInfoPtr scrn = (arg1)
#define SCREEN_ARG_TYPE ScreenPtr
#define SCREEN_PTR(arg1) ScreenPtr screen = (arg1)
#define SCREEN_INIT_ARGS_DECL ScreenPtr screen, int argc, char **argv
#define BLOCKHANDLER_ARGS_DECL ScreenPtr arg, pointer pTimeout, pointer pReadmask
#define BLOCKHANDLER_ARGS arg, pTimeout, pReadmask
#define CLOSE_SCREEN_ARGS_DECL ScreenPtr screen
#define CLOSE_SCREEN_ARGS screen
#define ADJUST_FRAME_ARGS_DECL ScrnInfoPtr arg, int x, int y
#define ADJUST_FRAME_ARGS(arg, x, y) arg, x, y
#define SWITCH_MODE_ARGS_DECL ScrnInfoPtr arg, DisplayModePtr mode
#define SWITCH_MODE_ARGS(arg, m) arg, m
#define FREE_SCREEN_ARGS_DECL ScrnInfoPtr arg
#define VT_FUNC_ARGS_DECL ScrnInfoPtr arg
#define VT_FUNC_ARGS scrn
#define SCRN_OR_INDEX_ARG(x) (x)
#endif
#endif

1
driver/xf86-video-intel/src/intel.h
View File

@ -71,6 +71,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "i915_drm.h"
#include "intel_driver.h"
#include "compat-api.h"
#include "uxa.h"
/* XXX

70
driver/xf86-video-intel/src/intel_driver.c
View File

@ -143,9 +143,9 @@ static OptionInfoRec I830Options[] = {
};
/* *INDENT-ON* */
static void i830AdjustFrame(int scrnIndex, int x, int y, int flags);
static Bool I830CloseScreen(int scrnIndex, ScreenPtr screen);
static Bool I830EnterVT(int scrnIndex, int flags);
static void i830AdjustFrame(ADJUST_FRAME_ARGS_DECL);
static Bool I830CloseScreen(CLOSE_SCREEN_ARGS_DECL);
static Bool I830EnterVT(VT_FUNC_ARGS_DECL);
static Bool SaveHWState(ScrnInfoPtr scrn);
static Bool RestoreHWState(ScrnInfoPtr scrn);
@ -2027,15 +2027,15 @@ void IntelEmitInvarientState(ScrnInfoPtr scrn)
}
static void
I830BlockHandler(int i, pointer blockData, pointer pTimeout, pointer pReadmask)
I830BlockHandler(BLOCKHANDLER_ARGS_DECL)
{
ScreenPtr screen = screenInfo.screens[i];
ScrnInfoPtr scrn = xf86Screens[i];
SCREEN_PTR(arg);
ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
intel_screen_private *intel = intel_get_screen_private(scrn);
screen->BlockHandler = intel->BlockHandler;
(*screen->BlockHandler) (i, blockData, pTimeout, pReadmask);
(*screen->BlockHandler) (BLOCKHANDLER_ARGS);
intel->BlockHandler = screen->BlockHandler;
screen->BlockHandler = I830BlockHandler;
@ -2249,9 +2249,9 @@ intel_flush_callback(CallbackListPtr *list,
}
static Bool
I830ScreenInit(int scrnIndex, ScreenPtr screen, int argc, char **argv)
I830ScreenInit(SCREEN_INIT_ARGS_DECL)
{
ScrnInfoPtr scrn = xf86Screens[screen->myNum];
ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
vgaHWPtr hwp = NULL;
intel_screen_private *intel = intel_get_screen_private(scrn);
VisualPtr visual;
@ -2466,7 +2466,7 @@ I830ScreenInit(int scrnIndex, ScreenPtr screen, int argc, char **argv)
* later memory should be bound when allocating, e.g rotate_mem */
scrn->vtSema = TRUE;
if (!I830EnterVT(scrnIndex, 0))
if (!I830EnterVT(VT_FUNC_ARGS))
return FALSE;
intel->BlockHandler = screen->BlockHandler;
@ -2548,9 +2548,9 @@ I830ScreenInit(int scrnIndex, ScreenPtr screen, int argc, char **argv)
return TRUE;
}
static void i830AdjustFrame(int scrnIndex, int x, int y, int flags)
static void i830AdjustFrame(ADJUST_FRAME_ARGS_DECL)
{
ScrnInfoPtr scrn = xf86Screens[scrnIndex];
SCRN_INFO_PTR(arg);
xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
intel_screen_private *intel = intel_get_screen_private(scrn);
xf86OutputPtr output = config->output[config->compat_output];
@ -2572,20 +2572,20 @@ static void i830AdjustFrame(int scrnIndex, int x, int y, int flags)
}
}
static void I830FreeScreen(int scrnIndex, int flags)
static void I830FreeScreen(FREE_SCREEN_ARGS_DECL)
{
ScrnInfoPtr scrn = xf86Screens[scrnIndex];
SCRN_INFO_PTR(arg);
intel_close_drm_master(scrn);
I830FreeRec(xf86Screens[scrnIndex]);
I830FreeRec(scrn);
if (xf86LoaderCheckSymbol("vgaHWFreeHWRec"))
vgaHWFreeHWRec(xf86Screens[scrnIndex]);
vgaHWFreeHWRec(scrn);
}
static void I830LeaveVT(int scrnIndex, int flags)
static void I830LeaveVT(VT_FUNC_ARGS_DECL)
{
ScrnInfoPtr scrn = xf86Screens[scrnIndex];
SCRN_INFO_PTR(arg);
intel_screen_private *intel = intel_get_screen_private(scrn);
int ret;
@ -2637,9 +2637,9 @@ static void I830LeaveVT(int scrnIndex, int flags)
/*
* This gets called when gaining control of the VT, and from ScreenInit().
*/
static Bool I830EnterVT(int scrnIndex, int flags)
static Bool I830EnterVT(VT_FUNC_ARGS_DECL)
{
ScrnInfoPtr scrn = xf86Screens[scrnIndex];
SCRN_INFO_PTR(arg);
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
intel_screen_private *intel = intel_get_screen_private(scrn);
int i, ret;
@ -2742,20 +2742,20 @@ static Bool I830EnterVT(int scrnIndex, int flags)
return TRUE;
}
static Bool I830SwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
static Bool I830SwitchMode(SWITCH_MODE_ARGS_DECL)
{
ScrnInfoPtr scrn = xf86Screens[scrnIndex];
SCRN_INFO_PTR(arg);
return xf86SetSingleMode(scrn, mode, RR_Rotate_0);
}
static Bool I830CloseScreen(int scrnIndex, ScreenPtr screen)
static Bool I830CloseScreen(CLOSE_SCREEN_ARGS_DECL)
{
ScrnInfoPtr scrn = xf86Screens[scrnIndex];
ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
intel_screen_private *intel = intel_get_screen_private(scrn);
if (scrn->vtSema == TRUE) {
I830LeaveVT(scrnIndex, 0);
I830LeaveVT(VT_FUNC_ARGS);
}
DeleteCallback(&FlushCallback, intel_flush_callback, scrn);
@ -2808,7 +2808,7 @@ static Bool I830CloseScreen(int scrnIndex, ScreenPtr screen)
intel->offscreenImages = NULL;
screen->CloseScreen = intel->CloseScreen;
(*screen->CloseScreen) (scrnIndex, screen);
(*screen->CloseScreen) (CLOSE_SCREEN_ARGS);
if (intel->directRenderingOpen
&& intel->directRenderingType == DRI_DRI2) {
@ -2816,18 +2816,18 @@ static Bool I830CloseScreen(int scrnIndex, ScreenPtr screen)
I830DRI2CloseScreen(screen);
}
xf86GARTCloseScreen(scrnIndex);
xf86GARTCloseScreen(scrn->scrnIndex);
scrn->vtSema = FALSE;
return TRUE;
}
static ModeStatus
I830ValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
I830ValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode, Bool verbose, int flags)
{
SCRN_INFO_PTR(arg);
if (mode->Flags & V_INTERLACE) {
if (verbose) {
xf86DrvMsg(scrnIndex, X_PROBED,
xf86DrvMsg(scrn->scrnIndex, X_PROBED,
"Removing interlaced mode \"%s\"\n",
mode->name);
}
@ -2848,9 +2848,9 @@ I830ValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
* DoApmEvent() in common/xf86PM.c, including if we want to see events other
* than suspend/resume.
*/
static Bool I830PMEvent(int scrnIndex, pmEvent event, Bool undo)
static Bool I830PMEvent(SCRN_ARG_TYPE arg, pmEvent event, Bool undo)
{
ScrnInfoPtr scrn = xf86Screens[scrnIndex];
SCRN_INFO_PTR(arg);
intel_screen_private *intel = intel_get_screen_private(scrn);
DPRINTF(PFX, "Enter VT, event %d, undo: %s\n", event,
@ -2863,12 +2863,12 @@ static Bool I830PMEvent(int scrnIndex, pmEvent event, Bool undo)
case XF86_APM_SYS_STANDBY:
case XF86_APM_USER_STANDBY:
if (!undo && !intel->suspended) {
scrn->LeaveVT(scrnIndex, 0);
scrn->LeaveVT(VT_FUNC_ARGS);
intel->suspended = TRUE;
sleep(SUSPEND_SLEEP);
} else if (undo && intel->suspended) {
sleep(RESUME_SLEEP);
scrn->EnterVT(scrnIndex, 0);
scrn->EnterVT(VT_FUNC_ARGS);
intel->suspended = FALSE;
}
break;
@ -2877,7 +2877,7 @@ static Bool I830PMEvent(int scrnIndex, pmEvent event, Bool undo)
case XF86_APM_CRITICAL_RESUME:
if (intel->suspended) {
sleep(RESUME_SLEEP);
scrn->EnterVT(scrnIndex, 0);
scrn->EnterVT(VT_FUNC_ARGS);
intel->suspended = FALSE;
/*
* Turn the screen saver off when resuming. This seems to be

5
driver/xf86-video-intel/src/legacy/i810/i810.h
View File

@ -52,6 +52,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "xorg-server.h"
#include <pciaccess.h>
#include "compat-api.h"
#ifdef XF86DRI
#include "xf86drm.h"
#include "sarea.h"
@ -301,8 +302,8 @@ extern Bool I810UnbindGARTMemory(ScrnInfoPtr pScrn);
extern int I810CheckAvailableMemory(ScrnInfoPtr pScrn);
extern Bool I810SwitchMode(int scrnIndex, DisplayModePtr mode, int flags);
extern void I810AdjustFrame(int scrnIndex, int x, int y, int flags);
extern Bool I810SwitchMode(SWITCH_MODE_ARGS_DECL);
extern void I810AdjustFrame(ADJUST_FRAME_ARGS_DECL);
extern void I810SetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir,
int ydir, int rop,

14
driver/xf86-video-intel/src/legacy/i810/i810_dga.c
View File

@ -143,23 +143,23 @@ static DisplayModePtr I810SavedDGAModes[MAXSCREENS];
static Bool
I810_SetMode(ScrnInfoPtr pScrn, DGAModePtr pMode)
{
int index = pScrn->pScreen->myNum;
int idx = pScrn->pScreen->myNum;
I810Ptr pI810 = I810PTR(pScrn);
if (!pMode) { /* restore the original mode */
if (pI810->DGAactive) {
pScrn->currentMode = I810SavedDGAModes[index];
pScrn->SwitchMode(index, pScrn->currentMode, 0);
pScrn->AdjustFrame(index, 0, 0, 0);
pScrn->currentMode = I810SavedDGAModes[idx];
pScrn->SwitchMode(SWITCH_MODE_ARGS(pScrn, pScrn->currentMode));
pScrn->AdjustFrame(ADJUST_FRAME_ARGS(pScrn, 0, 0));
pI810->DGAactive = FALSE;
}
} else {
if (!pI810->DGAactive) {
I810SavedDGAModes[index] = pScrn->currentMode;
I810SavedDGAModes[idx] = pScrn->currentMode;
pI810->DGAactive = TRUE;
}
pScrn->SwitchMode(index, pMode->mode, 0);
pScrn->SwitchMode(SWITCH_MODE_ARGS(pScrn, pMode->mode));
}
return TRUE;
@ -179,7 +179,7 @@ I810_SetViewport(ScrnInfoPtr pScrn, int x, int y, int flags)
I810Ptr pI810 = I810PTR(pScrn);
vgaHWPtr hwp = VGAHWPTR(pScrn);
pScrn->AdjustFrame(pScrn->pScreen->myNum, x, y, flags);
pScrn->AdjustFrame(ADJUST_FRAME_ARGS(pScrn, x, y));
/* wait for retrace */
while ((hwp->readST01(hwp) & 0x08)) ;

238
driver/xf86-video-intel/src/legacy/i810/i810_driver.c
View File

@ -78,17 +78,16 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "../legacy.h"
static Bool I810PreInit(ScrnInfoPtr pScrn, int flags);
static Bool I810ScreenInit(int Index, ScreenPtr pScreen, 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 I810ScreenInit(SCREEN_INIT_ARGS_DECL);
static Bool I810EnterVT(VT_FUNC_ARGS_DECL);
static void I810LeaveVT(VT_FUNC_ARGS_DECL);
static Bool I810CloseScreen(CLOSE_SCREEN_ARGS_DECL);
static Bool I810SaveScreen(ScreenPtr pScreen, Bool unblank);
static void I810FreeScreen(int scrnIndex, int flags);
static void I810FreeScreen(FREE_SCREEN_ARGS_DECL);
static void I810DisplayPowerManagementSet(ScrnInfoPtr pScrn,
int PowerManagermentMode,
int flags);
static ModeStatus I810ValidMode(int scrnIndex, DisplayModePtr mode,
static ModeStatus I810ValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode,
Bool verbose, int flags);
typedef enum {
@ -188,19 +187,19 @@ intel_host_bridge (void)
}
static void
I810ProbeDDC(ScrnInfoPtr pScrn, int index)
I810ProbeDDC(ScrnInfoPtr pScrn, int ScrnIndex)
{
vbeInfoPtr pVbe;
if (xf86LoadSubModule(pScrn, "vbe")) {
pVbe = VBEInit(NULL, index);
pVbe = VBEInit(NULL, ScrnIndex);
ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
vbeFree(pVbe);
}
}
static xf86MonPtr
I810DoDDC(ScrnInfoPtr pScrn, int index)
I810DoDDC(ScrnInfoPtr pScrn, int ScrnIndex)
{
vbeInfoPtr pVbe;
xf86MonPtr MonInfo = NULL;
@ -211,7 +210,7 @@ I810DoDDC(ScrnInfoPtr pScrn, int index)
return MonInfo;
}
if (xf86LoadSubModule(pScrn, "vbe") && (pVbe = VBEInit(NULL, index))) {
if (xf86LoadSubModule(pScrn, "vbe") && (pVbe = VBEInit(NULL, ScrnIndex))) {
MonInfo = vbeDoEDID(pVbe, NULL);
xf86PrintEDID(MonInfo);
xf86SetDDCproperties(pScrn, MonInfo);
@ -1393,19 +1392,19 @@ I810LoadPalette15(ScrnInfoPtr pScrn, int numColors, int *indices,
{
I810Ptr pI810;
vgaHWPtr hwp;
int i, j, index;
int i, j, idx;
unsigned char r, g, b;
pI810 = I810PTR(pScrn);
hwp = VGAHWPTR(pScrn);
for (i = 0; i < numColors; i++) {
index = indices[i];
r = colors[index].red;
g = colors[index].green;
b = colors[index].blue;
idx = indices[i];
r = colors[idx].red;
g = colors[idx].green;
b = colors[idx].blue;
for (j = 0; j < 8; j++) {
hwp->writeDacWriteAddr(hwp, (index << 3) + j);
hwp->writeDacWriteAddr(hwp, (idx << 3) + j);
hwp->writeDacData(hwp, r);
hwp->writeDacData(hwp, g);
hwp->writeDacData(hwp, b);
@ -1419,7 +1418,7 @@ I810LoadPalette16(ScrnInfoPtr pScrn, int numColors, int *indices,
{
I810Ptr pI810;
vgaHWPtr hwp;
int i, index;
int i, idx;
unsigned char r, g, b;
pI810 = I810PTR(pScrn);
@ -1427,52 +1426,52 @@ I810LoadPalette16(ScrnInfoPtr pScrn, int numColors, int *indices,
/* Load all four entries in each of the 64 color ranges. -jens */
for (i = 0; i < numColors; i++) {
index = indices[i / 2];
r = colors[index].red;
b = colors[index].blue;
index = indices[i];
g = colors[index].green;
idx = indices[i / 2];
r = colors[idx].red;
b = colors[idx].blue;
idx = indices[i];
g = colors[idx].green;
hwp->writeDacWriteAddr(hwp, index << 2);
hwp->writeDacWriteAddr(hwp, idx << 2);
hwp->writeDacData(hwp, r);
hwp->writeDacData(hwp, g);
hwp->writeDacData(hwp, b);
hwp->writeDacWriteAddr(hwp, (index << 2) + 1);
hwp->writeDacWriteAddr(hwp, (idx << 2) + 1);
hwp->writeDacData(hwp, r);
hwp->writeDacData(hwp, g);
hwp->writeDacData(hwp, b);
hwp->writeDacWriteAddr(hwp, (index << 2) + 2);
hwp->writeDacWriteAddr(hwp, (idx << 2) + 2);
hwp->writeDacData(hwp, r);
hwp->writeDacData(hwp, g);
hwp->writeDacData(hwp, b);
hwp->writeDacWriteAddr(hwp, (index << 2) + 3);
hwp->writeDacWriteAddr(hwp, (idx << 2) + 3);
hwp->writeDacData(hwp, r);
hwp->writeDacData(hwp, g);
hwp->writeDacData(hwp, b);
i++;
index = indices[i];
g = colors[index].green;
idx = indices[i];
g = colors[idx].green;
hwp->writeDacWriteAddr(hwp, index << 2);
hwp->writeDacWriteAddr(hwp, idx << 2);
hwp->writeDacData(hwp, r);
hwp->writeDacData(hwp, g);
hwp->writeDacData(hwp, b);
hwp->writeDacWriteAddr(hwp, (index << 2) + 1);
hwp->writeDacWriteAddr(hwp, (idx << 2) + 1);
hwp->writeDacData(hwp, r);
hwp->writeDacData(hwp, g);
hwp->writeDacData(hwp, b);
hwp->writeDacWriteAddr(hwp, (index << 2) + 2);
hwp->writeDacWriteAddr(hwp, (idx << 2) + 2);
hwp->writeDacData(hwp, r);
hwp->writeDacData(hwp, g);
hwp->writeDacData(hwp, b);
hwp->writeDacWriteAddr(hwp, (index << 2) + 3);
hwp->writeDacWriteAddr(hwp, (idx << 2) + 3);
hwp->writeDacData(hwp, r);
hwp->writeDacData(hwp, g);
hwp->writeDacData(hwp, b);
@ -1485,18 +1484,18 @@ I810LoadPalette24(ScrnInfoPtr pScrn, int numColors, int *indices,
{
I810Ptr pI810;
vgaHWPtr hwp;
int i, index;
int i, idx;
unsigned char r, g, b;
pI810 = I810PTR(pScrn);
hwp = VGAHWPTR(pScrn);
for (i = 0; i < numColors; i++) {
index = indices[i];
r = colors[index].red;
g = colors[index].green;
b = colors[index].blue;
hwp->writeDacWriteAddr(hwp, index);
idx = indices[i];
r = colors[idx].red;
g = colors[idx].green;
b = colors[idx].blue;
hwp->writeDacWriteAddr(hwp, idx);
hwp->writeDacData(hwp, r);
hwp->writeDacData(hwp, g);
hwp->writeDacData(hwp, b);
@ -1593,7 +1592,7 @@ I810AllocateFront(ScrnInfoPtr pScrn)
}
static Bool
I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
I810ScreenInit(SCREEN_INIT_ARGS_DECL)
{
ScrnInfoPtr pScrn;
vgaHWPtr hwp;
@ -1601,7 +1600,7 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
VisualPtr visual;
MessageType driFrom = X_DEFAULT;
pScrn = xf86Screens[pScreen->myNum];
pScrn = xf86ScreenToScrn(screen);
pI810 = I810PTR(pScrn);
hwp = VGAHWPTR(pScrn);
@ -1647,7 +1646,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
driFrom = X_CONFIG;
@ -1674,10 +1673,10 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
if (!I810ModeInit(pScrn, pScrn->currentMode))
return FALSE;
I810SaveScreen(pScreen, FALSE);
I810AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
I810SaveScreen(screen, FALSE);
I810AdjustFrame(ADJUST_FRAME_ARGS(pScrn, pScrn->frameX0, pScrn->frameY0));
if (!fbScreenInit(pScreen, pI810->FbBase + pScrn->fbOffset,
if (!fbScreenInit(screen, pI810->FbBase + pScrn->fbOffset,
pScrn->virtualX, pScrn->virtualY,
pScrn->xDpi, pScrn->yDpi,
pScrn->displayWidth, pScrn->bitsPerPixel))
@ -1685,8 +1684,8 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
if (pScrn->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 = pScrn->offset.red;
visual->offsetGreen = pScrn->offset.green;
@ -1698,15 +1697,15 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
}
}
fbPictureInit(pScreen, NULL, 0);
fbPictureInit(screen, NULL, 0);
xf86SetBlackWhitePixels(pScreen);
xf86SetBlackWhitePixels(screen);
#ifdef XF86DRI
if (pI810->LpRing->mem.Start == 0 && pI810->directRenderingEnabled) {
pI810->directRenderingEnabled = FALSE;
driFrom = X_PROBED;
I810DRICloseScreen(pScreen);
I810DRICloseScreen(screen);
}
if (!pI810->directRenderingEnabled) {
@ -1719,10 +1718,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(pScrn->scrnIndex, X_ERROR,
"Failed to init memory manager\n");
return FALSE;
@ -1732,7 +1731,7 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
if (pI810->LpRing->mem.Size != 0) {
I810SetRingRegs(pScrn);
if (!I810AccelInit(pScreen)) {
if (!I810AccelInit(screen)) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Hardware acceleration initialization failed\n");
} else /* PK added 16.02.2004 */
@ -1740,57 +1739,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(pScrn->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 (pScrn->bitsPerPixel == 16) {
if (pScrn->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 XF86DRI
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
@ -1801,9 +1800,9 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
xf86DrvMsg(pScrn->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(pScrn->scrnIndex, pScrn->options);
@ -1812,14 +1811,14 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
}
Bool
I810SwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
I810SwitchMode(SWITCH_MODE_ARGS_DECL)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
SCRN_INFO_PTR(arg);
#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);
ErrorF("I810SwitchMode %p\n", (void *)mode);
#if 0
/*
@ -1839,17 +1838,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 XF86DRI
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)
@ -1859,33 +1858,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)
I810AdjustFrame(ADJUST_FRAME_ARGS_DECL)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
I810Ptr pI810 = I810PTR(pScrn);
vgaHWPtr hwp = VGAHWPTR(pScrn);
SCRN_INFO_PTR(arg);
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);
ErrorF("I810AdjustFrame %d,%d\n", x, y);
switch (pScrn->bitsPerPixel) {
switch (scrn->bitsPerPixel) {
case 8:
break;
case 16:
@ -1915,44 +1914,43 @@ I810AdjustFrame(int scrnIndex, int x, int y, int flags)
/* These functions are usually called with the lock **not held**.
*/
static Bool
I810EnterVT(int scrnIndex, int flags)
I810EnterVT(VT_FUNC_ARGS_DECL)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
SCRN_INFO_PTR(arg);
#ifdef XF86DRI
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 XF86DRI
if (!I810DRIEnter(pScrn)) {
if (!I810DRIEnter(scrn)) {
return FALSE;
}
if (pI810->directRenderingEnabled) {
if (I810_DEBUG & DEBUG_VERBOSE_DRI)
ErrorF("calling dri unlock\n");
DRIUnlock(screenInfo.screens[scrnIndex]);
DRIUnlock(xf86ScrnToScreen(scrn));
pI810->LockHeld = 0;
}
#endif
if (!I810ModeInit(pScrn, pScrn->currentMode))
if (!I810ModeInit(scrn, scrn->currentMode))
return FALSE;
I810AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
I810AdjustFrame(ADJUST_FRAME_ARGS(scrn, scrn->frameX0, scrn->frameY0));
return TRUE;
}
static void
I810LeaveVT(int scrnIndex, int flags)
I810LeaveVT(VT_FUNC_ARGS_DECL)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
vgaHWPtr hwp = VGAHWPTR(pScrn);
I810Ptr pI810 = I810PTR(pScrn);
SCRN_INFO_PTR(arg);
vgaHWPtr hwp = VGAHWPTR(scrn);
I810Ptr pI810 = I810PTR(scrn);
if (I810_DEBUG & DEBUG_VERBOSE_DRI)
ErrorF("\n\n\nLeave VT\n");
@ -1961,22 +1959,22 @@ I810LeaveVT(int scrnIndex, int flags)
if (pI810->directRenderingEnabled) {
if (I810_DEBUG & DEBUG_VERBOSE_DRI)
ErrorF("calling dri lock\n");
DRILock(screenInfo.screens[scrnIndex], 0);
DRILock(xf86ScrnToScreen(scrn), 0);
pI810->LockHeld = 1;
}
#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 XF86DRI
if (!I810DRILeave(pScrn))
if (!I810DRILeave(scrn))
return;
#endif
@ -1984,9 +1982,9 @@ I810LeaveVT(int scrnIndex, int flags)
}
static Bool
I810CloseScreen(int scrnIndex, ScreenPtr pScreen)
I810CloseScreen(CLOSE_SCREEN_ARGS_DECL)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
ScrnInfoPtr pScrn = xf86ScreenToScrn(screen);
vgaHWPtr hwp = VGAHWPTR(pScrn);
I810Ptr pI810 = I810PTR(pScrn);
XAAInfoRecPtr infoPtr = pI810->AccelInfoRec;
@ -2002,7 +2000,7 @@ I810CloseScreen(int scrnIndex, ScreenPtr pScreen)
}
#ifdef XF86DRI
if (pI810->directRenderingEnabled) {
I810DRICloseScreen(pScreen);
I810DRICloseScreen(screen);
pI810->directRenderingEnabled = FALSE;
}
#endif
@ -2042,30 +2040,32 @@ I810CloseScreen(int scrnIndex, ScreenPtr pScreen)
/* Need to actually close the gart fd, or the unbound memory will just sit
* around. Will prevent the Xserver from recycling.
*/
xf86GARTCloseScreen(scrnIndex);
xf86GARTCloseScreen(pScrn->scrnIndex);
free(pI810->LpRing);
pI810->LpRing = NULL;
pScrn->vtSema = FALSE;
pScreen->CloseScreen = pI810->CloseScreen;
return (*pScreen->CloseScreen) (scrnIndex, pScreen);
screen->CloseScreen = pI810->CloseScreen;
return (*screen->CloseScreen) (CLOSE_SCREEN_ARGS);
}
static void
I810FreeScreen(int scrnIndex, int flags)
I810FreeScreen(FREE_SCREEN_ARGS_DECL)
{
I810FreeRec(xf86Screens[scrnIndex]);
SCRN_INFO_PTR(arg);
I810FreeRec(scrn);
if (xf86LoaderCheckSymbol("vgaHWFreeHWRec"))
vgaHWFreeHWRec(xf86Screens[scrnIndex]);
vgaHWFreeHWRec(scrn);
}
static ModeStatus
I810ValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
I810ValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode, Bool verbose, int flags)
{
SCRN_INFO_PTR(arg);
if (mode->Flags & V_INTERLACE) {
if (verbose) {
xf86DrvMsg(scrnIndex, X_PROBED,
xf86DrvMsg(scrn->scrnIndex, X_PROBED,
"Removing interlaced mode \"%s\"\n", mode->name);
}
return MODE_BAD;

22
driver/xf86-video-intel/src/legacy/i810/i810_video.c
View File

@ -79,7 +79,7 @@ static int I810PutImage( ScrnInfoPtr,
static int I810QueryImageAttributes(ScrnInfoPtr,
int, unsigned short *, unsigned short *, int *, int *);
static void I810BlockHandler(int, pointer, pointer, pointer);
static void I810BlockHandler(BLOCKHANDLER_ARGS_DECL);
#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)
@ -1146,23 +1146,19 @@ I810QueryImageAttributes(
}
static void
I810BlockHandler (
int i,
pointer blockData,
pointer pTimeout,
pointer pReadmask
){
ScreenPtr pScreen = screenInfo.screens[i];
ScrnInfoPtr pScrn = xf86Screens[i];
I810BlockHandler (BLOCKHANDLER_ARGS_DECL)
{
SCREEN_PTR(arg);
ScrnInfoPtr pScrn = xf86ScreenToScrn(screen);
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) (BLOCKHANDLER_ARGS);
pScreen->BlockHandler = I810BlockHandler;
screen->BlockHandler = I810BlockHandler;
if(pPriv->videoStatus & TIMER_MASK) {
UpdateCurrentTime();
@ -1384,7 +1380,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;

4
driver/xf86-video-intel/uxa/uxa-priv.h
View File

@ -59,6 +59,8 @@
#endif
#include "damage.h"
#include "../src/compat-api.h"
/* Provide substitutes for gcc's __FUNCTION__ on other compilers */
#if !defined(__GNUC__) && !defined(__FUNCTION__)
# if defined(__STDC__) && (__STDC_VERSION__>=199901L) /* C99 */
@ -109,7 +111,7 @@ typedef struct {
#define UXA_NUM_SOLID_CACHE 16
typedef void (*EnableDisableFBAccessProcPtr) (int, Bool);
typedef void (*EnableDisableFBAccessProcPtr) (SCRN_ARG_TYPE, Bool);
typedef struct {
uxa_driver_t *info;
CreateGCProcPtr SavedCreateGC;

44
driver/xf86-video-intel/uxa/uxa.c
View File

@ -333,10 +333,10 @@ static RegionPtr uxa_bitmap_to_region(PixmapPtr pPix)
return ret;
}
static void uxa_xorg_enable_disable_fb_access(int index, Bool enable)
static void uxa_xorg_enable_disable_fb_access(SCRN_ARG_TYPE arg, Bool enable)
{
ScreenPtr screen = screenInfo.screens[index];
uxa_screen_t *uxa_screen = uxa_get_screen(screen);
SCRN_INFO_PTR(arg);
uxa_screen_t *uxa_screen = uxa_get_screen(scrn->pScreen);
if (!enable && uxa_screen->disableFbCount++ == 0)
uxa_screen->swappedOut = TRUE;
@ -345,7 +345,7 @@ static void uxa_xorg_enable_disable_fb_access(int index, Bool enable)
uxa_screen->swappedOut = FALSE;
if (uxa_screen->SavedEnableDisableFBAccess)
uxa_screen->SavedEnableDisableFBAccess(index, enable);
uxa_screen->SavedEnableDisableFBAccess(arg, enable);
}
void uxa_set_fallback_debug(ScreenPtr screen, Bool enable)
@ -366,12 +366,12 @@ void uxa_set_force_fallback(ScreenPtr screen, Bool value)
* uxa_close_screen() unwraps its wrapped screen functions and tears down UXA's
* screen private, before calling down to the next CloseSccreen.
*/
static Bool uxa_close_screen(int i, ScreenPtr pScreen)
static Bool uxa_close_screen(CLOSE_SCREEN_ARGS_DECL)
{
uxa_screen_t *uxa_screen = uxa_get_screen(pScreen);
ScrnInfoPtr scrn = xf86Screens[pScreen->myNum];
uxa_screen_t *uxa_screen = uxa_get_screen(screen);
ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
#ifdef RENDER
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
PictureScreenPtr ps = GetPictureScreenIfSet(screen);
#endif
int n;
@ -384,28 +384,28 @@ static Bool uxa_close_screen(int i, ScreenPtr pScreen)
for (n = 0; n < uxa_screen->solid_cache_size; n++)
FreePicture(uxa_screen->solid_cache[n].picture, 0);
uxa_glyphs_fini(pScreen);
uxa_glyphs_fini(screen);
if (pScreen->devPrivate) {
if (screen->devPrivate) {
/* Destroy the pixmap created by miScreenInit() *before*
* chaining up as we finalize ourselves here and so this
* is the last chance we have of releasing our resources
* associated with the Pixmap. So do it first.
*/
(void) (*pScreen->DestroyPixmap) (pScreen->devPrivate);
pScreen->devPrivate = NULL;
(void) (*screen->DestroyPixmap) (screen->devPrivate);
screen->devPrivate = NULL;
}
pScreen->CreateGC = uxa_screen->SavedCreateGC;
pScreen->CloseScreen = uxa_screen->SavedCloseScreen;
pScreen->GetImage = uxa_screen->SavedGetImage;
pScreen->GetSpans = uxa_screen->SavedGetSpans;
pScreen->CreatePixmap = uxa_screen->SavedCreatePixmap;
pScreen->DestroyPixmap = uxa_screen->SavedDestroyPixmap;
pScreen->CopyWindow = uxa_screen->SavedCopyWindow;
pScreen->ChangeWindowAttributes =
screen->CreateGC = uxa_screen->SavedCreateGC;
screen->CloseScreen = uxa_screen->SavedCloseScreen;
screen->GetImage = uxa_screen->SavedGetImage;
screen->GetSpans = uxa_screen->SavedGetSpans;
screen->CreatePixmap = uxa_screen->SavedCreatePixmap;
screen->DestroyPixmap = uxa_screen->SavedDestroyPixmap;
screen->CopyWindow = uxa_screen->SavedCopyWindow;
screen->ChangeWindowAttributes =
uxa_screen->SavedChangeWindowAttributes;
pScreen->BitmapToRegion = uxa_screen->SavedBitmapToRegion;
screen->BitmapToRegion = uxa_screen->SavedBitmapToRegion;
scrn->EnableDisableFBAccess = uxa_screen->SavedEnableDisableFBAccess;
#ifdef RENDER
if (ps) {
@ -422,7 +422,7 @@ static Bool uxa_close_screen(int i, ScreenPtr pScreen)
free(uxa_screen);
return (*pScreen->CloseScreen) (i, pScreen);
return (*screen->CloseScreen) (CLOSE_SCREEN_ARGS);
}
/**