xserver: Branch 'master' - 12 commits
Adam Jackson
ajax at kemper.freedesktop.org
Mon Feb 29 21:40:31 UTC 2016
Xext/Makefile.am | 7
Xext/vidmode.c | 2147 +++++++++++++++++++++++++++++++++++++
hw/xfree86/Makefile.am | 4
hw/xfree86/common/Makefile.am | 4
hw/xfree86/common/vidmodeproc.h | 83 -
hw/xfree86/common/xf86Extensions.c | 3
hw/xfree86/common/xf86Init.c | 1
hw/xfree86/common/xf86Privstr.h | 10
hw/xfree86/common/xf86VidMode.c | 582 +++-------
hw/xfree86/common/xf86str.h | 92 -
hw/xfree86/common/xf86vmode.c | 1955 ---------------------------------
hw/xwayland/Makefile.am | 2
hw/xwayland/xwayland-vidmode.c | 408 +++++++
hw/xwayland/xwayland.c | 8
hw/xwayland/xwayland.h | 4
include/Makefile.am | 2
include/displaymode.h | 102 +
include/vidmodestr.h | 140 ++
test/Makefile.am | 2
19 files changed, 3015 insertions(+), 2541 deletions(-)
New commits:
commit 6070a749d953951bacbfb149c5c36451293aad35
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Wed Feb 10 09:35:39 2016 +0100
xwayland: add partial xvidmode extension support
Older games (mostly those based on SDL 1.x) rely on the XVidMode
extension and would refuse to run without.
Add a simple, limited and read-only xvidmode support that reports the
current mode used so that games that rely on xvidmode extension can run
on XWayland.
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=87806
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/hw/xwayland/Makefile.am b/hw/xwayland/Makefile.am
index ab1bbb6..0905082 100644
--- a/hw/xwayland/Makefile.am
+++ b/hw/xwayland/Makefile.am
@@ -16,6 +16,7 @@ Xwayland_SOURCES = \
xwayland-shm.c \
xwayland-output.c \
xwayland-cvt.c \
+ xwayland-vidmode.c \
xwayland.h \
$(top_srcdir)/Xext/dpmsstubs.c \
$(top_srcdir)/Xi/stubs.c \
@@ -25,6 +26,7 @@ Xwayland_LDADD = \
$(glamor_lib) \
$(XWAYLAND_LIBS) \
$(XWAYLAND_SYS_LIBS) \
+ $(top_builddir)/Xext/libXvidmode.la \
$(XSERVER_SYS_LIBS)
Xwayland_LDFLAGS = $(LD_EXPORT_SYMBOLS_FLAG)
diff --git a/hw/xwayland/xwayland-vidmode.c b/hw/xwayland/xwayland-vidmode.c
new file mode 100644
index 0000000..6d70e39
--- /dev/null
+++ b/hw/xwayland/xwayland-vidmode.c
@@ -0,0 +1,408 @@
+/*
+ * Copyright (c) 1999-2003 by The XFree86 Project, 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
+ *
+ * Except as contained in this notice, the name of the copyright holder(s)
+ * and author(s) shall not be used in advertising or otherwise to promote
+ * the sale, use or other dealings in this Software without prior written
+ * authorization from the copyright holder(s) and author(s).
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include "misc.h"
+#include "os.h"
+#include "extinit.h"
+
+#ifdef XF86VIDMODE
+#include "xwayland.h"
+#include "randrstr.h"
+#include "vidmodestr.h"
+
+static DevPrivateKeyRec xwlVidModePrivateKeyRec;
+#define xwlVidModePrivateKey (&xwlVidModePrivateKeyRec)
+
+/* Taken from xrandr, h sync frequency in KHz */
+static double
+mode_hsync(const xRRModeInfo *mode_info)
+{
+ double rate;
+
+ if (mode_info->hTotal)
+ rate = (double) mode_info->dotClock / (double) mode_info->hTotal;
+ else
+ rate = 0.0;
+
+ return rate / 1000.0;
+}
+
+/* Taken from xrandr, v refresh frequency in Hz */
+static double
+mode_refresh(const xRRModeInfo *mode_info)
+{
+ double rate;
+ double vTotal = mode_info->vTotal;
+
+ if (mode_info->modeFlags & RR_DoubleScan)
+ vTotal *= 2.0;
+
+ if (mode_info->modeFlags & RR_Interlace)
+ vTotal /= 2.0;
+
+ if (mode_info->hTotal > 0.0 && vTotal > 0.0)
+ rate = ((double) mode_info->dotClock /
+ ((double) mode_info->hTotal * (double) vTotal));
+ else
+ rate = 0.0;
+
+ return rate;
+}
+
+static Bool
+xwlVidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
+{
+ DisplayModePtr pMod;
+ RROutputPtr output;
+ RRCrtcPtr crtc;
+ xRRModeInfo rrmode;
+
+ pMod = dixLookupPrivate(&pScreen->devPrivates, xwlVidModePrivateKey);
+ if (pMod == NULL)
+ return FALSE;
+
+ output = RRFirstOutput(pScreen);
+ if (output == NULL)
+ return FALSE;
+
+ crtc = output->crtc;
+ if (crtc == NULL)
+ return FALSE;
+
+ rrmode = crtc->mode->mode;
+
+ pMod->next = pMod;
+ pMod->prev = pMod;
+ pMod->name = "";
+ pMod->VScan = 1;
+ pMod->Private = NULL;
+ pMod->HDisplay = rrmode.width;
+ pMod->HSyncStart = rrmode.hSyncStart;
+ pMod->HSyncEnd = rrmode.hSyncEnd;
+ pMod->HTotal = rrmode.hTotal;
+ pMod->HSkew = rrmode.hSkew;
+ pMod->VDisplay = rrmode.height;
+ pMod->VSyncStart = rrmode.vSyncStart;
+ pMod->VSyncEnd = rrmode.vSyncEnd;
+ pMod->VTotal = rrmode.vTotal;
+ pMod->Flags = rrmode.modeFlags;
+ pMod->Clock = rrmode.dotClock / 1000.0;
+ pMod->VRefresh = mode_refresh(&rrmode); /* Or RRVerticalRefresh() */
+ pMod->HSync = mode_hsync(&rrmode);
+ *mode = pMod;
+
+ if (dotClock != NULL)
+ *dotClock = rrmode.dotClock / 1000.0;
+
+ return TRUE;
+}
+
+static vidMonitorValue
+xwlVidModeGetMonitorValue(ScreenPtr pScreen, int valtyp, int indx)
+{
+ vidMonitorValue ret = { NULL, };
+ DisplayModePtr pMod;
+
+ if (!xwlVidModeGetCurrentModeline(pScreen, &pMod, NULL))
+ return ret;
+
+ switch (valtyp) {
+ case VIDMODE_MON_VENDOR:
+ ret.ptr = XVENDORNAME;
+ break;
+ case VIDMODE_MON_MODEL:
+ ret.ptr = "XWAYLAND";
+ break;
+ case VIDMODE_MON_NHSYNC:
+ ret.i = 1;
+ break;
+ case VIDMODE_MON_NVREFRESH:
+ ret.i = 1;
+ break;
+ case VIDMODE_MON_HSYNC_LO:
+ case VIDMODE_MON_HSYNC_HI:
+ ret.f = 100.0 * pMod->HSync;
+ break;
+ case VIDMODE_MON_VREFRESH_LO:
+ case VIDMODE_MON_VREFRESH_HI:
+ ret.f = 100.0 * pMod->VRefresh;
+ break;
+ }
+ return ret;
+}
+
+static int
+xwlVidModeGetDotClock(ScreenPtr pScreen, int Clock)
+{
+ DisplayModePtr pMod;
+
+ if (!xwlVidModeGetCurrentModeline(pScreen, &pMod, NULL))
+ return 0;
+
+ return pMod->Clock;
+
+}
+
+static int
+xwlVidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock)
+{
+ return 1;
+}
+
+static Bool
+xwlVidModeGetClocks(ScreenPtr pScreen, int *Clocks)
+{
+ *Clocks = xwlVidModeGetDotClock(pScreen, 0);
+
+ return TRUE;
+}
+
+static Bool
+xwlVidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
+{
+ return FALSE;
+}
+
+static Bool
+xwlVidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
+{
+ return xwlVidModeGetCurrentModeline(pScreen, mode, dotClock);
+}
+
+static Bool
+xwlVidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode)
+{
+ /* Unsupported */
+ return FALSE;
+}
+
+static Bool
+xwlVidModeZoomViewport(ScreenPtr pScreen, int zoom)
+{
+ /* Unsupported for now */
+ return FALSE;
+}
+
+static Bool
+xwlVidModeSetViewPort(ScreenPtr pScreen, int x, int y)
+{
+ /* Unsupported for now */
+ return FALSE;
+}
+
+static Bool
+xwlVidModeGetViewPort(ScreenPtr pScreen, int *x, int *y)
+{
+ RROutputPtr output;
+ RRCrtcPtr crtc;
+
+ output = RRFirstOutput(pScreen);
+ if (output == NULL)
+ return FALSE;
+
+ crtc = output->crtc;
+ if (crtc == NULL)
+ return FALSE;
+
+ *x = crtc->x;
+ *y = crtc->y;
+
+ return TRUE;
+}
+
+static Bool
+xwlVidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
+{
+ /* Unsupported for now */
+ return FALSE;
+}
+
+static Bool
+xwlVidModeLockZoom(ScreenPtr pScreen, Bool lock)
+{
+ /* Unsupported for now, but pretend it works */
+ return TRUE;
+}
+
+static ModeStatus
+xwlVidModeCheckModeForMonitor(ScreenPtr pScreen, DisplayModePtr mode)
+{
+ DisplayModePtr pMod;
+
+ /* This should not happen */
+ if (!xwlVidModeGetCurrentModeline(pScreen, &pMod, NULL))
+ return MODE_ERROR;
+
+ /* Only support mode with the same HSync/VRefresh as we advertise */
+ if (mode->HSync == pMod->HSync && mode->VRefresh == pMod->VRefresh)
+ return MODE_OK;
+
+ /* All the rest is unsupported - If we want to succeed, return MODE_OK instead */
+ return MODE_ONE_SIZE;
+}
+
+static ModeStatus
+xwlVidModeCheckModeForDriver(ScreenPtr pScreen, DisplayModePtr mode)
+{
+ DisplayModePtr pMod;
+
+ /* This should not happen */
+ if (!xwlVidModeGetCurrentModeline(pScreen, &pMod, NULL))
+ return MODE_ERROR;
+
+ if (mode->HTotal != pMod->HTotal)
+ return MODE_BAD_HVALUE;
+
+ if (mode->VTotal != pMod->VTotal)
+ return MODE_BAD_VVALUE;
+
+ /* Unsupported for now, but pretend it works */
+ return MODE_OK;
+}
+
+static void
+xwlVidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode)
+{
+ /* Unsupported */
+ return;
+}
+
+static Bool
+xwlVidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode)
+{
+ /* Unsupported */
+ return FALSE;
+}
+
+static int
+xwlVidModeGetNumOfModes(ScreenPtr pScreen)
+{
+ /* We have only one mode */
+ return 1;
+}
+
+static Bool
+xwlVidModeSetGamma(ScreenPtr pScreen, float red, float green, float blue)
+{
+ /* Unsupported for now, but pretend it works */
+ return TRUE;
+}
+
+static Bool
+xwlVidModeGetGamma(ScreenPtr pScreen, float *red, float *green, float *blue)
+{
+ /* Unsupported for now, but pretend it works */
+ return TRUE;
+}
+
+static Bool
+xwlVidModeSetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
+{
+ /* Unsupported for now */
+ return FALSE;
+}
+
+static Bool
+xwlVidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
+{
+ /* Unsupported for now */
+ return FALSE;
+}
+
+static int
+xwlVidModeGetGammaRampSize(ScreenPtr pScreen)
+{
+ /* Unsupported for now */
+ return 0;
+}
+
+static Bool
+xwlVidModeInit(ScreenPtr pScreen)
+{
+ VidModePtr pVidMode = NULL;
+
+ pVidMode = VidModeInit(pScreen);
+ if (!pVidMode)
+ return FALSE;
+
+ pVidMode->Flags = 0;
+ pVidMode->Next = NULL;
+
+ pVidMode->GetMonitorValue = xwlVidModeGetMonitorValue;
+ pVidMode->GetCurrentModeline = xwlVidModeGetCurrentModeline;
+ pVidMode->GetFirstModeline = xwlVidModeGetFirstModeline;
+ pVidMode->GetNextModeline = xwlVidModeGetNextModeline;
+ pVidMode->DeleteModeline = xwlVidModeDeleteModeline;
+ pVidMode->ZoomViewport = xwlVidModeZoomViewport;
+ pVidMode->GetViewPort = xwlVidModeGetViewPort;
+ pVidMode->SetViewPort = xwlVidModeSetViewPort;
+ pVidMode->SwitchMode = xwlVidModeSwitchMode;
+ pVidMode->LockZoom = xwlVidModeLockZoom;
+ pVidMode->GetNumOfClocks = xwlVidModeGetNumOfClocks;
+ pVidMode->GetClocks = xwlVidModeGetClocks;
+ pVidMode->CheckModeForMonitor = xwlVidModeCheckModeForMonitor;
+ pVidMode->CheckModeForDriver = xwlVidModeCheckModeForDriver;
+ pVidMode->SetCrtcForMode = xwlVidModeSetCrtcForMode;
+ pVidMode->AddModeline = xwlVidModeAddModeline;
+ pVidMode->GetDotClock = xwlVidModeGetDotClock;
+ pVidMode->GetNumOfModes = xwlVidModeGetNumOfModes;
+ pVidMode->SetGamma = xwlVidModeSetGamma;
+ pVidMode->GetGamma = xwlVidModeGetGamma;
+ pVidMode->SetGammaRamp = xwlVidModeSetGammaRamp;
+ pVidMode->GetGammaRamp = xwlVidModeGetGammaRamp;
+ pVidMode->GetGammaRampSize = xwlVidModeGetGammaRampSize;
+
+ return TRUE;
+}
+
+void
+xwlVidModeExtensionInit(void)
+{
+ int i;
+ Bool enabled = FALSE;
+
+ for (i = 0; i < screenInfo.numScreens; i++) {
+ if (xwlVidModeInit (screenInfo.screens[i]))
+ enabled = TRUE;
+ }
+ /* This means that the DDX doesn't want the vidmode extension enabled */
+ if (!enabled)
+ return;
+
+ if (!dixRegisterPrivateKey(xwlVidModePrivateKey, PRIVATE_SCREEN,
+ sizeof(DisplayModeRec)))
+ return;
+
+ VidModeAddExtension(FALSE);
+}
+
+#endif /* XF86VIDMODE */
diff --git a/hw/xwayland/xwayland.c b/hw/xwayland/xwayland.c
index c97f57d..151e044 100644
--- a/hw/xwayland/xwayland.c
+++ b/hw/xwayland/xwayland.c
@@ -33,6 +33,11 @@
#include <compositeext.h>
#include <glx_extinit.h>
+#ifdef XF86VIDMODE
+#include <X11/extensions/xf86vmproto.h>
+_X_EXPORT Bool noXFree86VidModeExtension;
+#endif
+
void
ddxGiveUp(enum ExitCode error)
{
@@ -712,6 +717,9 @@ static const ExtensionModule xwayland_extensions[] = {
#ifdef GLXEXT
{ GlxExtensionInit, "GLX", &noGlxExtension },
#endif
+#ifdef XF86VIDMODE
+ { xwlVidModeExtensionInit, XF86VIDMODENAME, &noXFree86VidModeExtension },
+#endif
};
void
diff --git a/hw/xwayland/xwayland.h b/hw/xwayland/xwayland.h
index 4fcdee5..4b150ed 100644
--- a/hw/xwayland/xwayland.h
+++ b/hw/xwayland/xwayland.h
@@ -190,4 +190,8 @@ Bool xwl_screen_init_glamor(struct xwl_screen *xwl_screen,
uint32_t id, uint32_t version);
struct wl_buffer *xwl_glamor_pixmap_get_wl_buffer(PixmapPtr pixmap);
+#ifdef XF86VIDMODE
+void xwlVidModeExtensionInit(void);
+#endif
+
#endif
commit b430f53bb753f9b064ab62d014820c1c3c76a841
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Fri Feb 5 09:48:25 2016 +0100
vidmode: remove redundant DIX function
The API signature of the DIX xf86VidModeGetGammaRampSize() is now
identical to the xf86cmap's xf86GetGammaRampSize() and all it does is
actually call xf86GetGammaRampSize() so we can save one vfunc.
Remove uneeded xf86VidModeGetGammaRampSize() function.
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/hw/xfree86/common/xf86VidMode.c b/hw/xfree86/common/xf86VidMode.c
index b7ccfb2..7e12ea2 100644
--- a/hw/xfree86/common/xf86VidMode.c
+++ b/hw/xfree86/common/xf86VidMode.c
@@ -393,12 +393,6 @@ xf86VidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD1
return TRUE;
}
-static int
-xf86VidModeGetGammaRampSize(ScreenPtr pScreen)
-{
- return xf86GetGammaRampSize(pScreen);
-}
-
static Bool
xf86VidModeInit(ScreenPtr pScreen)
{
@@ -438,7 +432,7 @@ xf86VidModeInit(ScreenPtr pScreen)
pVidMode->GetGamma = xf86VidModeGetGamma;
pVidMode->SetGammaRamp = xf86VidModeSetGammaRamp;
pVidMode->GetGammaRamp = xf86VidModeGetGammaRamp;
- pVidMode->GetGammaRampSize = xf86VidModeGetGammaRampSize;
+ pVidMode->GetGammaRampSize = xf86GetGammaRampSize; /* use xf86cmap API directly */
return TRUE;
}
commit 48fccde2bfb60efdbf45a96fa53bcd9a6570bf89
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Fri Feb 5 09:48:24 2016 +0100
vidmode: remove redundant check
The DIX already checks for VidModePrivateKey to get the vfunc, so
checking for this again in the DDX is redundant.
Remove the redundant function xf86VidModeAvailable() from the DDX.
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/hw/xfree86/common/xf86VidMode.c b/hw/xfree86/common/xf86VidMode.c
index d2bdf6b..b7ccfb2 100644
--- a/hw/xfree86/common/xf86VidMode.c
+++ b/hw/xfree86/common/xf86VidMode.c
@@ -50,17 +50,6 @@
#include "xf86Extensions.h"
#include "xf86cmap.h"
-static Bool
-xf86VidModeAvailable(ScreenPtr pScreen)
-{
- if (VidModeGetPtr(pScreen))
- return TRUE;
- else {
- DebugF("pVidMode == NULL\n");
- return FALSE;
- }
-}
-
static vidMonitorValue
xf86VidModeGetMonitorValue(ScreenPtr pScreen, int valtyp, int indx)
{
@@ -68,9 +57,6 @@ xf86VidModeGetMonitorValue(ScreenPtr pScreen, int valtyp, int indx)
MonPtr monitor;
ScrnInfoPtr pScrn;
- if (!xf86VidModeAvailable(pScreen))
- return ret;
-
pScrn = xf86ScreenToScrn(pScreen);
monitor = pScrn->monitor;
@@ -108,9 +94,6 @@ xf86VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotC
{
ScrnInfoPtr pScrn;
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
pScrn = xf86ScreenToScrn(pScreen);
if (pScrn->currentMode) {
@@ -127,9 +110,6 @@ xf86VidModeGetDotClock(ScreenPtr pScreen, int Clock)
{
ScrnInfoPtr pScrn;
- if (!xf86VidModeAvailable(pScreen))
- return 0;
-
pScrn = xf86ScreenToScrn(pScreen);
if ((pScrn->progClock) || (Clock >= MAXCLOCKS))
return Clock;
@@ -142,9 +122,6 @@ xf86VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock)
{
ScrnInfoPtr pScrn;
- if (!xf86VidModeAvailable(pScreen))
- return 0;
-
pScrn = xf86ScreenToScrn(pScreen);
if (pScrn->progClock) {
*progClock = TRUE;
@@ -162,9 +139,6 @@ xf86VidModeGetClocks(ScreenPtr pScreen, int *Clocks)
ScrnInfoPtr pScrn;
int i;
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
pScrn = xf86ScreenToScrn(pScreen);
if (pScrn->progClock)
@@ -182,9 +156,6 @@ xf86VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotCloc
VidModePtr pVidMode;
DisplayModePtr p;
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
pVidMode = VidModeGetPtr(pScreen);
for (p = pVidMode->Next; p != NULL && p != pVidMode->First; p = p->next) {
@@ -205,9 +176,6 @@ xf86VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClo
ScrnInfoPtr pScrn;
VidModePtr pVidMode;
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
pScrn = xf86ScreenToScrn(pScreen);
if (pScrn->modes == NULL)
return FALSE;
@@ -230,7 +198,7 @@ xf86VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!xf86VidModeAvailable(pScreen)))
+ if (mode == NULL)
return FALSE;
pScrn = xf86ScreenToScrn(pScreen);
@@ -241,9 +209,6 @@ xf86VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode)
static Bool
xf86VidModeZoomViewport(ScreenPtr pScreen, int zoom)
{
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
xf86ZoomViewport(pScreen, zoom);
return TRUE;
}
@@ -253,9 +218,6 @@ xf86VidModeSetViewPort(ScreenPtr pScreen, int x, int y)
{
ScrnInfoPtr pScrn;
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
pScrn = xf86ScreenToScrn(pScreen);
pScrn->frameX0 = min(max(x, 0),
pScrn->virtualX - pScrn->currentMode->HDisplay);
@@ -274,9 +236,6 @@ xf86VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y)
{
ScrnInfoPtr pScrn;
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
pScrn = xf86ScreenToScrn(pScreen);
*x = pScrn->frameX0;
*y = pScrn->frameY0;
@@ -290,9 +249,6 @@ xf86VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
DisplayModePtr pTmpMode;
Bool retval;
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
pScrn = xf86ScreenToScrn(pScreen);
/* save in case we fail */
pTmpMode = pScrn->currentMode;
@@ -308,9 +264,6 @@ xf86VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
static Bool
xf86VidModeLockZoom(ScreenPtr pScreen, Bool lock)
{
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
if (xf86Info.dontZoom)
return FALSE;
@@ -323,7 +276,7 @@ xf86VidModeCheckModeForMonitor(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!xf86VidModeAvailable(pScreen)))
+ if (mode == NULL)
return MODE_ERROR;
pScrn = xf86ScreenToScrn(pScreen);
@@ -336,7 +289,7 @@ xf86VidModeCheckModeForDriver(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!xf86VidModeAvailable(pScreen)))
+ if (mode == NULL)
return MODE_ERROR;
pScrn = xf86ScreenToScrn(pScreen);
@@ -350,7 +303,7 @@ xf86VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode)
ScrnInfoPtr pScrn;
DisplayModePtr ScreenModes;
- if ((mode == NULL) || (!xf86VidModeAvailable(pScreen)))
+ if (mode == NULL)
return;
/* Ugly hack so that the xf86Mode.c function can be used without change */
@@ -368,7 +321,7 @@ xf86VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!xf86VidModeAvailable(pScreen)))
+ if (mode == NULL)
return FALSE;
pScrn = xf86ScreenToScrn(pScreen);
@@ -405,9 +358,6 @@ xf86VidModeSetGamma(ScreenPtr pScreen, float red, float green, float blue)
{
Gamma gamma;
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
gamma.red = red;
gamma.green = green;
gamma.blue = blue;
@@ -422,9 +372,6 @@ xf86VidModeGetGamma(ScreenPtr pScreen, float *red, float *green, float *blue)
{
ScrnInfoPtr pScrn;
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
pScrn = xf86ScreenToScrn(pScreen);
*red = pScrn->gamma.red;
*green = pScrn->gamma.green;
@@ -435,9 +382,6 @@ xf86VidModeGetGamma(ScreenPtr pScreen, float *red, float *green, float *blue)
static Bool
xf86VidModeSetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
{
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
xf86ChangeGammaRamp(pScreen, size, r, g, b);
return TRUE;
}
@@ -445,9 +389,6 @@ xf86VidModeSetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD1
static Bool
xf86VidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
{
- if (!xf86VidModeAvailable(pScreen))
- return FALSE;
-
xf86GetGammaRamp(pScreen, size, r, g, b);
return TRUE;
}
@@ -455,9 +396,6 @@ xf86VidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD1
static int
xf86VidModeGetGammaRampSize(ScreenPtr pScreen)
{
- if (!xf86VidModeAvailable(pScreen))
- return 0;
-
return xf86GetGammaRampSize(pScreen);
}
commit f175cf45aebcdda53f3ae49c0eaf27da1f194e92
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Wed Feb 10 09:34:34 2016 +0100
vidmode: move to a separate library of its own
XVidMode extension might be useful to non hardware servers as well (e.g.
Xwayand) so that applications that rely on it (e.g. lot of older games)
can at least have read access to XVidMode.
But the implementation is very XFree86 centric, so the idea is to add
a bunch of vfunc that other non-XFree86 servers can hook up into to
provide a similar functionality.
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=87806
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/Xext/Makefile.am b/Xext/Makefile.am
index a9a4468..1ceb980 100644
--- a/Xext/Makefile.am
+++ b/Xext/Makefile.am
@@ -1,4 +1,4 @@
-noinst_LTLIBRARIES = libXext.la libXextdpmsstubs.la
+noinst_LTLIBRARIES = libXext.la libXextdpmsstubs.la libXvidmode.la
AM_CFLAGS = $(DIX_CFLAGS)
@@ -6,7 +6,7 @@ if XORG
sdk_HEADERS = xvdix.h xvmcext.h geext.h geint.h shmint.h syncsdk.h
endif
-# Sources always included in libXextbuiltin.la & libXext.la
+# Sources always included in libXextbuiltin.la, libXext.la
BUILTIN_SRCS = \
bigreq.c \
geext.c \
@@ -98,6 +98,9 @@ libXext_la_LIBADD = $(BUILTIN_LIBS)
libXextdpmsstubs_la_SOURCES = dpmsstubs.c
+# XVidMode extension
+libXvidmode_la_SOURCES = vidmode.c
+
EXTRA_DIST = \
$(MITSHM_SRCS) \
$(XV_SRCS) \
diff --git a/Xext/vidmode.c b/Xext/vidmode.c
new file mode 100644
index 0000000..7ea5ddf
--- /dev/null
+++ b/Xext/vidmode.c
@@ -0,0 +1,2147 @@
+/*
+
+Copyright 1995 Kaleb S. KEITHLEY
+
+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 Kaleb S. KEITHLEY 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.
+
+Except as contained in this notice, the name of Kaleb S. KEITHLEY
+shall not be used in advertising or otherwise to promote the sale, use
+or other dealings in this Software without prior written authorization
+from Kaleb S. KEITHLEY
+
+*/
+/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include <X11/extensions/xf86vmproto.h>
+#include "misc.h"
+#include "dixstruct.h"
+#include "extnsionst.h"
+#include "scrnintstr.h"
+#include "servermd.h"
+#include "swaprep.h"
+#include "vidmodestr.h"
+#include "globals.h"
+#include "protocol-versions.h"
+
+static int VidModeErrorBase;
+static int VidModeAllowNonLocal;
+
+static DevPrivateKeyRec VidModeClientPrivateKeyRec;
+#define VidModeClientPrivateKey (&VidModeClientPrivateKeyRec)
+
+static DevPrivateKeyRec VidModePrivateKeyRec;
+#define VidModePrivateKey (&VidModePrivateKeyRec)
+
+/* This holds the client's version information */
+typedef struct {
+ int major;
+ int minor;
+} VidModePrivRec, *VidModePrivPtr;
+
+#define VM_GETPRIV(c) ((VidModePrivPtr) \
+ dixLookupPrivate(&(c)->devPrivates, VidModeClientPrivateKey))
+#define VM_SETPRIV(c,p) \
+ dixSetPrivate(&(c)->devPrivates, VidModeClientPrivateKey, p)
+
+#ifdef DEBUG
+#define DEBUG_P(x) LogMessage(X_INFO, x"\n");
+#else
+#define DEBUG_P(x) /**/
+#endif
+
+static DisplayModePtr
+VidModeCreateMode(void)
+{
+ DisplayModePtr mode;
+
+ mode = malloc(sizeof(DisplayModeRec));
+ if (mode != NULL) {
+ mode->name = "";
+ mode->VScan = 1; /* divides refresh rate. default = 1 */
+ mode->Private = NULL;
+ mode->next = mode;
+ mode->prev = mode;
+ }
+ return mode;
+}
+
+static void
+VidModeCopyMode(DisplayModePtr modefrom, DisplayModePtr modeto)
+{
+ memcpy(modeto, modefrom, sizeof(DisplayModeRec));
+}
+
+static int
+VidModeGetModeValue(DisplayModePtr mode, int valtyp)
+{
+ int ret = 0;
+
+ switch (valtyp) {
+ case VIDMODE_H_DISPLAY:
+ ret = mode->HDisplay;
+ break;
+ case VIDMODE_H_SYNCSTART:
+ ret = mode->HSyncStart;
+ break;
+ case VIDMODE_H_SYNCEND:
+ ret = mode->HSyncEnd;
+ break;
+ case VIDMODE_H_TOTAL:
+ ret = mode->HTotal;
+ break;
+ case VIDMODE_H_SKEW:
+ ret = mode->HSkew;
+ break;
+ case VIDMODE_V_DISPLAY:
+ ret = mode->VDisplay;
+ break;
+ case VIDMODE_V_SYNCSTART:
+ ret = mode->VSyncStart;
+ break;
+ case VIDMODE_V_SYNCEND:
+ ret = mode->VSyncEnd;
+ break;
+ case VIDMODE_V_TOTAL:
+ ret = mode->VTotal;
+ break;
+ case VIDMODE_FLAGS:
+ ret = mode->Flags;
+ break;
+ case VIDMODE_CLOCK:
+ ret = mode->Clock;
+ break;
+ }
+ return ret;
+}
+
+static void
+VidModeSetModeValue(DisplayModePtr mode, int valtyp, int val)
+{
+ switch (valtyp) {
+ case VIDMODE_H_DISPLAY:
+ mode->HDisplay = val;
+ break;
+ case VIDMODE_H_SYNCSTART:
+ mode->HSyncStart = val;
+ break;
+ case VIDMODE_H_SYNCEND:
+ mode->HSyncEnd = val;
+ break;
+ case VIDMODE_H_TOTAL:
+ mode->HTotal = val;
+ break;
+ case VIDMODE_H_SKEW:
+ mode->HSkew = val;
+ break;
+ case VIDMODE_V_DISPLAY:
+ mode->VDisplay = val;
+ break;
+ case VIDMODE_V_SYNCSTART:
+ mode->VSyncStart = val;
+ break;
+ case VIDMODE_V_SYNCEND:
+ mode->VSyncEnd = val;
+ break;
+ case VIDMODE_V_TOTAL:
+ mode->VTotal = val;
+ break;
+ case VIDMODE_FLAGS:
+ mode->Flags = val;
+ break;
+ case VIDMODE_CLOCK:
+ mode->Clock = val;
+ break;
+ }
+ return;
+}
+
+static int
+ClientMajorVersion(ClientPtr client)
+{
+ VidModePrivPtr pPriv;
+
+ pPriv = VM_GETPRIV(client);
+ if (!pPriv)
+ return 0;
+ else
+ return pPriv->major;
+}
+
+static int
+ProcVidModeQueryVersion(ClientPtr client)
+{
+ xXF86VidModeQueryVersionReply rep = {
+ .type = X_Reply,
+ .sequenceNumber = client->sequence,
+ .length = 0,
+ .majorVersion = SERVER_XF86VIDMODE_MAJOR_VERSION,
+ .minorVersion = SERVER_XF86VIDMODE_MINOR_VERSION
+ };
+
+ DEBUG_P("XF86VidModeQueryVersion");
+
+ REQUEST_SIZE_MATCH(xXF86VidModeQueryVersionReq);
+
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swaps(&rep.majorVersion);
+ swaps(&rep.minorVersion);
+ }
+ WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), &rep);
+ return Success;
+}
+
+static int
+ProcVidModeGetModeLine(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetModeLineReq);
+ xXF86VidModeGetModeLineReply rep = {
+ .type = X_Reply,
+ .sequenceNumber = client->sequence
+ };
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+ DisplayModePtr mode;
+ int dotClock;
+ int ver;
+
+ DEBUG_P("XF86VidModeGetModeline");
+
+ ver = ClientMajorVersion(client);
+ REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
+
+ if (ver < 2) {
+ rep.length = bytes_to_int32(SIZEOF(xXF86OldVidModeGetModeLineReply) -
+ SIZEOF(xGenericReply));
+ }
+ else {
+ rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetModeLineReply) -
+ SIZEOF(xGenericReply));
+ }
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
+ return BadValue;
+
+ rep.dotclock = dotClock;
+ rep.hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY);
+ rep.hsyncstart = VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART);
+ rep.hsyncend = VidModeGetModeValue(mode, VIDMODE_H_SYNCEND);
+ rep.htotal = VidModeGetModeValue(mode, VIDMODE_H_TOTAL);
+ rep.hskew = VidModeGetModeValue(mode, VIDMODE_H_SKEW);
+ rep.vdisplay = VidModeGetModeValue(mode, VIDMODE_V_DISPLAY);
+ rep.vsyncstart = VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART);
+ rep.vsyncend = VidModeGetModeValue(mode, VIDMODE_V_SYNCEND);
+ rep.vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL);
+ rep.flags = VidModeGetModeValue(mode, VIDMODE_FLAGS);
+
+ LogMessage(X_INFO, "GetModeLine - scrn: %d clock: %ld\n",
+ stuff->screen, (unsigned long) rep.dotclock);
+ LogMessage(X_INFO, "GetModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
+ rep.hdisplay, rep.hsyncstart, rep.hsyncend, rep.htotal);
+ LogMessage(X_INFO, " vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+ rep.vdisplay, rep.vsyncstart, rep.vsyncend,
+ rep.vtotal, (unsigned long) rep.flags);
+
+ /*
+ * Older servers sometimes had server privates that the VidMode
+ * extention made available. So to be compatiable pretend that
+ * there are no server privates to pass to the client
+ */
+ rep.privsize = 0;
+
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swapl(&rep.dotclock);
+ swaps(&rep.hdisplay);
+ swaps(&rep.hsyncstart);
+ swaps(&rep.hsyncend);
+ swaps(&rep.htotal);
+ swaps(&rep.hskew);
+ swaps(&rep.vdisplay);
+ swaps(&rep.vsyncstart);
+ swaps(&rep.vsyncend);
+ swaps(&rep.vtotal);
+ swapl(&rep.flags);
+ swapl(&rep.privsize);
+ }
+ if (ver < 2) {
+ xXF86OldVidModeGetModeLineReply oldrep = {
+ .type = rep.type,
+ .sequenceNumber = rep.sequenceNumber,
+ .length = rep.length,
+ .dotclock = rep.dotclock,
+ .hdisplay = rep.hdisplay,
+ .hsyncstart = rep.hsyncstart,
+ .hsyncend = rep.hsyncend,
+ .htotal = rep.htotal,
+ .vdisplay = rep.vdisplay,
+ .vsyncstart = rep.vsyncstart,
+ .vsyncend = rep.vsyncend,
+ .vtotal = rep.vtotal,
+ .flags = rep.flags,
+ .privsize = rep.privsize
+ };
+ WriteToClient(client, sizeof(xXF86OldVidModeGetModeLineReply), &oldrep);
+ }
+ else {
+ WriteToClient(client, sizeof(xXF86VidModeGetModeLineReply), &rep);
+ }
+ return Success;
+}
+
+static int
+ProcVidModeGetAllModeLines(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetAllModeLinesReq);
+ xXF86VidModeGetAllModeLinesReply rep;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+ DisplayModePtr mode;
+ int modecount, dotClock;
+ int ver;
+
+ DEBUG_P("XF86VidModeGetAllModelines");
+
+ REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+ ver = ClientMajorVersion(client);
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ modecount = pVidMode->GetNumOfModes(pScreen);
+ if (modecount < 1)
+ return VidModeErrorBase + XF86VidModeExtensionDisabled;
+
+ if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock))
+ return BadValue;
+
+ rep = (xXF86VidModeGetAllModeLinesReply) {
+ .type = X_Reply,
+ .length = SIZEOF(xXF86VidModeGetAllModeLinesReply) -
+ SIZEOF(xGenericReply),
+ .sequenceNumber = client->sequence,
+ .modecount = modecount
+ };
+ if (ver < 2)
+ rep.length += modecount * sizeof(xXF86OldVidModeModeInfo);
+ else
+ rep.length += modecount * sizeof(xXF86VidModeModeInfo);
+ rep.length >>= 2;
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swapl(&rep.modecount);
+ }
+ WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply), &rep);
+
+ do {
+ xXF86VidModeModeInfo mdinf = {
+ .dotclock = dotClock,
+ .hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
+ .hsyncstart = VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
+ .hsyncend = VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
+ .htotal = VidModeGetModeValue(mode, VIDMODE_H_TOTAL),
+ .hskew = VidModeGetModeValue(mode, VIDMODE_H_SKEW),
+ .vdisplay = VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
+ .vsyncstart = VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
+ .vsyncend = VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
+ .vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
+ .flags = VidModeGetModeValue(mode, VIDMODE_FLAGS),
+ .privsize = 0
+ };
+ if (client->swapped) {
+ swapl(&mdinf.dotclock);
+ swaps(&mdinf.hdisplay);
+ swaps(&mdinf.hsyncstart);
+ swaps(&mdinf.hsyncend);
+ swaps(&mdinf.htotal);
+ swapl(&mdinf.hskew);
+ swaps(&mdinf.vdisplay);
+ swaps(&mdinf.vsyncstart);
+ swaps(&mdinf.vsyncend);
+ swaps(&mdinf.vtotal);
+ swapl(&mdinf.flags);
+ swapl(&mdinf.privsize);
+ }
+ if (ver < 2) {
+ xXF86OldVidModeModeInfo oldmdinf = {
+ .dotclock = mdinf.dotclock,
+ .hdisplay = mdinf.hdisplay,
+ .hsyncstart = mdinf.hsyncstart,
+ .hsyncend = mdinf.hsyncend,
+ .htotal = mdinf.htotal,
+ .vdisplay = mdinf.vdisplay,
+ .vsyncstart = mdinf.vsyncstart,
+ .vsyncend = mdinf.vsyncend,
+ .vtotal = mdinf.vtotal,
+ .flags = mdinf.flags,
+ .privsize = mdinf.privsize
+ };
+ WriteToClient(client, sizeof(xXF86OldVidModeModeInfo), &oldmdinf);
+ }
+ else {
+ WriteToClient(client, sizeof(xXF86VidModeModeInfo), &mdinf);
+ }
+
+ } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
+
+ return Success;
+}
+
+#define MODEMATCH(mode,stuff) \
+ (VidModeGetModeValue(mode, VIDMODE_H_DISPLAY) == stuff->hdisplay \
+ && VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART) == stuff->hsyncstart \
+ && VidModeGetModeValue(mode, VIDMODE_H_SYNCEND) == stuff->hsyncend \
+ && VidModeGetModeValue(mode, VIDMODE_H_TOTAL) == stuff->htotal \
+ && VidModeGetModeValue(mode, VIDMODE_V_DISPLAY) == stuff->vdisplay \
+ && VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART) == stuff->vsyncstart \
+ && VidModeGetModeValue(mode, VIDMODE_V_SYNCEND) == stuff->vsyncend \
+ && VidModeGetModeValue(mode, VIDMODE_V_TOTAL) == stuff->vtotal \
+ && VidModeGetModeValue(mode, VIDMODE_FLAGS) == stuff->flags )
+
+static int
+ProcVidModeAddModeLine(ClientPtr client)
+{
+ REQUEST(xXF86VidModeAddModeLineReq);
+ xXF86OldVidModeAddModeLineReq *oldstuff =
+ (xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
+ xXF86VidModeAddModeLineReq newstuff;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+ DisplayModePtr mode;
+ int len;
+ int dotClock;
+ int ver;
+
+ DEBUG_P("XF86VidModeAddModeline");
+
+ ver = ClientMajorVersion(client);
+ if (ver < 2) {
+ /* convert from old format */
+ stuff = &newstuff;
+ stuff->length = oldstuff->length;
+ stuff->screen = oldstuff->screen;
+ stuff->dotclock = oldstuff->dotclock;
+ stuff->hdisplay = oldstuff->hdisplay;
+ stuff->hsyncstart = oldstuff->hsyncstart;
+ stuff->hsyncend = oldstuff->hsyncend;
+ stuff->htotal = oldstuff->htotal;
+ stuff->hskew = 0;
+ stuff->vdisplay = oldstuff->vdisplay;
+ stuff->vsyncstart = oldstuff->vsyncstart;
+ stuff->vsyncend = oldstuff->vsyncend;
+ stuff->vtotal = oldstuff->vtotal;
+ stuff->flags = oldstuff->flags;
+ stuff->privsize = oldstuff->privsize;
+ stuff->after_dotclock = oldstuff->after_dotclock;
+ stuff->after_hdisplay = oldstuff->after_hdisplay;
+ stuff->after_hsyncstart = oldstuff->after_hsyncstart;
+ stuff->after_hsyncend = oldstuff->after_hsyncend;
+ stuff->after_htotal = oldstuff->after_htotal;
+ stuff->after_hskew = 0;
+ stuff->after_vdisplay = oldstuff->after_vdisplay;
+ stuff->after_vsyncstart = oldstuff->after_vsyncstart;
+ stuff->after_vsyncend = oldstuff->after_vsyncend;
+ stuff->after_vtotal = oldstuff->after_vtotal;
+ stuff->after_flags = oldstuff->after_flags;
+ }
+ LogMessage(X_INFO, "AddModeLine - scrn: %d clock: %ld\n",
+ (int) stuff->screen, (unsigned long) stuff->dotclock);
+ LogMessage(X_INFO, "AddModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
+ stuff->hdisplay, stuff->hsyncstart,
+ stuff->hsyncend, stuff->htotal);
+ LogMessage(X_INFO, " vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+ stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
+ stuff->vtotal, (unsigned long) stuff->flags);
+ LogMessage(X_INFO, " after - scrn: %d clock: %ld\n",
+ (int) stuff->screen, (unsigned long) stuff->after_dotclock);
+ LogMessage(X_INFO, " hdsp: %d hbeg: %d hend: %d httl: %d\n",
+ stuff->after_hdisplay, stuff->after_hsyncstart,
+ stuff->after_hsyncend, stuff->after_htotal);
+ LogMessage(X_INFO, " vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+ stuff->after_vdisplay, stuff->after_vsyncstart,
+ stuff->after_vsyncend, stuff->after_vtotal,
+ (unsigned long) stuff->after_flags);
+
+ if (ver < 2) {
+ REQUEST_AT_LEAST_SIZE(xXF86OldVidModeAddModeLineReq);
+ len =
+ client->req_len -
+ bytes_to_int32(sizeof(xXF86OldVidModeAddModeLineReq));
+ }
+ else {
+ REQUEST_AT_LEAST_SIZE(xXF86VidModeAddModeLineReq);
+ len =
+ client->req_len -
+ bytes_to_int32(sizeof(xXF86VidModeAddModeLineReq));
+ }
+ if (len != stuff->privsize)
+ return BadLength;
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ if (stuff->hsyncstart < stuff->hdisplay ||
+ stuff->hsyncend < stuff->hsyncstart ||
+ stuff->htotal < stuff->hsyncend ||
+ stuff->vsyncstart < stuff->vdisplay ||
+ stuff->vsyncend < stuff->vsyncstart || stuff->vtotal < stuff->vsyncend)
+ return BadValue;
+
+ if (stuff->after_hsyncstart < stuff->after_hdisplay ||
+ stuff->after_hsyncend < stuff->after_hsyncstart ||
+ stuff->after_htotal < stuff->after_hsyncend ||
+ stuff->after_vsyncstart < stuff->after_vdisplay ||
+ stuff->after_vsyncend < stuff->after_vsyncstart ||
+ stuff->after_vtotal < stuff->after_vsyncend)
+ return BadValue;
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (stuff->after_htotal != 0 || stuff->after_vtotal != 0) {
+ Bool found = FALSE;
+
+ if (pVidMode->GetFirstModeline(pScreen, &mode, &dotClock)) {
+ do {
+ if ((pVidMode->GetDotClock(pScreen, stuff->dotclock)
+ == dotClock) && MODEMATCH(mode, stuff)) {
+ found = TRUE;
+ break;
+ }
+ } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
+ }
+ if (!found)
+ return BadValue;
+ }
+
+ mode = VidModeCreateMode();
+ if (mode == NULL)
+ return BadValue;
+
+ VidModeSetModeValue(mode, VIDMODE_CLOCK, stuff->dotclock);
+ VidModeSetModeValue(mode, VIDMODE_H_DISPLAY, stuff->hdisplay);
+ VidModeSetModeValue(mode, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
+ VidModeSetModeValue(mode, VIDMODE_H_SYNCEND, stuff->hsyncend);
+ VidModeSetModeValue(mode, VIDMODE_H_TOTAL, stuff->htotal);
+ VidModeSetModeValue(mode, VIDMODE_H_SKEW, stuff->hskew);
+ VidModeSetModeValue(mode, VIDMODE_V_DISPLAY, stuff->vdisplay);
+ VidModeSetModeValue(mode, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
+ VidModeSetModeValue(mode, VIDMODE_V_SYNCEND, stuff->vsyncend);
+ VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal);
+ VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags);
+
+ if (stuff->privsize)
+ LogMessage(X_INFO, "AddModeLine - Privates in request have been ignored\n");
+
+ /* Check that the mode is consistent with the monitor specs */
+ switch (pVidMode->CheckModeForMonitor(pScreen, mode)) {
+ case MODE_OK:
+ break;
+ case MODE_HSYNC:
+ case MODE_H_ILLEGAL:
+ free(mode);
+ return VidModeErrorBase + XF86VidModeBadHTimings;
+ case MODE_VSYNC:
+ case MODE_V_ILLEGAL:
+ free(mode);
+ return VidModeErrorBase + XF86VidModeBadVTimings;
+ default:
+ free(mode);
+ return VidModeErrorBase + XF86VidModeModeUnsuitable;
+ }
+
+ /* Check that the driver is happy with the mode */
+ if (pVidMode->CheckModeForDriver(pScreen, mode) != MODE_OK) {
+ free(mode);
+ return VidModeErrorBase + XF86VidModeModeUnsuitable;
+ }
+
+ pVidMode->SetCrtcForMode(pScreen, mode);
+
+ pVidMode->AddModeline(pScreen, mode);
+
+ LogMessage(X_INFO, "AddModeLine - Succeeded\n");
+
+ return Success;
+}
+
+static int
+ProcVidModeDeleteModeLine(ClientPtr client)
+{
+ REQUEST(xXF86VidModeDeleteModeLineReq);
+ xXF86OldVidModeDeleteModeLineReq *oldstuff =
+ (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
+ xXF86VidModeDeleteModeLineReq newstuff;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+ DisplayModePtr mode;
+ int len, dotClock;
+ int ver;
+
+ DEBUG_P("XF86VidModeDeleteModeline");
+
+ ver = ClientMajorVersion(client);
+ if (ver < 2) {
+ /* convert from old format */
+ stuff = &newstuff;
+ stuff->length = oldstuff->length;
+ stuff->screen = oldstuff->screen;
+ stuff->dotclock = oldstuff->dotclock;
+ stuff->hdisplay = oldstuff->hdisplay;
+ stuff->hsyncstart = oldstuff->hsyncstart;
+ stuff->hsyncend = oldstuff->hsyncend;
+ stuff->htotal = oldstuff->htotal;
+ stuff->hskew = 0;
+ stuff->vdisplay = oldstuff->vdisplay;
+ stuff->vsyncstart = oldstuff->vsyncstart;
+ stuff->vsyncend = oldstuff->vsyncend;
+ stuff->vtotal = oldstuff->vtotal;
+ stuff->flags = oldstuff->flags;
+ stuff->privsize = oldstuff->privsize;
+ }
+ LogMessage(X_INFO, "DeleteModeLine - scrn: %d clock: %ld\n",
+ (int) stuff->screen, (unsigned long) stuff->dotclock);
+ LogMessage(X_INFO, " hdsp: %d hbeg: %d hend: %d httl: %d\n",
+ stuff->hdisplay, stuff->hsyncstart,
+ stuff->hsyncend, stuff->htotal);
+ LogMessage(X_INFO, " vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+ stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
+ (unsigned long) stuff->flags);
+
+ if (ver < 2) {
+ REQUEST_AT_LEAST_SIZE(xXF86OldVidModeDeleteModeLineReq);
+ len =
+ client->req_len -
+ bytes_to_int32(sizeof(xXF86OldVidModeDeleteModeLineReq));
+ }
+ else {
+ REQUEST_AT_LEAST_SIZE(xXF86VidModeDeleteModeLineReq);
+ len =
+ client->req_len -
+ bytes_to_int32(sizeof(xXF86VidModeDeleteModeLineReq));
+ }
+ if (len != stuff->privsize) {
+ LogMessage(X_INFO, "req_len = %ld, sizeof(Req) = %d, privsize = %ld, "
+ "len = %d, length = %d\n",
+ (unsigned long) client->req_len,
+ (int) sizeof(xXF86VidModeDeleteModeLineReq) >> 2,
+ (unsigned long) stuff->privsize, len, stuff->length);
+ return BadLength;
+ }
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
+ return BadValue;
+
+ LogMessage(X_INFO, "Checking against clock: %d (%d)\n",
+ VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
+ LogMessage(X_INFO, " hdsp: %d hbeg: %d hend: %d httl: %d\n",
+ VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
+ VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
+ VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
+ VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
+ LogMessage(X_INFO, " vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
+ VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
+ VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
+ VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
+ VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
+ VidModeGetModeValue(mode, VIDMODE_FLAGS));
+
+ if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) &&
+ MODEMATCH(mode, stuff))
+ return BadValue;
+
+ if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock))
+ return BadValue;
+
+ do {
+ LogMessage(X_INFO, "Checking against clock: %d (%d)\n",
+ VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
+ LogMessage(X_INFO, " hdsp: %d hbeg: %d hend: %d httl: %d\n",
+ VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
+ VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
+ VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
+ VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
+ LogMessage(X_INFO, " vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
+ VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
+ VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
+ VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
+ VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
+ VidModeGetModeValue(mode, VIDMODE_FLAGS));
+
+ if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) &&
+ MODEMATCH(mode, stuff)) {
+ pVidMode->DeleteModeline(pScreen, mode);
+ LogMessage(X_INFO, "DeleteModeLine - Succeeded\n");
+ return Success;
+ }
+ } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
+
+ return BadValue;
+}
+
+static int
+ProcVidModeModModeLine(ClientPtr client)
+{
+ REQUEST(xXF86VidModeModModeLineReq);
+ xXF86OldVidModeModModeLineReq *oldstuff =
+ (xXF86OldVidModeModModeLineReq *) client->requestBuffer;
+ xXF86VidModeModModeLineReq newstuff;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+ DisplayModePtr mode, modetmp;
+ int len, dotClock;
+ int ver;
+
+ DEBUG_P("XF86VidModeModModeline");
+
+ ver = ClientMajorVersion(client);
+ if (ver < 2) {
+ /* convert from old format */
+ stuff = &newstuff;
+ stuff->length = oldstuff->length;
+ stuff->screen = oldstuff->screen;
+ stuff->hdisplay = oldstuff->hdisplay;
+ stuff->hsyncstart = oldstuff->hsyncstart;
+ stuff->hsyncend = oldstuff->hsyncend;
+ stuff->htotal = oldstuff->htotal;
+ stuff->hskew = 0;
+ stuff->vdisplay = oldstuff->vdisplay;
+ stuff->vsyncstart = oldstuff->vsyncstart;
+ stuff->vsyncend = oldstuff->vsyncend;
+ stuff->vtotal = oldstuff->vtotal;
+ stuff->flags = oldstuff->flags;
+ stuff->privsize = oldstuff->privsize;
+ }
+ LogMessage(X_INFO, "ModModeLine - scrn: %d hdsp: %d hbeg: %d hend: %d httl: %d\n",
+ (int) stuff->screen, stuff->hdisplay, stuff->hsyncstart,
+ stuff->hsyncend, stuff->htotal);
+ LogMessage(X_INFO, " vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+ stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
+ stuff->vtotal, (unsigned long) stuff->flags);
+
+ if (ver < 2) {
+ REQUEST_AT_LEAST_SIZE(xXF86OldVidModeModModeLineReq);
+ len =
+ client->req_len -
+ bytes_to_int32(sizeof(xXF86OldVidModeModModeLineReq));
+ }
+ else {
+ REQUEST_AT_LEAST_SIZE(xXF86VidModeModModeLineReq);
+ len =
+ client->req_len -
+ bytes_to_int32(sizeof(xXF86VidModeModModeLineReq));
+ }
+ if (len != stuff->privsize)
+ return BadLength;
+
+ if (stuff->hsyncstart < stuff->hdisplay ||
+ stuff->hsyncend < stuff->hsyncstart ||
+ stuff->htotal < stuff->hsyncend ||
+ stuff->vsyncstart < stuff->vdisplay ||
+ stuff->vsyncend < stuff->vsyncstart || stuff->vtotal < stuff->vsyncend)
+ return BadValue;
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
+ return BadValue;
+
+ modetmp = VidModeCreateMode();
+ VidModeCopyMode(mode, modetmp);
+
+ VidModeSetModeValue(modetmp, VIDMODE_H_DISPLAY, stuff->hdisplay);
+ VidModeSetModeValue(modetmp, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
+ VidModeSetModeValue(modetmp, VIDMODE_H_SYNCEND, stuff->hsyncend);
+ VidModeSetModeValue(modetmp, VIDMODE_H_TOTAL, stuff->htotal);
+ VidModeSetModeValue(modetmp, VIDMODE_H_SKEW, stuff->hskew);
+ VidModeSetModeValue(modetmp, VIDMODE_V_DISPLAY, stuff->vdisplay);
+ VidModeSetModeValue(modetmp, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
+ VidModeSetModeValue(modetmp, VIDMODE_V_SYNCEND, stuff->vsyncend);
+ VidModeSetModeValue(modetmp, VIDMODE_V_TOTAL, stuff->vtotal);
+ VidModeSetModeValue(modetmp, VIDMODE_FLAGS, stuff->flags);
+
+ if (stuff->privsize)
+ LogMessage(X_INFO, "ModModeLine - Privates in request have been ignored\n");
+
+ /* Check that the mode is consistent with the monitor specs */
+ switch (pVidMode->CheckModeForMonitor(pScreen, modetmp)) {
+ case MODE_OK:
+ break;
+ case MODE_HSYNC:
+ case MODE_H_ILLEGAL:
+ free(modetmp);
+ return VidModeErrorBase + XF86VidModeBadHTimings;
+ case MODE_VSYNC:
+ case MODE_V_ILLEGAL:
+ free(modetmp);
+ return VidModeErrorBase + XF86VidModeBadVTimings;
+ default:
+ free(modetmp);
+ return VidModeErrorBase + XF86VidModeModeUnsuitable;
+ }
+
+ /* Check that the driver is happy with the mode */
+ if (pVidMode->CheckModeForDriver(pScreen, modetmp) != MODE_OK) {
+ free(modetmp);
+ return VidModeErrorBase + XF86VidModeModeUnsuitable;
+ }
+ free(modetmp);
+
+ VidModeSetModeValue(mode, VIDMODE_H_DISPLAY, stuff->hdisplay);
+ VidModeSetModeValue(mode, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
+ VidModeSetModeValue(mode, VIDMODE_H_SYNCEND, stuff->hsyncend);
+ VidModeSetModeValue(mode, VIDMODE_H_TOTAL, stuff->htotal);
+ VidModeSetModeValue(mode, VIDMODE_H_SKEW, stuff->hskew);
+ VidModeSetModeValue(mode, VIDMODE_V_DISPLAY, stuff->vdisplay);
+ VidModeSetModeValue(mode, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
+ VidModeSetModeValue(mode, VIDMODE_V_SYNCEND, stuff->vsyncend);
+ VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal);
+ VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags);
+
+ pVidMode->SetCrtcForMode(pScreen, mode);
+ pVidMode->SwitchMode(pScreen, mode);
+
+ LogMessage(X_INFO, "ModModeLine - Succeeded\n");
+ return Success;
+}
+
+static int
+ProcVidModeValidateModeLine(ClientPtr client)
+{
+ REQUEST(xXF86VidModeValidateModeLineReq);
+ xXF86OldVidModeValidateModeLineReq *oldstuff =
+ (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer;
+ xXF86VidModeValidateModeLineReq newstuff;
+ xXF86VidModeValidateModeLineReply rep;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+ DisplayModePtr mode, modetmp = NULL;
+ int len, status, dotClock;
+ int ver;
+
+ DEBUG_P("XF86VidModeValidateModeline");
+
+ ver = ClientMajorVersion(client);
+ if (ver < 2) {
+ /* convert from old format */
+ stuff = &newstuff;
+ stuff->length = oldstuff->length;
+ stuff->screen = oldstuff->screen;
+ stuff->dotclock = oldstuff->dotclock;
+ stuff->hdisplay = oldstuff->hdisplay;
+ stuff->hsyncstart = oldstuff->hsyncstart;
+ stuff->hsyncend = oldstuff->hsyncend;
+ stuff->htotal = oldstuff->htotal;
+ stuff->hskew = 0;
+ stuff->vdisplay = oldstuff->vdisplay;
+ stuff->vsyncstart = oldstuff->vsyncstart;
+ stuff->vsyncend = oldstuff->vsyncend;
+ stuff->vtotal = oldstuff->vtotal;
+ stuff->flags = oldstuff->flags;
+ stuff->privsize = oldstuff->privsize;
+ }
+
+ LogMessage(X_INFO, "ValidateModeLine - scrn: %d clock: %ld\n",
+ (int) stuff->screen, (unsigned long) stuff->dotclock);
+ LogMessage(X_INFO, " hdsp: %d hbeg: %d hend: %d httl: %d\n",
+ stuff->hdisplay, stuff->hsyncstart,
+ stuff->hsyncend, stuff->htotal);
+ LogMessage(X_INFO, " vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+ stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
+ (unsigned long) stuff->flags);
+
+ if (ver < 2) {
+ REQUEST_AT_LEAST_SIZE(xXF86OldVidModeValidateModeLineReq);
+ len = client->req_len -
+ bytes_to_int32(sizeof(xXF86OldVidModeValidateModeLineReq));
+ }
+ else {
+ REQUEST_AT_LEAST_SIZE(xXF86VidModeValidateModeLineReq);
+ len =
+ client->req_len -
+ bytes_to_int32(sizeof(xXF86VidModeValidateModeLineReq));
+ }
+ if (len != stuff->privsize)
+ return BadLength;
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ status = MODE_OK;
+
+ if (stuff->hsyncstart < stuff->hdisplay ||
+ stuff->hsyncend < stuff->hsyncstart ||
+ stuff->htotal < stuff->hsyncend ||
+ stuff->vsyncstart < stuff->vdisplay ||
+ stuff->vsyncend < stuff->vsyncstart ||
+ stuff->vtotal < stuff->vsyncend) {
+ status = MODE_BAD;
+ goto status_reply;
+ }
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
+ return BadValue;
+
+ modetmp = VidModeCreateMode();
+ VidModeCopyMode(mode, modetmp);
+
+ VidModeSetModeValue(modetmp, VIDMODE_H_DISPLAY, stuff->hdisplay);
+ VidModeSetModeValue(modetmp, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
+ VidModeSetModeValue(modetmp, VIDMODE_H_SYNCEND, stuff->hsyncend);
+ VidModeSetModeValue(modetmp, VIDMODE_H_TOTAL, stuff->htotal);
+ VidModeSetModeValue(modetmp, VIDMODE_H_SKEW, stuff->hskew);
+ VidModeSetModeValue(modetmp, VIDMODE_V_DISPLAY, stuff->vdisplay);
+ VidModeSetModeValue(modetmp, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
+ VidModeSetModeValue(modetmp, VIDMODE_V_SYNCEND, stuff->vsyncend);
+ VidModeSetModeValue(modetmp, VIDMODE_V_TOTAL, stuff->vtotal);
+ VidModeSetModeValue(modetmp, VIDMODE_FLAGS, stuff->flags);
+ if (stuff->privsize)
+ LogMessage(X_INFO, "ValidateModeLine - Privates in request have been ignored\n");
+
+ /* Check that the mode is consistent with the monitor specs */
+ if ((status =
+ pVidMode->CheckModeForMonitor(pScreen, modetmp)) != MODE_OK)
+ goto status_reply;
+
+ /* Check that the driver is happy with the mode */
+ status = pVidMode->CheckModeForDriver(pScreen, modetmp);
+
+ status_reply:
+ free(modetmp);
+
+ rep = (xXF86VidModeValidateModeLineReply) {
+ .type = X_Reply,
+ .sequenceNumber = client->sequence,
+ .length = bytes_to_int32(SIZEOF(xXF86VidModeValidateModeLineReply)
+ - SIZEOF(xGenericReply)),
+ .status = status
+ };
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swapl(&rep.status);
+ }
+ WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply), &rep);
+ LogMessage(X_INFO, "ValidateModeLine - Succeeded (status = %d)\n", status);
+
+ return Success;
+}
+
+static int
+ProcVidModeSwitchMode(ClientPtr client)
+{
+ REQUEST(xXF86VidModeSwitchModeReq);
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+
+ DEBUG_P("XF86VidModeSwitchMode");
+
+ REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ pVidMode->ZoomViewport(pScreen, (short) stuff->zoom);
+
+ return Success;
+}
+
+static int
+ProcVidModeSwitchToMode(ClientPtr client)
+{
+ REQUEST(xXF86VidModeSwitchToModeReq);
+ xXF86OldVidModeSwitchToModeReq *oldstuff =
+ (xXF86OldVidModeSwitchToModeReq *) client->requestBuffer;
+ xXF86VidModeSwitchToModeReq newstuff;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+ DisplayModePtr mode;
+ int len, dotClock;
+ int ver;
+
+ DEBUG_P("XF86VidModeSwitchToMode");
+
+ ver = ClientMajorVersion(client);
+ if (ver < 2) {
+ /* convert from old format */
+ stuff = &newstuff;
+ stuff->length = oldstuff->length;
+ stuff->screen = oldstuff->screen;
+ stuff->dotclock = oldstuff->dotclock;
+ stuff->hdisplay = oldstuff->hdisplay;
+ stuff->hsyncstart = oldstuff->hsyncstart;
+ stuff->hsyncend = oldstuff->hsyncend;
+ stuff->htotal = oldstuff->htotal;
+ stuff->hskew = 0;
+ stuff->vdisplay = oldstuff->vdisplay;
+ stuff->vsyncstart = oldstuff->vsyncstart;
+ stuff->vsyncend = oldstuff->vsyncend;
+ stuff->vtotal = oldstuff->vtotal;
+ stuff->flags = oldstuff->flags;
+ stuff->privsize = oldstuff->privsize;
+ }
+
+ LogMessage(X_INFO, "SwitchToMode - scrn: %d clock: %ld\n",
+ (int) stuff->screen, (unsigned long) stuff->dotclock);
+ LogMessage(X_INFO, " hdsp: %d hbeg: %d hend: %d httl: %d\n",
+ stuff->hdisplay, stuff->hsyncstart,
+ stuff->hsyncend, stuff->htotal);
+ LogMessage(X_INFO, " vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+ stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
+ (unsigned long) stuff->flags);
+
+ if (ver < 2) {
+ REQUEST_AT_LEAST_SIZE(xXF86OldVidModeSwitchToModeReq);
+ len =
+ client->req_len -
+ bytes_to_int32(sizeof(xXF86OldVidModeSwitchToModeReq));
+ }
+ else {
+ REQUEST_AT_LEAST_SIZE(xXF86VidModeSwitchToModeReq);
+ len =
+ client->req_len -
+ bytes_to_int32(sizeof(xXF86VidModeSwitchToModeReq));
+ }
+ if (len != stuff->privsize)
+ return BadLength;
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
+ return BadValue;
+
+ if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock)
+ && MODEMATCH(mode, stuff))
+ return Success;
+
+ if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock))
+ return BadValue;
+
+ do {
+ LogMessage(X_INFO, "Checking against clock: %d (%d)\n",
+ VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
+ LogMessage(X_INFO, " hdsp: %d hbeg: %d hend: %d httl: %d\n",
+ VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
+ VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
+ VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
+ VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
+ LogMessage(X_INFO, " vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
+ VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
+ VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
+ VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
+ VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
+ VidModeGetModeValue(mode, VIDMODE_FLAGS));
+
+ if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) &&
+ MODEMATCH(mode, stuff)) {
+
+ if (!pVidMode->SwitchMode(pScreen, mode))
+ return BadValue;
+
+ LogMessage(X_INFO, "SwitchToMode - Succeeded\n");
+ return Success;
+ }
+ } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
+
+ return BadValue;
+}
+
+static int
+ProcVidModeLockModeSwitch(ClientPtr client)
+{
+ REQUEST(xXF86VidModeLockModeSwitchReq);
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+
+ REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
+
+ DEBUG_P("XF86VidModeLockModeSwitch");
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (!pVidMode->LockZoom(pScreen, (short) stuff->lock))
+ return VidModeErrorBase + XF86VidModeZoomLocked;
+
+ return Success;
+}
+
+static int
+ProcVidModeGetMonitor(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetMonitorReq);
+ xXF86VidModeGetMonitorReply rep = {
+ .type = X_Reply,
+ .sequenceNumber = client->sequence
+ };
+ CARD32 *hsyncdata, *vsyncdata;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+ int i, nHsync, nVrefresh;
+
+ DEBUG_P("XF86VidModeGetMonitor");
+
+ REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ nHsync = pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_NHSYNC, 0).i;
+ nVrefresh = pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_NVREFRESH, 0).i;
+
+ if ((char *) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr)
+ rep.vendorLength = strlen((char *) (pVidMode->GetMonitorValue(pScreen,
+ VIDMODE_MON_VENDOR,
+ 0)).ptr);
+ else
+ rep.vendorLength = 0;
+ if ((char *) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr)
+ rep.modelLength = strlen((char *) (pVidMode->GetMonitorValue(pScreen,
+ VIDMODE_MON_MODEL,
+ 0)).ptr);
+ else
+ rep.modelLength = 0;
+ rep.length =
+ bytes_to_int32(SIZEOF(xXF86VidModeGetMonitorReply) -
+ SIZEOF(xGenericReply) + (nHsync +
+ nVrefresh) * sizeof(CARD32) +
+ pad_to_int32(rep.vendorLength) +
+ pad_to_int32(rep.modelLength));
+ rep.nhsync = nHsync;
+ rep.nvsync = nVrefresh;
+ hsyncdata = xallocarray(nHsync, sizeof(CARD32));
+ if (!hsyncdata) {
+ return BadAlloc;
+ }
+ vsyncdata = xallocarray(nVrefresh, sizeof(CARD32));
+
+ if (!vsyncdata) {
+ free(hsyncdata);
+ return BadAlloc;
+ }
+
+ for (i = 0; i < nHsync; i++) {
+ hsyncdata[i] = (unsigned short) (pVidMode->GetMonitorValue(pScreen,
+ VIDMODE_MON_HSYNC_LO,
+ i)).f |
+ (unsigned
+ short) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_HSYNC_HI,
+ i)).f << 16;
+ }
+ for (i = 0; i < nVrefresh; i++) {
+ vsyncdata[i] = (unsigned short) (pVidMode->GetMonitorValue(pScreen,
+ VIDMODE_MON_VREFRESH_LO,
+ i)).f |
+ (unsigned
+ short) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VREFRESH_HI,
+ i)).f << 16;
+ }
+
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ }
+ WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply), &rep);
+ client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
+ WriteSwappedDataToClient(client, nHsync * sizeof(CARD32), hsyncdata);
+ WriteSwappedDataToClient(client, nVrefresh * sizeof(CARD32), vsyncdata);
+ if (rep.vendorLength)
+ WriteToClient(client, rep.vendorLength,
+ (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr);
+ if (rep.modelLength)
+ WriteToClient(client, rep.modelLength,
+ (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr);
+
+ free(hsyncdata);
+ free(vsyncdata);
+
+ return Success;
+}
+
+static int
+ProcVidModeGetViewPort(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetViewPortReq);
+ xXF86VidModeGetViewPortReply rep;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+ int x, y;
+
+ DEBUG_P("XF86VidModeGetViewPort");
+
+ REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ pVidMode->GetViewPort(pScreen, &x, &y);
+
+ rep = (xXF86VidModeGetViewPortReply) {
+ .type = X_Reply,
+ .sequenceNumber = client->sequence,
+ .length = 0,
+ .x = x,
+ .y = y
+ };
+
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swapl(&rep.x);
+ swapl(&rep.y);
+ }
+ WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), &rep);
+ return Success;
+}
+
+static int
+ProcVidModeSetViewPort(ClientPtr client)
+{
+ REQUEST(xXF86VidModeSetViewPortReq);
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+
+ DEBUG_P("XF86VidModeSetViewPort");
+
+ REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (!pVidMode->SetViewPort(pScreen, stuff->x, stuff->y))
+ return BadValue;
+
+ return Success;
+}
+
+static int
+ProcVidModeGetDotClocks(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetDotClocksReq);
+ xXF86VidModeGetDotClocksReply rep;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+ int n;
+ int numClocks;
+ CARD32 dotclock;
+ int *Clocks = NULL;
+ Bool ClockProg;
+
+ DEBUG_P("XF86VidModeGetDotClocks");
+
+ REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ numClocks = pVidMode->GetNumOfClocks(pScreen, &ClockProg);
+
+ rep = (xXF86VidModeGetDotClocksReply) {
+ .type = X_Reply,
+ .sequenceNumber = client->sequence,
+ .length = bytes_to_int32(SIZEOF(xXF86VidModeGetDotClocksReply)
+ - SIZEOF(xGenericReply) + numClocks),
+ .clocks = numClocks,
+ .maxclocks = MAXCLOCKS,
+ .flags = 0
+ };
+
+ if (!ClockProg) {
+ Clocks = calloc(numClocks, sizeof(int));
+ if (!Clocks)
+ return BadValue;
+ if (!pVidMode->GetClocks(pScreen, Clocks)) {
+ free(Clocks);
+ return BadValue;
+ }
+ }
+ if (ClockProg) {
+ rep.flags |= CLKFLAG_PROGRAMABLE;
+ }
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swapl(&rep.clocks);
+ swapl(&rep.maxclocks);
+ swapl(&rep.flags);
+ }
+ WriteToClient(client, sizeof(xXF86VidModeGetDotClocksReply), &rep);
+ if (!ClockProg) {
+ for (n = 0; n < numClocks; n++) {
+ dotclock = *Clocks++;
+ if (client->swapped) {
+ WriteSwappedDataToClient(client, 4, (char *) &dotclock);
+ }
+ else {
+ WriteToClient(client, 4, &dotclock);
+ }
+ }
+ }
+
+ free(Clocks);
+ return Success;
+}
+
+static int
+ProcVidModeSetGamma(ClientPtr client)
+{
+ REQUEST(xXF86VidModeSetGammaReq);
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+
+ DEBUG_P("XF86VidModeSetGamma");
+
+ REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (!pVidMode->SetGamma(pScreen, ((float) stuff->red) / 10000.,
+ ((float) stuff->green) / 10000.,
+ ((float) stuff->blue) / 10000.))
+ return BadValue;
+
+ return Success;
+}
+
+static int
+ProcVidModeGetGamma(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetGammaReq);
+ xXF86VidModeGetGammaReply rep;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+ float red, green, blue;
+
+ DEBUG_P("XF86VidModeGetGamma");
+
+ REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (!pVidMode->GetGamma(pScreen, &red, &green, &blue))
+ return BadValue;
+ rep = (xXF86VidModeGetGammaReply) {
+ .type = X_Reply,
+ .sequenceNumber = client->sequence,
+ .length = 0,
+ .red = (CARD32) (red * 10000.),
+ .green = (CARD32) (green * 10000.),
+ .blue = (CARD32) (blue * 10000.)
+ };
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swapl(&rep.red);
+ swapl(&rep.green);
+ swapl(&rep.blue);
+ }
+ WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), &rep);
+
+ return Success;
+}
+
+static int
+ProcVidModeSetGammaRamp(ClientPtr client)
+{
+ CARD16 *r, *g, *b;
+ int length;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+
+ REQUEST(xXF86VidModeSetGammaRampReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (stuff->size != pVidMode->GetGammaRampSize(pScreen))
+ return BadValue;
+
+ length = (stuff->size + 1) & ~1;
+
+ REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length * 6);
+
+ r = (CARD16 *) &stuff[1];
+ g = r + length;
+ b = g + length;
+
+ if (!pVidMode->SetGammaRamp(pScreen, stuff->size, r, g, b))
+ return BadValue;
+
+ return Success;
+}
+
+static int
+ProcVidModeGetGammaRamp(ClientPtr client)
+{
+ CARD16 *ramp = NULL;
+ int length;
+ size_t ramplen = 0;
+ xXF86VidModeGetGammaRampReply rep;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+
+ REQUEST(xXF86VidModeGetGammaRampReq);
+
+ REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ if (stuff->size != pVidMode->GetGammaRampSize(pScreen))
+ return BadValue;
+
+ length = (stuff->size + 1) & ~1;
+
+ if (stuff->size) {
+ if (!(ramp = xallocarray(length, 3 * sizeof(CARD16))))
+ return BadAlloc;
+ ramplen = length * 3 * sizeof(CARD16);
+
+ if (!pVidMode->GetGammaRamp(pScreen, stuff->size,
+ ramp, ramp + length, ramp + (length * 2))) {
+ free(ramp);
+ return BadValue;
+ }
+ }
+ rep = (xXF86VidModeGetGammaRampReply) {
+ .type = X_Reply,
+ .sequenceNumber = client->sequence,
+ .length = (length >> 1) * 3,
+ .size = stuff->size
+ };
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swaps(&rep.size);
+ SwapShorts((short *) ramp, length * 3);
+ }
+ WriteToClient(client, sizeof(xXF86VidModeGetGammaRampReply), &rep);
+
+ if (stuff->size) {
+ WriteToClient(client, ramplen, ramp);
+ free(ramp);
+ }
+
+ return Success;
+}
+
+
+static int
+ProcVidModeGetGammaRampSize(ClientPtr client)
+{
+ xXF86VidModeGetGammaRampSizeReply rep;
+ ScreenPtr pScreen;
+ VidModePtr pVidMode;
+
+ REQUEST(xXF86VidModeGetGammaRampSizeReq);
+
+ REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
+
+ pVidMode = VidModeGetPtr(pScreen);
+ if (pVidMode == NULL)
+ return BadImplementation;
+
+ rep = (xXF86VidModeGetGammaRampSizeReply) {
+ .type = X_Reply,
+ .sequenceNumber = client->sequence,
+ .length = 0,
+ .size = pVidMode->GetGammaRampSize(pScreen)
+ };
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swaps(&rep.size);
+ }
+ WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply), &rep);
+
+ return Success;
+}
+
+static int
+ProcVidModeGetPermissions(ClientPtr client)
+{
+ xXF86VidModeGetPermissionsReply rep = {
+ .type = X_Reply,
+ .sequenceNumber = client->sequence,
+ .length = 0,
+ .permissions = XF86VM_READ_PERMISSION
+ };
+
+ REQUEST(xXF86VidModeGetPermissionsReq);
+
+ REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq);
+
+ if (stuff->screen >= screenInfo.numScreens)
+ return BadValue;
+
+ if (VidModeAllowNonLocal || client->local) {
+ rep.permissions |= XF86VM_WRITE_PERMISSION;
+ }
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swapl(&rep.permissions);
+ }
+ WriteToClient(client, sizeof(xXF86VidModeGetPermissionsReply), &rep);
+
+ return Success;
+}
+
+static int
+ProcVidModeSetClientVersion(ClientPtr client)
+{
+ REQUEST(xXF86VidModeSetClientVersionReq);
+
+ VidModePrivPtr pPriv;
+
+ DEBUG_P("XF86VidModeSetClientVersion");
+
+ REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq);
+
+ if ((pPriv = VM_GETPRIV(client)) == NULL) {
+ pPriv = malloc(sizeof(VidModePrivRec));
+ if (!pPriv)
+ return BadAlloc;
+ VM_SETPRIV(client, pPriv);
+ }
+ pPriv->major = stuff->major;
+
+ pPriv->minor = stuff->minor;
+
+ return Success;
+}
+
+static int
+ProcVidModeDispatch(ClientPtr client)
+{
+ REQUEST(xReq);
+ switch (stuff->data) {
+ case X_XF86VidModeQueryVersion:
+ return ProcVidModeQueryVersion(client);
+ case X_XF86VidModeGetModeLine:
+ return ProcVidModeGetModeLine(client);
+ case X_XF86VidModeGetMonitor:
+ return ProcVidModeGetMonitor(client);
+ case X_XF86VidModeGetAllModeLines:
+ return ProcVidModeGetAllModeLines(client);
+ case X_XF86VidModeValidateModeLine:
+ return ProcVidModeValidateModeLine(client);
+ case X_XF86VidModeGetViewPort:
+ return ProcVidModeGetViewPort(client);
+ case X_XF86VidModeGetDotClocks:
+ return ProcVidModeGetDotClocks(client);
+ case X_XF86VidModeSetClientVersion:
+ return ProcVidModeSetClientVersion(client);
+ case X_XF86VidModeGetGamma:
+ return ProcVidModeGetGamma(client);
+ case X_XF86VidModeGetGammaRamp:
+ return ProcVidModeGetGammaRamp(client);
+ case X_XF86VidModeGetGammaRampSize:
+ return ProcVidModeGetGammaRampSize(client);
+ case X_XF86VidModeGetPermissions:
+ return ProcVidModeGetPermissions(client);
+ default:
+ if (VidModeAllowNonLocal || client->local) {
+ switch (stuff->data) {
+ case X_XF86VidModeAddModeLine:
+ return ProcVidModeAddModeLine(client);
+ case X_XF86VidModeDeleteModeLine:
+ return ProcVidModeDeleteModeLine(client);
+ case X_XF86VidModeModModeLine:
+ return ProcVidModeModModeLine(client);
+ case X_XF86VidModeSwitchMode:
+ return ProcVidModeSwitchMode(client);
+ case X_XF86VidModeSwitchToMode:
+ return ProcVidModeSwitchToMode(client);
+ case X_XF86VidModeLockModeSwitch:
+ return ProcVidModeLockModeSwitch(client);
+ case X_XF86VidModeSetViewPort:
+ return ProcVidModeSetViewPort(client);
+ case X_XF86VidModeSetGamma:
+ return ProcVidModeSetGamma(client);
+ case X_XF86VidModeSetGammaRamp:
+ return ProcVidModeSetGammaRamp(client);
+ default:
+ return BadRequest;
+ }
+ }
+ else
+ return VidModeErrorBase + XF86VidModeClientNotLocal;
+ }
+}
+
+static int
+SProcVidModeQueryVersion(ClientPtr client)
+{
+ REQUEST(xXF86VidModeQueryVersionReq);
+ swaps(&stuff->length);
+ return ProcVidModeQueryVersion(client);
+}
+
+static int
+SProcVidModeGetModeLine(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetModeLineReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
+ swaps(&stuff->screen);
+ return ProcVidModeGetModeLine(client);
+}
+
+static int
+SProcVidModeGetAllModeLines(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetAllModeLinesReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
+ swaps(&stuff->screen);
+ return ProcVidModeGetAllModeLines(client);
+}
+
+static int
+SProcVidModeAddModeLine(ClientPtr client)
+{
+ xXF86OldVidModeAddModeLineReq *oldstuff =
+ (xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
+ int ver;
+
+ REQUEST(xXF86VidModeAddModeLineReq);
+ ver = ClientMajorVersion(client);
+ if (ver < 2) {
+ swaps(&oldstuff->length);
+ REQUEST_AT_LEAST_SIZE(xXF86OldVidModeAddModeLineReq);
+ swapl(&oldstuff->screen);
+ swaps(&oldstuff->hdisplay);
+ swaps(&oldstuff->hsyncstart);
+ swaps(&oldstuff->hsyncend);
+ swaps(&oldstuff->htotal);
+ swaps(&oldstuff->vdisplay);
+ swaps(&oldstuff->vsyncstart);
+ swaps(&oldstuff->vsyncend);
+ swaps(&oldstuff->vtotal);
+ swapl(&oldstuff->flags);
+ swapl(&oldstuff->privsize);
+ SwapRestL(oldstuff);
+ }
+ else {
+ swaps(&stuff->length);
+ REQUEST_AT_LEAST_SIZE(xXF86VidModeAddModeLineReq);
+ swapl(&stuff->screen);
+ swaps(&stuff->hdisplay);
+ swaps(&stuff->hsyncstart);
+ swaps(&stuff->hsyncend);
+ swaps(&stuff->htotal);
+ swaps(&stuff->hskew);
+ swaps(&stuff->vdisplay);
+ swaps(&stuff->vsyncstart);
+ swaps(&stuff->vsyncend);
+ swaps(&stuff->vtotal);
+ swapl(&stuff->flags);
+ swapl(&stuff->privsize);
+ SwapRestL(stuff);
+ }
+ return ProcVidModeAddModeLine(client);
+}
+
+static int
+SProcVidModeDeleteModeLine(ClientPtr client)
+{
+ xXF86OldVidModeDeleteModeLineReq *oldstuff =
+ (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
+ int ver;
+
+ REQUEST(xXF86VidModeDeleteModeLineReq);
+ ver = ClientMajorVersion(client);
+ if (ver < 2) {
+ swaps(&oldstuff->length);
+ REQUEST_AT_LEAST_SIZE(xXF86OldVidModeDeleteModeLineReq);
+ swapl(&oldstuff->screen);
+ swaps(&oldstuff->hdisplay);
+ swaps(&oldstuff->hsyncstart);
+ swaps(&oldstuff->hsyncend);
+ swaps(&oldstuff->htotal);
+ swaps(&oldstuff->vdisplay);
+ swaps(&oldstuff->vsyncstart);
+ swaps(&oldstuff->vsyncend);
+ swaps(&oldstuff->vtotal);
+ swapl(&oldstuff->flags);
+ swapl(&oldstuff->privsize);
+ SwapRestL(oldstuff);
+ }
+ else {
+ swaps(&stuff->length);
+ REQUEST_AT_LEAST_SIZE(xXF86VidModeDeleteModeLineReq);
+ swapl(&stuff->screen);
+ swaps(&stuff->hdisplay);
+ swaps(&stuff->hsyncstart);
+ swaps(&stuff->hsyncend);
+ swaps(&stuff->htotal);
+ swaps(&stuff->hskew);
+ swaps(&stuff->vdisplay);
+ swaps(&stuff->vsyncstart);
+ swaps(&stuff->vsyncend);
+ swaps(&stuff->vtotal);
+ swapl(&stuff->flags);
+ swapl(&stuff->privsize);
+ SwapRestL(stuff);
+ }
+ return ProcVidModeDeleteModeLine(client);
+}
+
+static int
+SProcVidModeModModeLine(ClientPtr client)
+{
+ xXF86OldVidModeModModeLineReq *oldstuff =
+ (xXF86OldVidModeModModeLineReq *) client->requestBuffer;
+ int ver;
+
+ REQUEST(xXF86VidModeModModeLineReq);
+ ver = ClientMajorVersion(client);
+ if (ver < 2) {
+ swaps(&oldstuff->length);
+ REQUEST_AT_LEAST_SIZE(xXF86OldVidModeModModeLineReq);
+ swapl(&oldstuff->screen);
+ swaps(&oldstuff->hdisplay);
+ swaps(&oldstuff->hsyncstart);
+ swaps(&oldstuff->hsyncend);
+ swaps(&oldstuff->htotal);
+ swaps(&oldstuff->vdisplay);
+ swaps(&oldstuff->vsyncstart);
+ swaps(&oldstuff->vsyncend);
+ swaps(&oldstuff->vtotal);
+ swapl(&oldstuff->flags);
+ swapl(&oldstuff->privsize);
+ SwapRestL(oldstuff);
+ }
+ else {
+ swaps(&stuff->length);
+ REQUEST_AT_LEAST_SIZE(xXF86VidModeModModeLineReq);
+ swapl(&stuff->screen);
+ swaps(&stuff->hdisplay);
+ swaps(&stuff->hsyncstart);
+ swaps(&stuff->hsyncend);
+ swaps(&stuff->htotal);
+ swaps(&stuff->hskew);
+ swaps(&stuff->vdisplay);
+ swaps(&stuff->vsyncstart);
+ swaps(&stuff->vsyncend);
+ swaps(&stuff->vtotal);
+ swapl(&stuff->flags);
+ swapl(&stuff->privsize);
+ SwapRestL(stuff);
+ }
+ return ProcVidModeModModeLine(client);
+}
+
+static int
+SProcVidModeValidateModeLine(ClientPtr client)
+{
+ xXF86OldVidModeValidateModeLineReq *oldstuff =
+ (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer;
+ int ver;
+
+ REQUEST(xXF86VidModeValidateModeLineReq);
+ ver = ClientMajorVersion(client);
+ if (ver < 2) {
+ swaps(&oldstuff->length);
+ REQUEST_AT_LEAST_SIZE(xXF86OldVidModeValidateModeLineReq);
+ swapl(&oldstuff->screen);
+ swaps(&oldstuff->hdisplay);
+ swaps(&oldstuff->hsyncstart);
+ swaps(&oldstuff->hsyncend);
+ swaps(&oldstuff->htotal);
+ swaps(&oldstuff->vdisplay);
+ swaps(&oldstuff->vsyncstart);
+ swaps(&oldstuff->vsyncend);
+ swaps(&oldstuff->vtotal);
+ swapl(&oldstuff->flags);
+ swapl(&oldstuff->privsize);
+ SwapRestL(oldstuff);
+ }
+ else {
+ swaps(&stuff->length);
+ REQUEST_AT_LEAST_SIZE(xXF86VidModeValidateModeLineReq);
+ swapl(&stuff->screen);
+ swaps(&stuff->hdisplay);
+ swaps(&stuff->hsyncstart);
+ swaps(&stuff->hsyncend);
+ swaps(&stuff->htotal);
+ swaps(&stuff->hskew);
+ swaps(&stuff->vdisplay);
+ swaps(&stuff->vsyncstart);
+ swaps(&stuff->vsyncend);
+ swaps(&stuff->vtotal);
+ swapl(&stuff->flags);
+ swapl(&stuff->privsize);
+ SwapRestL(stuff);
+ }
+ return ProcVidModeValidateModeLine(client);
+}
+
+static int
+SProcVidModeSwitchMode(ClientPtr client)
+{
+ REQUEST(xXF86VidModeSwitchModeReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq);
+ swaps(&stuff->screen);
+ swaps(&stuff->zoom);
+ return ProcVidModeSwitchMode(client);
+}
+
+static int
+SProcVidModeSwitchToMode(ClientPtr client)
+{
+ REQUEST(xXF86VidModeSwitchToModeReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeSwitchToModeReq);
+ swapl(&stuff->screen);
+ return ProcVidModeSwitchToMode(client);
+}
+
+static int
+SProcVidModeLockModeSwitch(ClientPtr client)
+{
+ REQUEST(xXF86VidModeLockModeSwitchReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
+ swaps(&stuff->screen);
+ swaps(&stuff->lock);
+ return ProcVidModeLockModeSwitch(client);
+}
+
+static int
+SProcVidModeGetMonitor(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetMonitorReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq);
+ swaps(&stuff->screen);
+ return ProcVidModeGetMonitor(client);
+}
+
+static int
+SProcVidModeGetViewPort(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetViewPortReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq);
+ swaps(&stuff->screen);
+ return ProcVidModeGetViewPort(client);
+}
+
+static int
+SProcVidModeSetViewPort(ClientPtr client)
+{
+ REQUEST(xXF86VidModeSetViewPortReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq);
+ swaps(&stuff->screen);
+ swapl(&stuff->x);
+ swapl(&stuff->y);
+ return ProcVidModeSetViewPort(client);
+}
+
+static int
+SProcVidModeGetDotClocks(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetDotClocksReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq);
+ swaps(&stuff->screen);
+ return ProcVidModeGetDotClocks(client);
+}
+
+static int
+SProcVidModeSetClientVersion(ClientPtr client)
+{
+ REQUEST(xXF86VidModeSetClientVersionReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq);
+ swaps(&stuff->major);
+ swaps(&stuff->minor);
+ return ProcVidModeSetClientVersion(client);
+}
+
+static int
+SProcVidModeSetGamma(ClientPtr client)
+{
+ REQUEST(xXF86VidModeSetGammaReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq);
+ swaps(&stuff->screen);
+ swapl(&stuff->red);
+ swapl(&stuff->green);
+ swapl(&stuff->blue);
+ return ProcVidModeSetGamma(client);
+}
+
+static int
+SProcVidModeGetGamma(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetGammaReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq);
+ swaps(&stuff->screen);
+ return ProcVidModeGetGamma(client);
+}
+
+static int
+SProcVidModeSetGammaRamp(ClientPtr client)
+{
+ int length;
+
+ REQUEST(xXF86VidModeSetGammaRampReq);
+ swaps(&stuff->length);
+ REQUEST_AT_LEAST_SIZE(xXF86VidModeSetGammaRampReq);
+ swaps(&stuff->size);
+ swaps(&stuff->screen);
+ length = ((stuff->size + 1) & ~1) * 6;
+ REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length);
+ SwapRestS(stuff);
+ return ProcVidModeSetGammaRamp(client);
+}
+
+static int
+SProcVidModeGetGammaRamp(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetGammaRampReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq);
+ swaps(&stuff->size);
+ swaps(&stuff->screen);
+ return ProcVidModeGetGammaRamp(client);
+}
+
+static int
+SProcVidModeGetGammaRampSize(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetGammaRampSizeReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq);
+ swaps(&stuff->screen);
+ return ProcVidModeGetGammaRampSize(client);
+}
+
+static int
+SProcVidModeGetPermissions(ClientPtr client)
+{
+ REQUEST(xXF86VidModeGetPermissionsReq);
+ swaps(&stuff->length);
+ REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq);
+ swaps(&stuff->screen);
+ return ProcVidModeGetPermissions(client);
+}
+
+static int
+SProcVidModeDispatch(ClientPtr client)
+{
+ REQUEST(xReq);
+ switch (stuff->data) {
+ case X_XF86VidModeQueryVersion:
+ return SProcVidModeQueryVersion(client);
+ case X_XF86VidModeGetModeLine:
+ return SProcVidModeGetModeLine(client);
+ case X_XF86VidModeGetMonitor:
+ return SProcVidModeGetMonitor(client);
+ case X_XF86VidModeGetAllModeLines:
+ return SProcVidModeGetAllModeLines(client);
+ case X_XF86VidModeGetViewPort:
+ return SProcVidModeGetViewPort(client);
+ case X_XF86VidModeValidateModeLine:
+ return SProcVidModeValidateModeLine(client);
+ case X_XF86VidModeGetDotClocks:
+ return SProcVidModeGetDotClocks(client);
+ case X_XF86VidModeSetClientVersion:
+ return SProcVidModeSetClientVersion(client);
+ case X_XF86VidModeGetGamma:
+ return SProcVidModeGetGamma(client);
+ case X_XF86VidModeGetGammaRamp:
+ return SProcVidModeGetGammaRamp(client);
+ case X_XF86VidModeGetGammaRampSize:
+ return SProcVidModeGetGammaRampSize(client);
+ case X_XF86VidModeGetPermissions:
+ return SProcVidModeGetPermissions(client);
+ default:
+ if (VidModeAllowNonLocal || client->local) {
+ switch (stuff->data) {
+ case X_XF86VidModeAddModeLine:
+ return SProcVidModeAddModeLine(client);
+ case X_XF86VidModeDeleteModeLine:
+ return SProcVidModeDeleteModeLine(client);
+ case X_XF86VidModeModModeLine:
+ return SProcVidModeModModeLine(client);
+ case X_XF86VidModeSwitchMode:
+ return SProcVidModeSwitchMode(client);
+ case X_XF86VidModeSwitchToMode:
+ return SProcVidModeSwitchToMode(client);
+ case X_XF86VidModeLockModeSwitch:
+ return SProcVidModeLockModeSwitch(client);
+ case X_XF86VidModeSetViewPort:
+ return SProcVidModeSetViewPort(client);
+ case X_XF86VidModeSetGamma:
+ return SProcVidModeSetGamma(client);
+ case X_XF86VidModeSetGammaRamp:
+ return SProcVidModeSetGammaRamp(client);
+ default:
+ return BadRequest;
+ }
+ }
+ else
+ return VidModeErrorBase + XF86VidModeClientNotLocal;
+ }
+}
+
+void
+VidModeAddExtension(Bool allow_non_local)
+{
+ ExtensionEntry *extEntry;
+
+ DEBUG_P("VidModeAddExtension");
+
+ if (!dixRegisterPrivateKey(VidModeClientPrivateKey, PRIVATE_CLIENT, 0))
+ return;
+
+ if ((extEntry = AddExtension(XF86VIDMODENAME,
+ XF86VidModeNumberEvents,
+ XF86VidModeNumberErrors,
+ ProcVidModeDispatch,
+ SProcVidModeDispatch,
+ NULL, StandardMinorOpcode))) {
+ VidModeErrorBase = extEntry->errorBase;
+ VidModeAllowNonLocal = allow_non_local;
+ }
+}
+
+VidModePtr VidModeGetPtr(ScreenPtr pScreen)
+{
+ return (VidModePtr) (dixLookupPrivate(&pScreen->devPrivates, VidModePrivateKey));
+}
+
+VidModePtr VidModeInit(ScreenPtr pScreen)
+{
+ if (!dixRegisterPrivateKey(VidModePrivateKey, PRIVATE_SCREEN, sizeof(VidModeRec)))
+ return NULL;
+
+ return VidModeGetPtr(pScreen);
+}
diff --git a/hw/xfree86/Makefile.am b/hw/xfree86/Makefile.am
index 64c4f74..85bd0be 100644
--- a/hw/xfree86/Makefile.am
+++ b/hw/xfree86/Makefile.am
@@ -72,7 +72,9 @@ LOCAL_LIBS = \
$(DRI3_LIB) \
$(top_builddir)/miext/sync/libsync.la \
$(top_builddir)/mi/libmi.la \
- $(top_builddir)/os/libos.la
+ $(top_builddir)/os/libos.la \
+ $(top_builddir)/Xext/libXvidmode.la
+
Xorg_LDADD = \
$(LOCAL_LIBS) \
$(XORG_SYS_LIBS) \
diff --git a/hw/xfree86/common/Makefile.am b/hw/xfree86/common/Makefile.am
index 3bc0046..2eed5de 100644
--- a/hw/xfree86/common/Makefile.am
+++ b/hw/xfree86/common/Makefile.am
@@ -14,10 +14,6 @@ XVSOURCES = xf86xv.c xf86xvmc.c
XVSDKINCS = xf86xv.h xf86xvmc.h xf86xvpriv.h
endif
-if XF86VIDMODE
-XF86VMODESOURCES = xf86vmode.c
-endif
-
if DGA
DGASOURCES = xf86DGA.c
DGA_SDK = dgaproc.h
diff --git a/hw/xfree86/common/vidmodeproc.h b/hw/xfree86/common/vidmodeproc.h
deleted file mode 100644
index 4410253..0000000
--- a/hw/xfree86/common/vidmodeproc.h
+++ /dev/null
@@ -1,78 +0,0 @@
-
-/* Prototypes for DGA functions that the DDX must provide */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#ifndef _VIDMODEPROC_H_
-#define _VIDMODEPROC_H_
-
-typedef enum {
- VIDMODE_H_DISPLAY,
- VIDMODE_H_SYNCSTART,
- VIDMODE_H_SYNCEND,
- VIDMODE_H_TOTAL,
- VIDMODE_H_SKEW,
- VIDMODE_V_DISPLAY,
- VIDMODE_V_SYNCSTART,
- VIDMODE_V_SYNCEND,
- VIDMODE_V_TOTAL,
- VIDMODE_FLAGS,
- VIDMODE_CLOCK
-} VidModeSelectMode;
-
-typedef enum {
- VIDMODE_MON_VENDOR,
- VIDMODE_MON_MODEL,
- VIDMODE_MON_NHSYNC,
- VIDMODE_MON_NVREFRESH,
- VIDMODE_MON_HSYNC_LO,
- VIDMODE_MON_HSYNC_HI,
- VIDMODE_MON_VREFRESH_LO,
- VIDMODE_MON_VREFRESH_HI
-} VidModeSelectMonitor;
-
-typedef union {
- const void *ptr;
- int i;
- float f;
-} vidMonitorValue;
-
-extern Bool xf86VidModeExtensionInit(ScreenPtr pScreen);
-
-extern Bool xf86VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode,
- int *dotClock);
-extern Bool xf86VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode,
- int *dotClock);
-extern Bool xf86VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode,
- int *dotClock);
-extern Bool xf86VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode);
-extern Bool xf86VidModeZoomViewport(ScreenPtr pScreen, int zoom);
-extern Bool xf86VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y);
-extern Bool xf86VidModeSetViewPort(ScreenPtr pScreen, int x, int y);
-extern Bool xf86VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode);
-extern Bool xf86VidModeLockZoom(ScreenPtr pScreen, Bool lock);
-extern int xf86VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock);
-extern Bool xf86VidModeGetClocks(ScreenPtr pScreen, int *Clocks);
-extern ModeStatus xf86VidModeCheckModeForMonitor(ScreenPtr pScreen,
- DisplayModePtr mode);
-extern ModeStatus xf86VidModeCheckModeForDriver(ScreenPtr pScreen,
- DisplayModePtr mode);
-extern void xf86VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode);
-extern Bool xf86VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode);
-extern int xf86VidModeGetDotClock(ScreenPtr pScreen, int Clock);
-extern int xf86VidModeGetNumOfModes(ScreenPtr pScreen);
-extern Bool xf86VidModeSetGamma(ScreenPtr pScreen, float red, float green,
- float blue);
-extern Bool xf86VidModeGetGamma(ScreenPtr pScreen, float *red, float *green,
- float *blue);
-extern vidMonitorValue xf86VidModeGetMonitorValue(ScreenPtr pScreen,
- int valtyp, int indx);
-extern Bool xf86VidModeSetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
- CARD16 *);
-extern Bool xf86VidModeGetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
- CARD16 *);
-extern int xf86VidModeGetGammaRampSize(ScreenPtr pScreen);
-
-#endif
diff --git a/hw/xfree86/common/xf86Extensions.c b/hw/xfree86/common/xf86Extensions.c
index 25b2bc3..1b8b785 100644
--- a/hw/xfree86/common/xf86Extensions.c
+++ b/hw/xfree86/common/xf86Extensions.c
@@ -28,6 +28,7 @@
#endif
#include "extension.h"
+#include "extinit.h"
#include "globals.h"
#include "xf86.h"
@@ -47,7 +48,7 @@
#ifdef XF86VIDMODE
#include <X11/extensions/xf86vmproto.h>
-#include "vidmodeproc.h"
+#include "vidmodestr.h"
#endif
/*
diff --git a/hw/xfree86/common/xf86Init.c b/hw/xfree86/common/xf86Init.c
index 017dcb6..de51497 100644
--- a/hw/xfree86/common/xf86Init.c
+++ b/hw/xfree86/common/xf86Init.c
@@ -72,6 +72,7 @@
#include "mipointer.h"
#include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h>
+#include "xf86Extensions.h"
#include "xf86DDC.h"
#include "xf86Xinput.h"
#include "xf86InPriv.h"
diff --git a/hw/xfree86/common/xf86Privstr.h b/hw/xfree86/common/xf86Privstr.h
index f2b8e8a..4830fb3 100644
--- a/hw/xfree86/common/xf86Privstr.h
+++ b/hw/xfree86/common/xf86Privstr.h
@@ -115,15 +115,6 @@ typedef struct {
} DPMSRec, *DPMSPtr;
#endif
-#ifdef XF86VIDMODE
-/* Private info for Video Mode Extentsion */
-typedef struct {
- DisplayModePtr First;
- DisplayModePtr Next;
- int Flags;
-} VidModeRec, *VidModePtr;
-#endif
-
/* Information for root window properties. */
typedef struct _RootWinProp {
struct _RootWinProp *next;
diff --git a/hw/xfree86/common/xf86VidMode.c b/hw/xfree86/common/xf86VidMode.c
index 5d04738..d2bdf6b 100644
--- a/hw/xfree86/common/xf86VidMode.c
+++ b/hw/xfree86/common/xf86VidMode.c
@@ -42,29 +42,18 @@
#include "os.h"
#include "xf86.h"
#include "xf86Priv.h"
+#include "extinit.h"
#ifdef XF86VIDMODE
-#include "vidmodeproc.h"
+#include "vidmodestr.h"
+#include "xf86Privstr.h"
+#include "xf86Extensions.h"
#include "xf86cmap.h"
-static DevPrivateKeyRec VidModeKeyRec;
-#define VidModeKey (&VidModeKeyRec)
-
-#define VMPTR(p) ((VidModePtr)dixLookupPrivate(&(p)->devPrivates, VidModeKey))
-
-#endif
-
-#ifdef XF86VIDMODE
-
static Bool
xf86VidModeAvailable(ScreenPtr pScreen)
{
- if (pScreen == NULL) {
- DebugF("pScreen == NULL\n");
- return FALSE;
- }
-
- if (VMPTR(pScreen))
+ if (VidModeGetPtr(pScreen))
return TRUE;
else {
DebugF("pVidMode == NULL\n");
@@ -72,7 +61,7 @@ xf86VidModeAvailable(ScreenPtr pScreen)
}
}
-vidMonitorValue
+static vidMonitorValue
xf86VidModeGetMonitorValue(ScreenPtr pScreen, int valtyp, int indx)
{
vidMonitorValue ret = { NULL, };
@@ -114,7 +103,7 @@ xf86VidModeGetMonitorValue(ScreenPtr pScreen, int valtyp, int indx)
return ret;
}
-Bool
+static Bool
xf86VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
{
ScrnInfoPtr pScrn;
@@ -133,7 +122,7 @@ xf86VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotC
return FALSE;
}
-int
+static int
xf86VidModeGetDotClock(ScreenPtr pScreen, int Clock)
{
ScrnInfoPtr pScrn;
@@ -148,7 +137,7 @@ xf86VidModeGetDotClock(ScreenPtr pScreen, int Clock)
return pScrn->clock[Clock];
}
-int
+static int
xf86VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock)
{
ScrnInfoPtr pScrn;
@@ -167,7 +156,7 @@ xf86VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock)
}
}
-Bool
+static Bool
xf86VidModeGetClocks(ScreenPtr pScreen, int *Clocks)
{
ScrnInfoPtr pScrn;
@@ -187,7 +176,7 @@ xf86VidModeGetClocks(ScreenPtr pScreen, int *Clocks)
return TRUE;
}
-Bool
+static Bool
xf86VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
{
VidModePtr pVidMode;
@@ -196,7 +185,7 @@ xf86VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotCloc
if (!xf86VidModeAvailable(pScreen))
return FALSE;
- pVidMode = VMPTR(pScreen);
+ pVidMode = VidModeGetPtr(pScreen);
for (p = pVidMode->Next; p != NULL && p != pVidMode->First; p = p->next) {
if (p->status == MODE_OK) {
@@ -210,7 +199,7 @@ xf86VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotCloc
return FALSE;
}
-Bool
+static Bool
xf86VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
{
ScrnInfoPtr pScrn;
@@ -223,7 +212,7 @@ xf86VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClo
if (pScrn->modes == NULL)
return FALSE;
- pVidMode = VMPTR(pScreen);
+ pVidMode = VidModeGetPtr(pScreen);
pVidMode->First = pScrn->modes;
pVidMode->Next = pVidMode->First->next;
@@ -236,7 +225,7 @@ xf86VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClo
return xf86VidModeGetNextModeline(pScreen, mode, dotClock);
}
-Bool
+static Bool
xf86VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
@@ -249,7 +238,7 @@ xf86VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode)
return TRUE;
}
-Bool
+static Bool
xf86VidModeZoomViewport(ScreenPtr pScreen, int zoom)
{
if (!xf86VidModeAvailable(pScreen))
@@ -259,7 +248,7 @@ xf86VidModeZoomViewport(ScreenPtr pScreen, int zoom)
return TRUE;
}
-Bool
+static Bool
xf86VidModeSetViewPort(ScreenPtr pScreen, int x, int y)
{
ScrnInfoPtr pScrn;
@@ -280,7 +269,7 @@ xf86VidModeSetViewPort(ScreenPtr pScreen, int x, int y)
return TRUE;
}
-Bool
+static Bool
xf86VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y)
{
ScrnInfoPtr pScrn;
@@ -294,7 +283,7 @@ xf86VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y)
return TRUE;
}
-Bool
+static Bool
xf86VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
@@ -316,7 +305,7 @@ xf86VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
return retval;
}
-Bool
+static Bool
xf86VidModeLockZoom(ScreenPtr pScreen, Bool lock)
{
if (!xf86VidModeAvailable(pScreen))
@@ -329,7 +318,7 @@ xf86VidModeLockZoom(ScreenPtr pScreen, Bool lock)
return TRUE;
}
-ModeStatus
+static ModeStatus
xf86VidModeCheckModeForMonitor(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
@@ -342,7 +331,7 @@ xf86VidModeCheckModeForMonitor(ScreenPtr pScreen, DisplayModePtr mode)
return xf86CheckModeForMonitor(mode, pScrn->monitor);
}
-ModeStatus
+static ModeStatus
xf86VidModeCheckModeForDriver(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
@@ -355,7 +344,7 @@ xf86VidModeCheckModeForDriver(ScreenPtr pScreen, DisplayModePtr mode)
return xf86CheckModeForDriver(pScrn, mode, 0);
}
-void
+static void
xf86VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
@@ -374,7 +363,7 @@ xf86VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode)
return;
}
-Bool
+static Bool
xf86VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
@@ -395,7 +384,7 @@ xf86VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode)
return TRUE;
}
-int
+static int
xf86VidModeGetNumOfModes(ScreenPtr pScreen)
{
DisplayModePtr mode = NULL;
@@ -411,7 +400,7 @@ xf86VidModeGetNumOfModes(ScreenPtr pScreen)
} while (TRUE);
}
-Bool
+static Bool
xf86VidModeSetGamma(ScreenPtr pScreen, float red, float green, float blue)
{
Gamma gamma;
@@ -428,7 +417,7 @@ xf86VidModeSetGamma(ScreenPtr pScreen, float red, float green, float blue)
return TRUE;
}
-Bool
+static Bool
xf86VidModeGetGamma(ScreenPtr pScreen, float *red, float *green, float *blue)
{
ScrnInfoPtr pScrn;
@@ -443,7 +432,7 @@ xf86VidModeGetGamma(ScreenPtr pScreen, float *red, float *green, float *blue)
return TRUE;
}
-Bool
+static Bool
xf86VidModeSetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
{
if (!xf86VidModeAvailable(pScreen))
@@ -453,7 +442,7 @@ xf86VidModeSetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD1
return TRUE;
}
-Bool
+static Bool
xf86VidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
{
if (!xf86VidModeAvailable(pScreen))
@@ -463,7 +452,7 @@ xf86VidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD1
return TRUE;
}
-int
+static int
xf86VidModeGetGammaRampSize(ScreenPtr pScreen)
{
if (!xf86VidModeAvailable(pScreen))
@@ -472,12 +461,9 @@ xf86VidModeGetGammaRampSize(ScreenPtr pScreen)
return xf86GetGammaRampSize(pScreen);
}
-#endif /* XF86VIDMODE */
-
-Bool
-xf86VidModeExtensionInit(ScreenPtr pScreen)
+static Bool
+xf86VidModeInit(ScreenPtr pScreen)
{
-#ifdef XF86VIDMODE
VidModePtr pVidMode;
if (!xf86GetVidModeEnabled()) {
@@ -485,18 +471,61 @@ xf86VidModeExtensionInit(ScreenPtr pScreen)
return FALSE;
}
- if (!dixRegisterPrivateKey(&VidModeKeyRec, PRIVATE_SCREEN, sizeof(VidModeRec)))
+ pVidMode = VidModeInit(pScreen);
+ if (!pVidMode)
return FALSE;
- pVidMode = VMPTR(pScreen);
-
pVidMode->Flags = 0;
pVidMode->Next = NULL;
+ pVidMode->GetMonitorValue = xf86VidModeGetMonitorValue;
+ pVidMode->GetCurrentModeline = xf86VidModeGetCurrentModeline;
+ pVidMode->GetFirstModeline = xf86VidModeGetFirstModeline;
+ pVidMode->GetNextModeline = xf86VidModeGetNextModeline;
+ pVidMode->DeleteModeline = xf86VidModeDeleteModeline;
+ pVidMode->ZoomViewport = xf86VidModeZoomViewport;
+ pVidMode->GetViewPort = xf86VidModeGetViewPort;
+ pVidMode->SetViewPort = xf86VidModeSetViewPort;
+ pVidMode->SwitchMode = xf86VidModeSwitchMode;
+ pVidMode->LockZoom = xf86VidModeLockZoom;
+ pVidMode->GetNumOfClocks = xf86VidModeGetNumOfClocks;
+ pVidMode->GetClocks = xf86VidModeGetClocks;
+ pVidMode->CheckModeForMonitor = xf86VidModeCheckModeForMonitor;
+ pVidMode->CheckModeForDriver = xf86VidModeCheckModeForDriver;
+ pVidMode->SetCrtcForMode = xf86VidModeSetCrtcForMode;
+ pVidMode->AddModeline = xf86VidModeAddModeline;
+ pVidMode->GetDotClock = xf86VidModeGetDotClock;
+ pVidMode->GetNumOfModes = xf86VidModeGetNumOfModes;
+ pVidMode->SetGamma = xf86VidModeSetGamma;
+ pVidMode->GetGamma = xf86VidModeGetGamma;
+ pVidMode->SetGammaRamp = xf86VidModeSetGammaRamp;
+ pVidMode->GetGammaRamp = xf86VidModeGetGammaRamp;
+ pVidMode->GetGammaRampSize = xf86VidModeGetGammaRampSize;
+
return TRUE;
-#else
- DebugF("no vidmode extension\n");
- return FALSE;
-#endif
}
+void
+XFree86VidModeExtensionInit(void)
+{
+ int i;
+ Bool enabled = FALSE;
+
+ DebugF("XFree86VidModeExtensionInit");
+
+ /* This means that the DDX doesn't want the vidmode extension enabled */
+ if (!xf86GetVidModeEnabled())
+ return;
+
+ for (i = 0; i < screenInfo.numScreens; i++) {
+ if (xf86VidModeInit (screenInfo.screens[i]))
+ enabled = TRUE;
+ }
+ /* This means that the DDX doesn't want the vidmode extension enabled */
+ if (!enabled)
+ return;
+
+ VidModeAddExtension(xf86GetVidModeAllowNonLocal());
+}
+
+#endif /* XF86VIDMODE */
diff --git a/hw/xfree86/common/xf86vmode.c b/hw/xfree86/common/xf86vmode.c
deleted file mode 100644
index 0ad1b8d..0000000
--- a/hw/xfree86/common/xf86vmode.c
+++ /dev/null
@@ -1,2093 +0,0 @@
-
-/*
-
-Copyright 1995 Kaleb S. KEITHLEY
-
-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 Kaleb S. KEITHLEY 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.
-
-Except as contained in this notice, the name of Kaleb S. KEITHLEY
-shall not be used in advertising or otherwise to promote the sale, use
-or other dealings in this Software without prior written authorization
-from Kaleb S. KEITHLEY
-
-*/
-/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include "misc.h"
-#include "dixstruct.h"
-#include "extnsionst.h"
-#include "xf86Extensions.h"
-#include "scrnintstr.h"
-#include "servermd.h"
-#include <X11/extensions/xf86vmproto.h>
-#include "swaprep.h"
-#include "xf86.h"
-#include "vidmodeproc.h"
-#include "globals.h"
-#include "protocol-versions.h"
-
-#define DEFAULT_XF86VIDMODE_VERBOSITY 3
-
-static int VidModeErrorBase;
-static DevPrivateKeyRec VidModeClientPrivateKeyRec;
-
-#define VidModeClientPrivateKey (&VidModeClientPrivateKeyRec)
-
-/* This holds the client's version information */
-typedef struct {
- int major;
- int minor;
-} VidModePrivRec, *VidModePrivPtr;
-
-#define VM_GETPRIV(c) ((VidModePrivPtr) \
- dixLookupPrivate(&(c)->devPrivates, VidModeClientPrivateKey))
-#define VM_SETPRIV(c,p) \
- dixSetPrivate(&(c)->devPrivates, VidModeClientPrivateKey, p)
-
-#if 0
-static unsigned char XF86VidModeReqCode = 0;
-#endif
-
-#ifdef DEBUG
-#define DEBUG_P(x) ErrorF(x"\n");
-#else
-#define DEBUG_P(x) /**/
-#endif
-
-static DisplayModePtr
-VidModeCreateMode(void)
-{
- DisplayModePtr mode;
-
- mode = malloc(sizeof(DisplayModeRec));
- if (mode != NULL) {
- mode->name = "";
- mode->VScan = 1; /* divides refresh rate. default = 1 */
- mode->Private = NULL;
- mode->next = mode;
- mode->prev = mode;
- }
- return mode;
-}
-
-static void
-VidModeCopyMode(DisplayModePtr modefrom, DisplayModePtr modeto)
-{
- memcpy(modeto, modefrom, sizeof(DisplayModeRec));
-}
-
-static int
-VidModeGetModeValue(DisplayModePtr mode, int valtyp)
-{
- int ret = 0;
-
- switch (valtyp) {
- case VIDMODE_H_DISPLAY:
- ret = mode->HDisplay;
- break;
- case VIDMODE_H_SYNCSTART:
- ret = mode->HSyncStart;
- break;
- case VIDMODE_H_SYNCEND:
- ret = mode->HSyncEnd;
- break;
- case VIDMODE_H_TOTAL:
- ret = mode->HTotal;
- break;
- case VIDMODE_H_SKEW:
- ret = mode->HSkew;
- break;
- case VIDMODE_V_DISPLAY:
- ret = mode->VDisplay;
- break;
- case VIDMODE_V_SYNCSTART:
- ret = mode->VSyncStart;
- break;
- case VIDMODE_V_SYNCEND:
- ret = mode->VSyncEnd;
- break;
- case VIDMODE_V_TOTAL:
- ret = mode->VTotal;
- break;
- case VIDMODE_FLAGS:
- ret = mode->Flags;
- break;
- case VIDMODE_CLOCK:
- ret = mode->Clock;
- break;
- }
- return ret;
-}
-
-static void
-VidModeSetModeValue(DisplayModePtr mode, int valtyp, int val)
-{
- switch (valtyp) {
- case VIDMODE_H_DISPLAY:
- mode->HDisplay = val;
- break;
- case VIDMODE_H_SYNCSTART:
- mode->HSyncStart = val;
- break;
- case VIDMODE_H_SYNCEND:
- mode->HSyncEnd = val;
- break;
- case VIDMODE_H_TOTAL:
- mode->HTotal = val;
- break;
- case VIDMODE_H_SKEW:
- mode->HSkew = val;
- break;
- case VIDMODE_V_DISPLAY:
- mode->VDisplay = val;
- break;
- case VIDMODE_V_SYNCSTART:
- mode->VSyncStart = val;
- break;
- case VIDMODE_V_SYNCEND:
- mode->VSyncEnd = val;
- break;
- case VIDMODE_V_TOTAL:
- mode->VTotal = val;
- break;
- case VIDMODE_FLAGS:
- mode->Flags = val;
- break;
- case VIDMODE_CLOCK:
- mode->Clock = val;
- break;
- }
- return;
-}
-
-static int
-ClientMajorVersion(ClientPtr client)
-{
- VidModePrivPtr pPriv;
-
- pPriv = VM_GETPRIV(client);
- if (!pPriv)
- return 0;
- else
- return pPriv->major;
-}
-
-static int
-ProcXF86VidModeQueryVersion(ClientPtr client)
-{
- xXF86VidModeQueryVersionReply rep = {
- .type = X_Reply,
- .sequenceNumber = client->sequence,
- .length = 0,
- .majorVersion = SERVER_XF86VIDMODE_MAJOR_VERSION,
- .minorVersion = SERVER_XF86VIDMODE_MINOR_VERSION
- };
-
- DEBUG_P("XF86VidModeQueryVersion");
-
- REQUEST_SIZE_MATCH(xXF86VidModeQueryVersionReq);
-
- if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swaps(&rep.majorVersion);
- swaps(&rep.minorVersion);
- }
- WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), &rep);
- return Success;
-}
-
-static int
-ProcXF86VidModeGetModeLine(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetModeLineReq);
- xXF86VidModeGetModeLineReply rep = {
- .type = X_Reply,
- .sequenceNumber = client->sequence
- };
- ScreenPtr pScreen;
- DisplayModePtr mode;
- int dotClock;
- int ver;
-
- DEBUG_P("XF86VidModeGetModeline");
-
- ver = ClientMajorVersion(client);
- REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
-
- if (ver < 2) {
- rep.length = bytes_to_int32(SIZEOF(xXF86OldVidModeGetModeLineReply) -
- SIZEOF(xGenericReply));
- }
- else {
- rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetModeLineReply) -
- SIZEOF(xGenericReply));
- }
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
- return BadValue;
-
- rep.dotclock = dotClock;
- rep.hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY);
- rep.hsyncstart = VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART);
- rep.hsyncend = VidModeGetModeValue(mode, VIDMODE_H_SYNCEND);
- rep.htotal = VidModeGetModeValue(mode, VIDMODE_H_TOTAL);
- rep.hskew = VidModeGetModeValue(mode, VIDMODE_H_SKEW);
- rep.vdisplay = VidModeGetModeValue(mode, VIDMODE_V_DISPLAY);
- rep.vsyncstart = VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART);
- rep.vsyncend = VidModeGetModeValue(mode, VIDMODE_V_SYNCEND);
- rep.vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL);
- rep.flags = VidModeGetModeValue(mode, VIDMODE_FLAGS);
-
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
- ErrorF("GetModeLine - scrn: %d clock: %ld\n",
- stuff->screen, (unsigned long) rep.dotclock);
- ErrorF("GetModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
- rep.hdisplay, rep.hsyncstart, rep.hsyncend, rep.htotal);
- ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
- rep.vdisplay, rep.vsyncstart, rep.vsyncend,
- rep.vtotal, (unsigned long) rep.flags);
- }
-
- /*
- * Older servers sometimes had server privates that the VidMode
- * extention made available. So to be compatiable pretend that
- * there are no server privates to pass to the client
- */
- rep.privsize = 0;
-
- if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swapl(&rep.dotclock);
- swaps(&rep.hdisplay);
- swaps(&rep.hsyncstart);
- swaps(&rep.hsyncend);
- swaps(&rep.htotal);
- swaps(&rep.hskew);
- swaps(&rep.vdisplay);
- swaps(&rep.vsyncstart);
- swaps(&rep.vsyncend);
- swaps(&rep.vtotal);
- swapl(&rep.flags);
- swapl(&rep.privsize);
- }
- if (ver < 2) {
- xXF86OldVidModeGetModeLineReply oldrep = {
- .type = rep.type,
- .sequenceNumber = rep.sequenceNumber,
- .length = rep.length,
- .dotclock = rep.dotclock,
- .hdisplay = rep.hdisplay,
- .hsyncstart = rep.hsyncstart,
- .hsyncend = rep.hsyncend,
- .htotal = rep.htotal,
- .vdisplay = rep.vdisplay,
- .vsyncstart = rep.vsyncstart,
- .vsyncend = rep.vsyncend,
- .vtotal = rep.vtotal,
- .flags = rep.flags,
- .privsize = rep.privsize
- };
- WriteToClient(client, sizeof(xXF86OldVidModeGetModeLineReply), &oldrep);
- }
- else {
- WriteToClient(client, sizeof(xXF86VidModeGetModeLineReply), &rep);
- }
- return Success;
-}
-
-static int
-ProcXF86VidModeGetAllModeLines(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetAllModeLinesReq);
- xXF86VidModeGetAllModeLinesReply rep;
- ScreenPtr pScreen;
- DisplayModePtr mode;
- int modecount, dotClock;
- int ver;
-
- DEBUG_P("XF86VidModeGetAllModelines");
-
- REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
- ver = ClientMajorVersion(client);
-
- modecount = xf86VidModeGetNumOfModes(pScreen);
- if (modecount < 1)
- return VidModeErrorBase + XF86VidModeExtensionDisabled;
-
- if (!xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock))
- return BadValue;
-
- rep = (xXF86VidModeGetAllModeLinesReply) {
- .type = X_Reply,
- .length = SIZEOF(xXF86VidModeGetAllModeLinesReply) -
- SIZEOF(xGenericReply),
- .sequenceNumber = client->sequence,
- .modecount = modecount
- };
- if (ver < 2)
- rep.length += modecount * sizeof(xXF86OldVidModeModeInfo);
- else
- rep.length += modecount * sizeof(xXF86VidModeModeInfo);
- rep.length >>= 2;
- if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swapl(&rep.modecount);
- }
- WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply), &rep);
-
- do {
- xXF86VidModeModeInfo mdinf = {
- .dotclock = dotClock,
- .hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
- .hsyncstart = VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
- .hsyncend = VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
- .htotal = VidModeGetModeValue(mode, VIDMODE_H_TOTAL),
- .hskew = VidModeGetModeValue(mode, VIDMODE_H_SKEW),
- .vdisplay = VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
- .vsyncstart = VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
- .vsyncend = VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
- .vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
- .flags = VidModeGetModeValue(mode, VIDMODE_FLAGS),
- .privsize = 0
- };
- if (client->swapped) {
- swapl(&mdinf.dotclock);
- swaps(&mdinf.hdisplay);
- swaps(&mdinf.hsyncstart);
- swaps(&mdinf.hsyncend);
- swaps(&mdinf.htotal);
- swapl(&mdinf.hskew);
- swaps(&mdinf.vdisplay);
- swaps(&mdinf.vsyncstart);
- swaps(&mdinf.vsyncend);
- swaps(&mdinf.vtotal);
- swapl(&mdinf.flags);
- swapl(&mdinf.privsize);
- }
- if (ver < 2) {
- xXF86OldVidModeModeInfo oldmdinf = {
- .dotclock = mdinf.dotclock,
- .hdisplay = mdinf.hdisplay,
- .hsyncstart = mdinf.hsyncstart,
- .hsyncend = mdinf.hsyncend,
- .htotal = mdinf.htotal,
- .vdisplay = mdinf.vdisplay,
- .vsyncstart = mdinf.vsyncstart,
- .vsyncend = mdinf.vsyncend,
- .vtotal = mdinf.vtotal,
- .flags = mdinf.flags,
- .privsize = mdinf.privsize
- };
- WriteToClient(client, sizeof(xXF86OldVidModeModeInfo), &oldmdinf);
- }
- else {
- WriteToClient(client, sizeof(xXF86VidModeModeInfo), &mdinf);
- }
-
- } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
-
- return Success;
-}
-
-#define MODEMATCH(mode,stuff) \
- (VidModeGetModeValue(mode, VIDMODE_H_DISPLAY) == stuff->hdisplay \
- && VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART) == stuff->hsyncstart \
- && VidModeGetModeValue(mode, VIDMODE_H_SYNCEND) == stuff->hsyncend \
- && VidModeGetModeValue(mode, VIDMODE_H_TOTAL) == stuff->htotal \
- && VidModeGetModeValue(mode, VIDMODE_V_DISPLAY) == stuff->vdisplay \
- && VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART) == stuff->vsyncstart \
- && VidModeGetModeValue(mode, VIDMODE_V_SYNCEND) == stuff->vsyncend \
- && VidModeGetModeValue(mode, VIDMODE_V_TOTAL) == stuff->vtotal \
- && VidModeGetModeValue(mode, VIDMODE_FLAGS) == stuff->flags )
-
-static int
-ProcXF86VidModeAddModeLine(ClientPtr client)
-{
- REQUEST(xXF86VidModeAddModeLineReq);
- xXF86OldVidModeAddModeLineReq *oldstuff =
- (xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
- xXF86VidModeAddModeLineReq newstuff;
- ScreenPtr pScreen;
- DisplayModePtr mode;
- int len;
- int dotClock;
- int ver;
-
- DEBUG_P("XF86VidModeAddModeline");
-
- ver = ClientMajorVersion(client);
- if (ver < 2) {
- /* convert from old format */
- stuff = &newstuff;
- stuff->length = oldstuff->length;
- stuff->screen = oldstuff->screen;
- stuff->dotclock = oldstuff->dotclock;
- stuff->hdisplay = oldstuff->hdisplay;
- stuff->hsyncstart = oldstuff->hsyncstart;
- stuff->hsyncend = oldstuff->hsyncend;
- stuff->htotal = oldstuff->htotal;
- stuff->hskew = 0;
- stuff->vdisplay = oldstuff->vdisplay;
- stuff->vsyncstart = oldstuff->vsyncstart;
- stuff->vsyncend = oldstuff->vsyncend;
- stuff->vtotal = oldstuff->vtotal;
- stuff->flags = oldstuff->flags;
- stuff->privsize = oldstuff->privsize;
- stuff->after_dotclock = oldstuff->after_dotclock;
- stuff->after_hdisplay = oldstuff->after_hdisplay;
- stuff->after_hsyncstart = oldstuff->after_hsyncstart;
- stuff->after_hsyncend = oldstuff->after_hsyncend;
- stuff->after_htotal = oldstuff->after_htotal;
- stuff->after_hskew = 0;
- stuff->after_vdisplay = oldstuff->after_vdisplay;
- stuff->after_vsyncstart = oldstuff->after_vsyncstart;
- stuff->after_vsyncend = oldstuff->after_vsyncend;
- stuff->after_vtotal = oldstuff->after_vtotal;
- stuff->after_flags = oldstuff->after_flags;
- }
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
- ErrorF("AddModeLine - scrn: %d clock: %ld\n",
- (int) stuff->screen, (unsigned long) stuff->dotclock);
- ErrorF("AddModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
- stuff->hdisplay, stuff->hsyncstart,
- stuff->hsyncend, stuff->htotal);
- ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
- stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
- stuff->vtotal, (unsigned long) stuff->flags);
- ErrorF(" after - scrn: %d clock: %ld\n",
- (int) stuff->screen, (unsigned long) stuff->after_dotclock);
- ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
- stuff->after_hdisplay, stuff->after_hsyncstart,
- stuff->after_hsyncend, stuff->after_htotal);
- ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
- stuff->after_vdisplay, stuff->after_vsyncstart,
- stuff->after_vsyncend, stuff->after_vtotal,
- (unsigned long) stuff->after_flags);
- }
-
- if (ver < 2) {
- REQUEST_AT_LEAST_SIZE(xXF86OldVidModeAddModeLineReq);
- len =
- client->req_len -
- bytes_to_int32(sizeof(xXF86OldVidModeAddModeLineReq));
- }
- else {
- REQUEST_AT_LEAST_SIZE(xXF86VidModeAddModeLineReq);
- len =
- client->req_len -
- bytes_to_int32(sizeof(xXF86VidModeAddModeLineReq));
- }
- if (len != stuff->privsize)
- return BadLength;
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- if (stuff->hsyncstart < stuff->hdisplay ||
- stuff->hsyncend < stuff->hsyncstart ||
- stuff->htotal < stuff->hsyncend ||
- stuff->vsyncstart < stuff->vdisplay ||
- stuff->vsyncend < stuff->vsyncstart || stuff->vtotal < stuff->vsyncend)
- return BadValue;
-
- if (stuff->after_hsyncstart < stuff->after_hdisplay ||
- stuff->after_hsyncend < stuff->after_hsyncstart ||
- stuff->after_htotal < stuff->after_hsyncend ||
- stuff->after_vsyncstart < stuff->after_vdisplay ||
- stuff->after_vsyncend < stuff->after_vsyncstart ||
- stuff->after_vtotal < stuff->after_vsyncend)
- return BadValue;
-
- if (stuff->after_htotal != 0 || stuff->after_vtotal != 0) {
- Bool found = FALSE;
-
- if (xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock)) {
- do {
- if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock)
- == dotClock) && MODEMATCH(mode, stuff)) {
- found = TRUE;
- break;
- }
- } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
- }
- if (!found)
- return BadValue;
- }
-
- mode = VidModeCreateMode();
- if (mode == NULL)
- return BadValue;
-
- VidModeSetModeValue(mode, VIDMODE_CLOCK, stuff->dotclock);
- VidModeSetModeValue(mode, VIDMODE_H_DISPLAY, stuff->hdisplay);
- VidModeSetModeValue(mode, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
- VidModeSetModeValue(mode, VIDMODE_H_SYNCEND, stuff->hsyncend);
- VidModeSetModeValue(mode, VIDMODE_H_TOTAL, stuff->htotal);
- VidModeSetModeValue(mode, VIDMODE_H_SKEW, stuff->hskew);
- VidModeSetModeValue(mode, VIDMODE_V_DISPLAY, stuff->vdisplay);
- VidModeSetModeValue(mode, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
- VidModeSetModeValue(mode, VIDMODE_V_SYNCEND, stuff->vsyncend);
- VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal);
- VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags);
-
- if (stuff->privsize)
- ErrorF("AddModeLine - Privates in request have been ignored\n");
-
- /* Check that the mode is consistent with the monitor specs */
- switch (xf86VidModeCheckModeForMonitor(pScreen, mode)) {
- case MODE_OK:
- break;
- case MODE_HSYNC:
- case MODE_H_ILLEGAL:
- free(mode);
- return VidModeErrorBase + XF86VidModeBadHTimings;
- case MODE_VSYNC:
- case MODE_V_ILLEGAL:
- free(mode);
- return VidModeErrorBase + XF86VidModeBadVTimings;
- default:
- free(mode);
- return VidModeErrorBase + XF86VidModeModeUnsuitable;
- }
-
- /* Check that the driver is happy with the mode */
- if (xf86VidModeCheckModeForDriver(pScreen, mode) != MODE_OK) {
- free(mode);
- return VidModeErrorBase + XF86VidModeModeUnsuitable;
- }
-
- xf86VidModeSetCrtcForMode(pScreen, mode);
-
- xf86VidModeAddModeline(pScreen, mode);
-
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
- ErrorF("AddModeLine - Succeeded\n");
- return Success;
-}
-
-static int
-ProcXF86VidModeDeleteModeLine(ClientPtr client)
-{
- REQUEST(xXF86VidModeDeleteModeLineReq);
- xXF86OldVidModeDeleteModeLineReq *oldstuff =
- (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
- xXF86VidModeDeleteModeLineReq newstuff;
- ScreenPtr pScreen;
- DisplayModePtr mode;
- int len, dotClock;
- int ver;
-
- DEBUG_P("XF86VidModeDeleteModeline");
-
- ver = ClientMajorVersion(client);
- if (ver < 2) {
- /* convert from old format */
- stuff = &newstuff;
- stuff->length = oldstuff->length;
- stuff->screen = oldstuff->screen;
- stuff->dotclock = oldstuff->dotclock;
- stuff->hdisplay = oldstuff->hdisplay;
- stuff->hsyncstart = oldstuff->hsyncstart;
- stuff->hsyncend = oldstuff->hsyncend;
- stuff->htotal = oldstuff->htotal;
- stuff->hskew = 0;
- stuff->vdisplay = oldstuff->vdisplay;
- stuff->vsyncstart = oldstuff->vsyncstart;
- stuff->vsyncend = oldstuff->vsyncend;
- stuff->vtotal = oldstuff->vtotal;
- stuff->flags = oldstuff->flags;
- stuff->privsize = oldstuff->privsize;
- }
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
- ErrorF("DeleteModeLine - scrn: %d clock: %ld\n",
- (int) stuff->screen, (unsigned long) stuff->dotclock);
- ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
- stuff->hdisplay, stuff->hsyncstart,
- stuff->hsyncend, stuff->htotal);
- ErrorF
- (" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
- stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
- (unsigned long) stuff->flags);
- }
-
- if (ver < 2) {
- REQUEST_AT_LEAST_SIZE(xXF86OldVidModeDeleteModeLineReq);
- len =
- client->req_len -
- bytes_to_int32(sizeof(xXF86OldVidModeDeleteModeLineReq));
- }
- else {
- REQUEST_AT_LEAST_SIZE(xXF86VidModeDeleteModeLineReq);
- len =
- client->req_len -
- bytes_to_int32(sizeof(xXF86VidModeDeleteModeLineReq));
- }
- if (len != stuff->privsize) {
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
- ErrorF("req_len = %ld, sizeof(Req) = %d, privsize = %ld, "
- "len = %d, length = %d\n",
- (unsigned long) client->req_len,
- (int) sizeof(xXF86VidModeDeleteModeLineReq) >> 2,
- (unsigned long) stuff->privsize, len, stuff->length);
- }
- return BadLength;
- }
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
- return BadValue;
-
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
- ErrorF("Checking against clock: %d (%d)\n",
- VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
- ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
- VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
- VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
- VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
- VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
- ErrorF
- (" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
- VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
- VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
- VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
- VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
- VidModeGetModeValue(mode, VIDMODE_FLAGS));
- }
- if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
- MODEMATCH(mode, stuff))
- return BadValue;
-
- if (!xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock))
- return BadValue;
-
- do {
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
- ErrorF("Checking against clock: %d (%d)\n",
- VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
- ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
- VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
- VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
- VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
- VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
- ErrorF
- (" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
- VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
- VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
- VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
- VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
- VidModeGetModeValue(mode, VIDMODE_FLAGS));
- }
- if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
- MODEMATCH(mode, stuff)) {
- xf86VidModeDeleteModeline(pScreen, mode);
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
- ErrorF("DeleteModeLine - Succeeded\n");
- return Success;
- }
- } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
-
- return BadValue;
-}
-
-static int
-ProcXF86VidModeModModeLine(ClientPtr client)
-{
- REQUEST(xXF86VidModeModModeLineReq);
- xXF86OldVidModeModModeLineReq *oldstuff =
- (xXF86OldVidModeModModeLineReq *) client->requestBuffer;
- xXF86VidModeModModeLineReq newstuff;
- ScreenPtr pScreen;
- DisplayModePtr mode, modetmp;
- int len, dotClock;
- int ver;
-
- DEBUG_P("XF86VidModeModModeline");
-
- ver = ClientMajorVersion(client);
- if (ver < 2) {
- /* convert from old format */
- stuff = &newstuff;
- stuff->length = oldstuff->length;
- stuff->screen = oldstuff->screen;
- stuff->hdisplay = oldstuff->hdisplay;
- stuff->hsyncstart = oldstuff->hsyncstart;
- stuff->hsyncend = oldstuff->hsyncend;
- stuff->htotal = oldstuff->htotal;
- stuff->hskew = 0;
- stuff->vdisplay = oldstuff->vdisplay;
- stuff->vsyncstart = oldstuff->vsyncstart;
- stuff->vsyncend = oldstuff->vsyncend;
- stuff->vtotal = oldstuff->vtotal;
- stuff->flags = oldstuff->flags;
- stuff->privsize = oldstuff->privsize;
- }
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
- ErrorF("ModModeLine - scrn: %d hdsp: %d hbeg: %d hend: %d httl: %d\n",
- (int) stuff->screen, stuff->hdisplay, stuff->hsyncstart,
- stuff->hsyncend, stuff->htotal);
- ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
- stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
- stuff->vtotal, (unsigned long) stuff->flags);
- }
-
- if (ver < 2) {
- REQUEST_AT_LEAST_SIZE(xXF86OldVidModeModModeLineReq);
- len =
- client->req_len -
- bytes_to_int32(sizeof(xXF86OldVidModeModModeLineReq));
- }
- else {
- REQUEST_AT_LEAST_SIZE(xXF86VidModeModModeLineReq);
- len =
- client->req_len -
- bytes_to_int32(sizeof(xXF86VidModeModModeLineReq));
- }
- if (len != stuff->privsize)
- return BadLength;
-
- if (stuff->hsyncstart < stuff->hdisplay ||
- stuff->hsyncend < stuff->hsyncstart ||
- stuff->htotal < stuff->hsyncend ||
- stuff->vsyncstart < stuff->vdisplay ||
- stuff->vsyncend < stuff->vsyncstart || stuff->vtotal < stuff->vsyncend)
- return BadValue;
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
- return BadValue;
-
- modetmp = VidModeCreateMode();
- VidModeCopyMode(mode, modetmp);
-
- VidModeSetModeValue(modetmp, VIDMODE_H_DISPLAY, stuff->hdisplay);
- VidModeSetModeValue(modetmp, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
- VidModeSetModeValue(modetmp, VIDMODE_H_SYNCEND, stuff->hsyncend);
- VidModeSetModeValue(modetmp, VIDMODE_H_TOTAL, stuff->htotal);
- VidModeSetModeValue(modetmp, VIDMODE_H_SKEW, stuff->hskew);
- VidModeSetModeValue(modetmp, VIDMODE_V_DISPLAY, stuff->vdisplay);
- VidModeSetModeValue(modetmp, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
- VidModeSetModeValue(modetmp, VIDMODE_V_SYNCEND, stuff->vsyncend);
- VidModeSetModeValue(modetmp, VIDMODE_V_TOTAL, stuff->vtotal);
- VidModeSetModeValue(modetmp, VIDMODE_FLAGS, stuff->flags);
-
- if (stuff->privsize)
- ErrorF("ModModeLine - Privates in request have been ignored\n");
-
- /* Check that the mode is consistent with the monitor specs */
- switch (xf86VidModeCheckModeForMonitor(pScreen, modetmp)) {
- case MODE_OK:
- break;
- case MODE_HSYNC:
- case MODE_H_ILLEGAL:
- free(modetmp);
- return VidModeErrorBase + XF86VidModeBadHTimings;
- case MODE_VSYNC:
- case MODE_V_ILLEGAL:
- free(modetmp);
- return VidModeErrorBase + XF86VidModeBadVTimings;
- default:
- free(modetmp);
- return VidModeErrorBase + XF86VidModeModeUnsuitable;
- }
-
- /* Check that the driver is happy with the mode */
- if (xf86VidModeCheckModeForDriver(pScreen, modetmp) != MODE_OK) {
- free(modetmp);
- return VidModeErrorBase + XF86VidModeModeUnsuitable;
- }
- free(modetmp);
-
- VidModeSetModeValue(mode, VIDMODE_H_DISPLAY, stuff->hdisplay);
- VidModeSetModeValue(mode, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
- VidModeSetModeValue(mode, VIDMODE_H_SYNCEND, stuff->hsyncend);
- VidModeSetModeValue(mode, VIDMODE_H_TOTAL, stuff->htotal);
- VidModeSetModeValue(mode, VIDMODE_H_SKEW, stuff->hskew);
- VidModeSetModeValue(mode, VIDMODE_V_DISPLAY, stuff->vdisplay);
- VidModeSetModeValue(mode, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
- VidModeSetModeValue(mode, VIDMODE_V_SYNCEND, stuff->vsyncend);
- VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal);
- VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags);
-
- xf86VidModeSetCrtcForMode(pScreen, mode);
- xf86VidModeSwitchMode(pScreen, mode);
-
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
- ErrorF("ModModeLine - Succeeded\n");
- return Success;
-}
-
-static int
-ProcXF86VidModeValidateModeLine(ClientPtr client)
-{
- REQUEST(xXF86VidModeValidateModeLineReq);
- xXF86OldVidModeValidateModeLineReq *oldstuff =
- (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer;
- xXF86VidModeValidateModeLineReq newstuff;
- xXF86VidModeValidateModeLineReply rep;
- ScreenPtr pScreen;
- DisplayModePtr mode, modetmp = NULL;
- int len, status, dotClock;
- int ver;
-
- DEBUG_P("XF86VidModeValidateModeline");
-
- ver = ClientMajorVersion(client);
- if (ver < 2) {
- /* convert from old format */
- stuff = &newstuff;
- stuff->length = oldstuff->length;
- stuff->screen = oldstuff->screen;
- stuff->dotclock = oldstuff->dotclock;
- stuff->hdisplay = oldstuff->hdisplay;
- stuff->hsyncstart = oldstuff->hsyncstart;
- stuff->hsyncend = oldstuff->hsyncend;
- stuff->htotal = oldstuff->htotal;
- stuff->hskew = 0;
- stuff->vdisplay = oldstuff->vdisplay;
- stuff->vsyncstart = oldstuff->vsyncstart;
- stuff->vsyncend = oldstuff->vsyncend;
- stuff->vtotal = oldstuff->vtotal;
- stuff->flags = oldstuff->flags;
- stuff->privsize = oldstuff->privsize;
- }
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
- ErrorF("ValidateModeLine - scrn: %d clock: %ld\n",
- (int) stuff->screen, (unsigned long) stuff->dotclock);
- ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
- stuff->hdisplay, stuff->hsyncstart,
- stuff->hsyncend, stuff->htotal);
- ErrorF
- (" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
- stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
- (unsigned long) stuff->flags);
- }
-
- if (ver < 2) {
- REQUEST_AT_LEAST_SIZE(xXF86OldVidModeValidateModeLineReq);
- len = client->req_len -
- bytes_to_int32(sizeof(xXF86OldVidModeValidateModeLineReq));
- }
- else {
- REQUEST_AT_LEAST_SIZE(xXF86VidModeValidateModeLineReq);
- len =
- client->req_len -
- bytes_to_int32(sizeof(xXF86VidModeValidateModeLineReq));
- }
- if (len != stuff->privsize)
- return BadLength;
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- status = MODE_OK;
-
- if (stuff->hsyncstart < stuff->hdisplay ||
- stuff->hsyncend < stuff->hsyncstart ||
- stuff->htotal < stuff->hsyncend ||
- stuff->vsyncstart < stuff->vdisplay ||
- stuff->vsyncend < stuff->vsyncstart ||
- stuff->vtotal < stuff->vsyncend) {
- status = MODE_BAD;
- goto status_reply;
- }
-
- if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
- return BadValue;
-
- modetmp = VidModeCreateMode();
- VidModeCopyMode(mode, modetmp);
-
- VidModeSetModeValue(modetmp, VIDMODE_H_DISPLAY, stuff->hdisplay);
- VidModeSetModeValue(modetmp, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
- VidModeSetModeValue(modetmp, VIDMODE_H_SYNCEND, stuff->hsyncend);
- VidModeSetModeValue(modetmp, VIDMODE_H_TOTAL, stuff->htotal);
- VidModeSetModeValue(modetmp, VIDMODE_H_SKEW, stuff->hskew);
- VidModeSetModeValue(modetmp, VIDMODE_V_DISPLAY, stuff->vdisplay);
- VidModeSetModeValue(modetmp, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
- VidModeSetModeValue(modetmp, VIDMODE_V_SYNCEND, stuff->vsyncend);
- VidModeSetModeValue(modetmp, VIDMODE_V_TOTAL, stuff->vtotal);
- VidModeSetModeValue(modetmp, VIDMODE_FLAGS, stuff->flags);
- if (stuff->privsize)
- ErrorF("ValidateModeLine - Privates in request have been ignored\n");
-
- /* Check that the mode is consistent with the monitor specs */
- if ((status =
- xf86VidModeCheckModeForMonitor(pScreen, modetmp)) != MODE_OK)
- goto status_reply;
-
- /* Check that the driver is happy with the mode */
- status = xf86VidModeCheckModeForDriver(pScreen, modetmp);
-
- status_reply:
- free(modetmp);
-
- rep = (xXF86VidModeValidateModeLineReply) {
- .type = X_Reply,
- .sequenceNumber = client->sequence,
- .length = bytes_to_int32(SIZEOF(xXF86VidModeValidateModeLineReply)
- - SIZEOF(xGenericReply)),
- .status = status
- };
- if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swapl(&rep.status);
- }
- WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply), &rep);
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
- ErrorF("ValidateModeLine - Succeeded (status = %d)\n", status);
- return Success;
-}
-
-static int
-ProcXF86VidModeSwitchMode(ClientPtr client)
-{
- REQUEST(xXF86VidModeSwitchModeReq);
- ScreenPtr pScreen;
-
- DEBUG_P("XF86VidModeSwitchMode");
-
- REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- xf86VidModeZoomViewport(pScreen, (short) stuff->zoom);
-
- return Success;
-}
-
-static int
-ProcXF86VidModeSwitchToMode(ClientPtr client)
-{
- REQUEST(xXF86VidModeSwitchToModeReq);
- xXF86OldVidModeSwitchToModeReq *oldstuff =
- (xXF86OldVidModeSwitchToModeReq *) client->requestBuffer;
- xXF86VidModeSwitchToModeReq newstuff;
- ScreenPtr pScreen;
- DisplayModePtr mode;
- int len, dotClock;
- int ver;
-
- DEBUG_P("XF86VidModeSwitchToMode");
-
- ver = ClientMajorVersion(client);
- if (ver < 2) {
- /* convert from old format */
- stuff = &newstuff;
- stuff->length = oldstuff->length;
- stuff->screen = oldstuff->screen;
- stuff->dotclock = oldstuff->dotclock;
- stuff->hdisplay = oldstuff->hdisplay;
- stuff->hsyncstart = oldstuff->hsyncstart;
- stuff->hsyncend = oldstuff->hsyncend;
- stuff->htotal = oldstuff->htotal;
- stuff->hskew = 0;
- stuff->vdisplay = oldstuff->vdisplay;
- stuff->vsyncstart = oldstuff->vsyncstart;
- stuff->vsyncend = oldstuff->vsyncend;
- stuff->vtotal = oldstuff->vtotal;
- stuff->flags = oldstuff->flags;
- stuff->privsize = oldstuff->privsize;
- }
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
- ErrorF("SwitchToMode - scrn: %d clock: %ld\n",
- (int) stuff->screen, (unsigned long) stuff->dotclock);
- ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
- stuff->hdisplay, stuff->hsyncstart,
- stuff->hsyncend, stuff->htotal);
- ErrorF
- (" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
- stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
- (unsigned long) stuff->flags);
- }
-
- if (ver < 2) {
- REQUEST_AT_LEAST_SIZE(xXF86OldVidModeSwitchToModeReq);
- len =
- client->req_len -
- bytes_to_int32(sizeof(xXF86OldVidModeSwitchToModeReq));
- }
- else {
- REQUEST_AT_LEAST_SIZE(xXF86VidModeSwitchToModeReq);
- len =
- client->req_len -
- bytes_to_int32(sizeof(xXF86VidModeSwitchToModeReq));
- }
- if (len != stuff->privsize)
- return BadLength;
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
- return BadValue;
-
- if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock)
- && MODEMATCH(mode, stuff))
- return Success;
-
- if (!xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock))
- return BadValue;
-
- do {
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
- ErrorF("Checking against clock: %d (%d)\n",
- VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
- ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
- VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
- VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
- VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
- VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
- ErrorF
- (" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
- VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
- VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
- VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
- VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
- VidModeGetModeValue(mode, VIDMODE_FLAGS));
- }
- if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
- MODEMATCH(mode, stuff)) {
-
- if (!xf86VidModeSwitchMode(pScreen, mode))
- return BadValue;
-
- if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
- ErrorF("SwitchToMode - Succeeded\n");
- return Success;
- }
- } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
-
- return BadValue;
-}
-
-static int
-ProcXF86VidModeLockModeSwitch(ClientPtr client)
-{
- REQUEST(xXF86VidModeLockModeSwitchReq);
- ScreenPtr pScreen;
-
- REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
-
- DEBUG_P("XF86VidModeLockModeSwitch");
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- if (!xf86VidModeLockZoom(pScreen, (short) stuff->lock))
- return VidModeErrorBase + XF86VidModeZoomLocked;
-
- return Success;
-}
-
-static int
-ProcXF86VidModeGetMonitor(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetMonitorReq);
- xXF86VidModeGetMonitorReply rep = {
- .type = X_Reply,
- .sequenceNumber = client->sequence
- };
- CARD32 *hsyncdata, *vsyncdata;
- int i, nHsync, nVrefresh;
- ScreenPtr pScreen;
-
- DEBUG_P("XF86VidModeGetMonitor");
-
- REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- nHsync = xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_NHSYNC, 0).i;
- nVrefresh = xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_NVREFRESH, 0).i;
-
- if ((char *) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr)
- rep.vendorLength = strlen((char *) (xf86VidModeGetMonitorValue(pScreen,
- VIDMODE_MON_VENDOR,
- 0)).ptr);
- else
- rep.vendorLength = 0;
- if ((char *) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr)
- rep.modelLength = strlen((char *) (xf86VidModeGetMonitorValue(pScreen,
- VIDMODE_MON_MODEL,
- 0)).ptr);
- else
- rep.modelLength = 0;
- rep.length =
- bytes_to_int32(SIZEOF(xXF86VidModeGetMonitorReply) -
- SIZEOF(xGenericReply) + (nHsync +
- nVrefresh) * sizeof(CARD32) +
- pad_to_int32(rep.vendorLength) +
- pad_to_int32(rep.modelLength));
- rep.nhsync = nHsync;
- rep.nvsync = nVrefresh;
- hsyncdata = xallocarray(nHsync, sizeof(CARD32));
- if (!hsyncdata) {
- return BadAlloc;
- }
- vsyncdata = xallocarray(nVrefresh, sizeof(CARD32));
-
- if (!vsyncdata) {
- free(hsyncdata);
- return BadAlloc;
- }
-
- for (i = 0; i < nHsync; i++) {
- hsyncdata[i] = (unsigned short) (xf86VidModeGetMonitorValue(pScreen,
- VIDMODE_MON_HSYNC_LO,
- i)).f |
- (unsigned
- short) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_HSYNC_HI,
- i)).f << 16;
- }
- for (i = 0; i < nVrefresh; i++) {
- vsyncdata[i] = (unsigned short) (xf86VidModeGetMonitorValue(pScreen,
- VIDMODE_MON_VREFRESH_LO,
- i)).f |
- (unsigned
- short) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_VREFRESH_HI,
- i)).f << 16;
- }
-
- if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- }
- WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply), &rep);
- client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
- WriteSwappedDataToClient(client, nHsync * sizeof(CARD32), hsyncdata);
- WriteSwappedDataToClient(client, nVrefresh * sizeof(CARD32), vsyncdata);
- if (rep.vendorLength)
- WriteToClient(client, rep.vendorLength,
- (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr);
- if (rep.modelLength)
- WriteToClient(client, rep.modelLength,
- (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr);
-
- free(hsyncdata);
- free(vsyncdata);
-
- return Success;
-}
-
-static int
-ProcXF86VidModeGetViewPort(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetViewPortReq);
- xXF86VidModeGetViewPortReply rep;
- ScreenPtr pScreen;
- int x, y;
-
- DEBUG_P("XF86VidModeGetViewPort");
-
- REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- xf86VidModeGetViewPort(pScreen, &x, &y);
-
- rep = (xXF86VidModeGetViewPortReply) {
- .type = X_Reply,
- .sequenceNumber = client->sequence,
- .length = 0,
- .x = x,
- .y = y
- };
-
- if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swapl(&rep.x);
- swapl(&rep.y);
- }
- WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), &rep);
- return Success;
-}
-
-static int
-ProcXF86VidModeSetViewPort(ClientPtr client)
-{
- REQUEST(xXF86VidModeSetViewPortReq);
- ScreenPtr pScreen;
-
- DEBUG_P("XF86VidModeSetViewPort");
-
- REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- if (!xf86VidModeSetViewPort(pScreen, stuff->x, stuff->y))
- return BadValue;
-
- return Success;
-}
-
-static int
-ProcXF86VidModeGetDotClocks(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetDotClocksReq);
- xXF86VidModeGetDotClocksReply rep;
- ScreenPtr pScreen;
- int n;
- int numClocks;
- CARD32 dotclock;
- int *Clocks = NULL;
- Bool ClockProg;
-
- DEBUG_P("XF86VidModeGetDotClocks");
-
- REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- numClocks = xf86VidModeGetNumOfClocks(pScreen, &ClockProg);
-
- rep = (xXF86VidModeGetDotClocksReply) {
- .type = X_Reply,
- .sequenceNumber = client->sequence,
- .length = bytes_to_int32(SIZEOF(xXF86VidModeGetDotClocksReply)
- - SIZEOF(xGenericReply) + numClocks),
- .clocks = numClocks,
- .maxclocks = MAXCLOCKS,
- .flags = 0
- };
-
- if (!ClockProg) {
- Clocks = calloc(numClocks, sizeof(int));
- if (!Clocks)
- return BadValue;
- if (!xf86VidModeGetClocks(pScreen, Clocks)) {
- free(Clocks);
- return BadValue;
- }
- }
- if (ClockProg) {
- rep.flags |= CLKFLAG_PROGRAMABLE;
- }
- if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swapl(&rep.clocks);
- swapl(&rep.maxclocks);
- swapl(&rep.flags);
- }
- WriteToClient(client, sizeof(xXF86VidModeGetDotClocksReply), &rep);
- if (!ClockProg) {
- for (n = 0; n < numClocks; n++) {
- dotclock = *Clocks++;
- if (client->swapped) {
- WriteSwappedDataToClient(client, 4, (char *) &dotclock);
- }
- else {
- WriteToClient(client, 4, &dotclock);
- }
- }
- }
-
- free(Clocks);
- return Success;
-}
-
-static int
-ProcXF86VidModeSetGamma(ClientPtr client)
-{
- REQUEST(xXF86VidModeSetGammaReq);
- ScreenPtr pScreen;
-
- DEBUG_P("XF86VidModeSetGamma");
-
- REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- if (!xf86VidModeSetGamma(pScreen, ((float) stuff->red) / 10000.,
- ((float) stuff->green) / 10000.,
- ((float) stuff->blue) / 10000.))
- return BadValue;
-
- return Success;
-}
-
-static int
-ProcXF86VidModeGetGamma(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetGammaReq);
- xXF86VidModeGetGammaReply rep;
- ScreenPtr pScreen;
- float red, green, blue;
-
- DEBUG_P("XF86VidModeGetGamma");
-
- REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- if (!xf86VidModeGetGamma(pScreen, &red, &green, &blue))
- return BadValue;
- rep = (xXF86VidModeGetGammaReply) {
- .type = X_Reply,
- .sequenceNumber = client->sequence,
- .length = 0,
- .red = (CARD32) (red * 10000.),
- .green = (CARD32) (green * 10000.),
- .blue = (CARD32) (blue * 10000.)
- };
- if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swapl(&rep.red);
- swapl(&rep.green);
- swapl(&rep.blue);
- }
- WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), &rep);
-
- return Success;
-}
-
-static int
-ProcXF86VidModeSetGammaRamp(ClientPtr client)
-{
- ScreenPtr pScreen;
- CARD16 *r, *g, *b;
- int length;
-
- REQUEST(xXF86VidModeSetGammaRampReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- if (stuff->size != xf86VidModeGetGammaRampSize(pScreen))
- return BadValue;
-
- length = (stuff->size + 1) & ~1;
-
- REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length * 6);
-
- r = (CARD16 *) &stuff[1];
- g = r + length;
- b = g + length;
-
- if (!xf86VidModeSetGammaRamp(pScreen, stuff->size, r, g, b))
- return BadValue;
-
- return Success;
-}
-
-static int
-ProcXF86VidModeGetGammaRamp(ClientPtr client)
-{
- CARD16 *ramp = NULL;
- int length;
- size_t ramplen = 0;
- xXF86VidModeGetGammaRampReply rep;
- ScreenPtr pScreen;
-
- REQUEST(xXF86VidModeGetGammaRampReq);
-
- REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- if (stuff->size != xf86VidModeGetGammaRampSize(pScreen))
- return BadValue;
-
- length = (stuff->size + 1) & ~1;
-
- if (stuff->size) {
- if (!(ramp = xallocarray(length, 3 * sizeof(CARD16))))
- return BadAlloc;
- ramplen = length * 3 * sizeof(CARD16);
-
- if (!xf86VidModeGetGammaRamp(pScreen, stuff->size,
- ramp, ramp + length, ramp + (length * 2))) {
- free(ramp);
- return BadValue;
- }
- }
- rep = (xXF86VidModeGetGammaRampReply) {
- .type = X_Reply,
- .sequenceNumber = client->sequence,
- .length = (length >> 1) * 3,
- .size = stuff->size
- };
- if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swaps(&rep.size);
- SwapShorts((short *) ramp, length * 3);
- }
- WriteToClient(client, sizeof(xXF86VidModeGetGammaRampReply), &rep);
-
- if (stuff->size) {
- WriteToClient(client, ramplen, ramp);
- free(ramp);
- }
-
- return Success;
-}
-
-static int
-ProcXF86VidModeGetGammaRampSize(ClientPtr client)
-{
- xXF86VidModeGetGammaRampSizeReply rep;
- ScreenPtr pScreen;
-
- REQUEST(xXF86VidModeGetGammaRampSizeReq);
-
- REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
- pScreen = screenInfo.screens[stuff->screen];
-
- rep = (xXF86VidModeGetGammaRampSizeReply) {
- .type = X_Reply,
- .sequenceNumber = client->sequence,
- .length = 0,
- .size = xf86VidModeGetGammaRampSize(pScreen)
- };
- if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swaps(&rep.size);
- }
- WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply), &rep);
-
- return Success;
-}
-
-static int
-ProcXF86VidModeGetPermissions(ClientPtr client)
-{
- xXF86VidModeGetPermissionsReply rep = {
- .type = X_Reply,
- .sequenceNumber = client->sequence,
- .length = 0,
- .permissions = XF86VM_READ_PERMISSION
- };
-
- REQUEST(xXF86VidModeGetPermissionsReq);
-
- REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq);
-
- if (stuff->screen >= screenInfo.numScreens)
- return BadValue;
-
- if (xf86GetVidModeEnabled() &&
- (xf86GetVidModeAllowNonLocal() || client->local)) {
- rep.permissions |= XF86VM_WRITE_PERMISSION;
- }
- if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swapl(&rep.permissions);
- }
- WriteToClient(client, sizeof(xXF86VidModeGetPermissionsReply), &rep);
-
- return Success;
-}
-
-static int
-ProcXF86VidModeSetClientVersion(ClientPtr client)
-{
- REQUEST(xXF86VidModeSetClientVersionReq);
-
- VidModePrivPtr pPriv;
-
- DEBUG_P("XF86VidModeSetClientVersion");
-
- REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq);
-
- if ((pPriv = VM_GETPRIV(client)) == NULL) {
- pPriv = malloc(sizeof(VidModePrivRec));
- if (!pPriv)
- return BadAlloc;
- VM_SETPRIV(client, pPriv);
- }
- pPriv->major = stuff->major;
-
- pPriv->minor = stuff->minor;
-
- return Success;
-}
-
-static int
-ProcXF86VidModeDispatch(ClientPtr client)
-{
- REQUEST(xReq);
- switch (stuff->data) {
- case X_XF86VidModeQueryVersion:
- return ProcXF86VidModeQueryVersion(client);
- case X_XF86VidModeGetModeLine:
- return ProcXF86VidModeGetModeLine(client);
- case X_XF86VidModeGetMonitor:
- return ProcXF86VidModeGetMonitor(client);
- case X_XF86VidModeGetAllModeLines:
- return ProcXF86VidModeGetAllModeLines(client);
- case X_XF86VidModeValidateModeLine:
- return ProcXF86VidModeValidateModeLine(client);
- case X_XF86VidModeGetViewPort:
- return ProcXF86VidModeGetViewPort(client);
- case X_XF86VidModeGetDotClocks:
- return ProcXF86VidModeGetDotClocks(client);
- case X_XF86VidModeSetClientVersion:
- return ProcXF86VidModeSetClientVersion(client);
- case X_XF86VidModeGetGamma:
- return ProcXF86VidModeGetGamma(client);
- case X_XF86VidModeGetGammaRamp:
- return ProcXF86VidModeGetGammaRamp(client);
- case X_XF86VidModeGetGammaRampSize:
- return ProcXF86VidModeGetGammaRampSize(client);
- case X_XF86VidModeGetPermissions:
- return ProcXF86VidModeGetPermissions(client);
- default:
- if (!xf86GetVidModeEnabled())
- return VidModeErrorBase + XF86VidModeExtensionDisabled;
- if (xf86GetVidModeAllowNonLocal() || client->local) {
- switch (stuff->data) {
- case X_XF86VidModeAddModeLine:
- return ProcXF86VidModeAddModeLine(client);
- case X_XF86VidModeDeleteModeLine:
- return ProcXF86VidModeDeleteModeLine(client);
- case X_XF86VidModeModModeLine:
- return ProcXF86VidModeModModeLine(client);
- case X_XF86VidModeSwitchMode:
- return ProcXF86VidModeSwitchMode(client);
- case X_XF86VidModeSwitchToMode:
- return ProcXF86VidModeSwitchToMode(client);
- case X_XF86VidModeLockModeSwitch:
- return ProcXF86VidModeLockModeSwitch(client);
- case X_XF86VidModeSetViewPort:
- return ProcXF86VidModeSetViewPort(client);
- case X_XF86VidModeSetGamma:
- return ProcXF86VidModeSetGamma(client);
- case X_XF86VidModeSetGammaRamp:
- return ProcXF86VidModeSetGammaRamp(client);
- default:
- return BadRequest;
- }
- }
- else
- return VidModeErrorBase + XF86VidModeClientNotLocal;
- }
-}
-
-static int
-SProcXF86VidModeQueryVersion(ClientPtr client)
-{
- REQUEST(xXF86VidModeQueryVersionReq);
- swaps(&stuff->length);
- return ProcXF86VidModeQueryVersion(client);
-}
-
-static int
-SProcXF86VidModeGetModeLine(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetModeLineReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
- swaps(&stuff->screen);
- return ProcXF86VidModeGetModeLine(client);
-}
-
-static int
-SProcXF86VidModeGetAllModeLines(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetAllModeLinesReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
- swaps(&stuff->screen);
- return ProcXF86VidModeGetAllModeLines(client);
-}
-
-static int
-SProcXF86VidModeAddModeLine(ClientPtr client)
-{
- xXF86OldVidModeAddModeLineReq *oldstuff =
- (xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
- int ver;
-
- REQUEST(xXF86VidModeAddModeLineReq);
- ver = ClientMajorVersion(client);
- if (ver < 2) {
- swaps(&oldstuff->length);
- REQUEST_AT_LEAST_SIZE(xXF86OldVidModeAddModeLineReq);
- swapl(&oldstuff->screen);
- swaps(&oldstuff->hdisplay);
- swaps(&oldstuff->hsyncstart);
- swaps(&oldstuff->hsyncend);
- swaps(&oldstuff->htotal);
- swaps(&oldstuff->vdisplay);
- swaps(&oldstuff->vsyncstart);
- swaps(&oldstuff->vsyncend);
- swaps(&oldstuff->vtotal);
- swapl(&oldstuff->flags);
- swapl(&oldstuff->privsize);
- SwapRestL(oldstuff);
- }
- else {
- swaps(&stuff->length);
- REQUEST_AT_LEAST_SIZE(xXF86VidModeAddModeLineReq);
- swapl(&stuff->screen);
- swaps(&stuff->hdisplay);
- swaps(&stuff->hsyncstart);
- swaps(&stuff->hsyncend);
- swaps(&stuff->htotal);
- swaps(&stuff->hskew);
- swaps(&stuff->vdisplay);
- swaps(&stuff->vsyncstart);
- swaps(&stuff->vsyncend);
- swaps(&stuff->vtotal);
- swapl(&stuff->flags);
- swapl(&stuff->privsize);
- SwapRestL(stuff);
- }
- return ProcXF86VidModeAddModeLine(client);
-}
-
-static int
-SProcXF86VidModeDeleteModeLine(ClientPtr client)
-{
- xXF86OldVidModeDeleteModeLineReq *oldstuff =
- (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
- int ver;
-
- REQUEST(xXF86VidModeDeleteModeLineReq);
- ver = ClientMajorVersion(client);
- if (ver < 2) {
- swaps(&oldstuff->length);
- REQUEST_AT_LEAST_SIZE(xXF86OldVidModeDeleteModeLineReq);
- swapl(&oldstuff->screen);
- swaps(&oldstuff->hdisplay);
- swaps(&oldstuff->hsyncstart);
- swaps(&oldstuff->hsyncend);
- swaps(&oldstuff->htotal);
- swaps(&oldstuff->vdisplay);
- swaps(&oldstuff->vsyncstart);
- swaps(&oldstuff->vsyncend);
- swaps(&oldstuff->vtotal);
- swapl(&oldstuff->flags);
- swapl(&oldstuff->privsize);
- SwapRestL(oldstuff);
- }
- else {
- swaps(&stuff->length);
- REQUEST_AT_LEAST_SIZE(xXF86VidModeDeleteModeLineReq);
- swapl(&stuff->screen);
- swaps(&stuff->hdisplay);
- swaps(&stuff->hsyncstart);
- swaps(&stuff->hsyncend);
- swaps(&stuff->htotal);
- swaps(&stuff->hskew);
- swaps(&stuff->vdisplay);
- swaps(&stuff->vsyncstart);
- swaps(&stuff->vsyncend);
- swaps(&stuff->vtotal);
- swapl(&stuff->flags);
- swapl(&stuff->privsize);
- SwapRestL(stuff);
- }
- return ProcXF86VidModeDeleteModeLine(client);
-}
-
-static int
-SProcXF86VidModeModModeLine(ClientPtr client)
-{
- xXF86OldVidModeModModeLineReq *oldstuff =
- (xXF86OldVidModeModModeLineReq *) client->requestBuffer;
- int ver;
-
- REQUEST(xXF86VidModeModModeLineReq);
- ver = ClientMajorVersion(client);
- if (ver < 2) {
- swaps(&oldstuff->length);
- REQUEST_AT_LEAST_SIZE(xXF86OldVidModeModModeLineReq);
- swapl(&oldstuff->screen);
- swaps(&oldstuff->hdisplay);
- swaps(&oldstuff->hsyncstart);
- swaps(&oldstuff->hsyncend);
- swaps(&oldstuff->htotal);
- swaps(&oldstuff->vdisplay);
- swaps(&oldstuff->vsyncstart);
- swaps(&oldstuff->vsyncend);
- swaps(&oldstuff->vtotal);
- swapl(&oldstuff->flags);
- swapl(&oldstuff->privsize);
- SwapRestL(oldstuff);
- }
- else {
- swaps(&stuff->length);
- REQUEST_AT_LEAST_SIZE(xXF86VidModeModModeLineReq);
- swapl(&stuff->screen);
- swaps(&stuff->hdisplay);
- swaps(&stuff->hsyncstart);
- swaps(&stuff->hsyncend);
- swaps(&stuff->htotal);
- swaps(&stuff->hskew);
- swaps(&stuff->vdisplay);
- swaps(&stuff->vsyncstart);
- swaps(&stuff->vsyncend);
- swaps(&stuff->vtotal);
- swapl(&stuff->flags);
- swapl(&stuff->privsize);
- SwapRestL(stuff);
- }
- return ProcXF86VidModeModModeLine(client);
-}
-
-static int
-SProcXF86VidModeValidateModeLine(ClientPtr client)
-{
- xXF86OldVidModeValidateModeLineReq *oldstuff =
- (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer;
- int ver;
-
- REQUEST(xXF86VidModeValidateModeLineReq);
- ver = ClientMajorVersion(client);
- if (ver < 2) {
- swaps(&oldstuff->length);
- REQUEST_AT_LEAST_SIZE(xXF86OldVidModeValidateModeLineReq);
- swapl(&oldstuff->screen);
- swaps(&oldstuff->hdisplay);
- swaps(&oldstuff->hsyncstart);
- swaps(&oldstuff->hsyncend);
- swaps(&oldstuff->htotal);
- swaps(&oldstuff->vdisplay);
- swaps(&oldstuff->vsyncstart);
- swaps(&oldstuff->vsyncend);
- swaps(&oldstuff->vtotal);
- swapl(&oldstuff->flags);
- swapl(&oldstuff->privsize);
- SwapRestL(oldstuff);
- }
- else {
- swaps(&stuff->length);
- REQUEST_AT_LEAST_SIZE(xXF86VidModeValidateModeLineReq);
- swapl(&stuff->screen);
- swaps(&stuff->hdisplay);
- swaps(&stuff->hsyncstart);
- swaps(&stuff->hsyncend);
- swaps(&stuff->htotal);
- swaps(&stuff->hskew);
- swaps(&stuff->vdisplay);
- swaps(&stuff->vsyncstart);
- swaps(&stuff->vsyncend);
- swaps(&stuff->vtotal);
- swapl(&stuff->flags);
- swapl(&stuff->privsize);
- SwapRestL(stuff);
- }
- return ProcXF86VidModeValidateModeLine(client);
-}
-
-static int
-SProcXF86VidModeSwitchMode(ClientPtr client)
-{
- REQUEST(xXF86VidModeSwitchModeReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq);
- swaps(&stuff->screen);
- swaps(&stuff->zoom);
- return ProcXF86VidModeSwitchMode(client);
-}
-
-static int
-SProcXF86VidModeSwitchToMode(ClientPtr client)
-{
- REQUEST(xXF86VidModeSwitchToModeReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeSwitchToModeReq);
- swapl(&stuff->screen);
- return ProcXF86VidModeSwitchToMode(client);
-}
-
-static int
-SProcXF86VidModeLockModeSwitch(ClientPtr client)
-{
- REQUEST(xXF86VidModeLockModeSwitchReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
- swaps(&stuff->screen);
- swaps(&stuff->lock);
- return ProcXF86VidModeLockModeSwitch(client);
-}
-
-static int
-SProcXF86VidModeGetMonitor(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetMonitorReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq);
- swaps(&stuff->screen);
- return ProcXF86VidModeGetMonitor(client);
-}
-
-static int
-SProcXF86VidModeGetViewPort(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetViewPortReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq);
- swaps(&stuff->screen);
- return ProcXF86VidModeGetViewPort(client);
-}
-
-static int
-SProcXF86VidModeSetViewPort(ClientPtr client)
-{
- REQUEST(xXF86VidModeSetViewPortReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq);
- swaps(&stuff->screen);
- swapl(&stuff->x);
- swapl(&stuff->y);
- return ProcXF86VidModeSetViewPort(client);
-}
-
-static int
-SProcXF86VidModeGetDotClocks(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetDotClocksReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq);
- swaps(&stuff->screen);
- return ProcXF86VidModeGetDotClocks(client);
-}
-
-static int
-SProcXF86VidModeSetClientVersion(ClientPtr client)
-{
- REQUEST(xXF86VidModeSetClientVersionReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq);
- swaps(&stuff->major);
- swaps(&stuff->minor);
- return ProcXF86VidModeSetClientVersion(client);
-}
-
-static int
-SProcXF86VidModeSetGamma(ClientPtr client)
-{
- REQUEST(xXF86VidModeSetGammaReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq);
- swaps(&stuff->screen);
- swapl(&stuff->red);
- swapl(&stuff->green);
- swapl(&stuff->blue);
- return ProcXF86VidModeSetGamma(client);
-}
-
-static int
-SProcXF86VidModeGetGamma(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetGammaReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq);
- swaps(&stuff->screen);
- return ProcXF86VidModeGetGamma(client);
-}
-
-static int
-SProcXF86VidModeSetGammaRamp(ClientPtr client)
-{
- int length;
-
- REQUEST(xXF86VidModeSetGammaRampReq);
- swaps(&stuff->length);
- REQUEST_AT_LEAST_SIZE(xXF86VidModeSetGammaRampReq);
- swaps(&stuff->size);
- swaps(&stuff->screen);
- length = ((stuff->size + 1) & ~1) * 6;
- REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length);
- SwapRestS(stuff);
- return ProcXF86VidModeSetGammaRamp(client);
-}
-
-static int
-SProcXF86VidModeGetGammaRamp(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetGammaRampReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq);
- swaps(&stuff->size);
- swaps(&stuff->screen);
- return ProcXF86VidModeGetGammaRamp(client);
-}
-
-static int
-SProcXF86VidModeGetGammaRampSize(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetGammaRampSizeReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq);
- swaps(&stuff->screen);
- return ProcXF86VidModeGetGammaRampSize(client);
-}
-
-static int
-SProcXF86VidModeGetPermissions(ClientPtr client)
-{
- REQUEST(xXF86VidModeGetPermissionsReq);
- swaps(&stuff->length);
- REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq);
- swaps(&stuff->screen);
- return ProcXF86VidModeGetPermissions(client);
-}
-
-static int
-SProcXF86VidModeDispatch(ClientPtr client)
-{
- REQUEST(xReq);
- switch (stuff->data) {
- case X_XF86VidModeQueryVersion:
- return SProcXF86VidModeQueryVersion(client);
- case X_XF86VidModeGetModeLine:
- return SProcXF86VidModeGetModeLine(client);
- case X_XF86VidModeGetMonitor:
- return SProcXF86VidModeGetMonitor(client);
- case X_XF86VidModeGetAllModeLines:
- return SProcXF86VidModeGetAllModeLines(client);
- case X_XF86VidModeGetViewPort:
- return SProcXF86VidModeGetViewPort(client);
- case X_XF86VidModeValidateModeLine:
- return SProcXF86VidModeValidateModeLine(client);
- case X_XF86VidModeGetDotClocks:
- return SProcXF86VidModeGetDotClocks(client);
- case X_XF86VidModeSetClientVersion:
- return SProcXF86VidModeSetClientVersion(client);
- case X_XF86VidModeGetGamma:
- return SProcXF86VidModeGetGamma(client);
- case X_XF86VidModeGetGammaRamp:
- return SProcXF86VidModeGetGammaRamp(client);
- case X_XF86VidModeGetGammaRampSize:
- return SProcXF86VidModeGetGammaRampSize(client);
- case X_XF86VidModeGetPermissions:
- return SProcXF86VidModeGetPermissions(client);
- default:
- if (!xf86GetVidModeEnabled())
- return VidModeErrorBase + XF86VidModeExtensionDisabled;
- if (xf86GetVidModeAllowNonLocal() || client->local) {
- switch (stuff->data) {
- case X_XF86VidModeAddModeLine:
- return SProcXF86VidModeAddModeLine(client);
- case X_XF86VidModeDeleteModeLine:
- return SProcXF86VidModeDeleteModeLine(client);
- case X_XF86VidModeModModeLine:
- return SProcXF86VidModeModModeLine(client);
- case X_XF86VidModeSwitchMode:
- return SProcXF86VidModeSwitchMode(client);
- case X_XF86VidModeSwitchToMode:
- return SProcXF86VidModeSwitchToMode(client);
- case X_XF86VidModeLockModeSwitch:
- return SProcXF86VidModeLockModeSwitch(client);
- case X_XF86VidModeSetViewPort:
- return SProcXF86VidModeSetViewPort(client);
- case X_XF86VidModeSetGamma:
- return SProcXF86VidModeSetGamma(client);
- case X_XF86VidModeSetGammaRamp:
- return SProcXF86VidModeSetGammaRamp(client);
- default:
- return BadRequest;
- }
- }
- else
- return VidModeErrorBase + XF86VidModeClientNotLocal;
- }
-}
-
-void
-XFree86VidModeExtensionInit(void)
-{
- ExtensionEntry *extEntry;
- ScreenPtr pScreen;
- int i;
- Bool enabled = FALSE;
-
- DEBUG_P("XFree86VidModeExtensionInit");
-
- if (!dixRegisterPrivateKey(&VidModeClientPrivateKeyRec, PRIVATE_CLIENT, 0))
- return;
-
- for (i = 0; i < screenInfo.numScreens; i++) {
- pScreen = screenInfo.screens[i];
- if (xf86VidModeExtensionInit(pScreen))
- enabled = TRUE;
- }
- /* This means that the DDX doesn't want the vidmode extension enabled */
- if (!enabled)
- return;
-
- if ((extEntry = AddExtension(XF86VIDMODENAME,
- XF86VidModeNumberEvents,
- XF86VidModeNumberErrors,
- ProcXF86VidModeDispatch,
- SProcXF86VidModeDispatch,
- NULL, StandardMinorOpcode))) {
-#if 0
- XF86VidModeReqCode = (unsigned char) extEntry->base;
-#endif
- VidModeErrorBase = extEntry->errorBase;
- }
-}
diff --git a/include/Makefile.am b/include/Makefile.am
index 4c8ea6a..b9cf584 100644
--- a/include/Makefile.am
+++ b/include/Makefile.am
@@ -76,4 +76,5 @@ EXTRA_DIST = \
swaprep.h \
swapreq.h \
systemd-logind.h \
+ vidmodestr.h \
xsha1.h
diff --git a/include/vidmodestr.h b/include/vidmodestr.h
new file mode 100644
index 0000000..3a44185
--- /dev/null
+++ b/include/vidmodestr.h
@@ -0,0 +1,140 @@
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef _VIDMODEPROC_H_
+#define _VIDMODEPROC_H_
+
+#include "displaymode.h"
+
+typedef enum {
+ VIDMODE_H_DISPLAY,
+ VIDMODE_H_SYNCSTART,
+ VIDMODE_H_SYNCEND,
+ VIDMODE_H_TOTAL,
+ VIDMODE_H_SKEW,
+ VIDMODE_V_DISPLAY,
+ VIDMODE_V_SYNCSTART,
+ VIDMODE_V_SYNCEND,
+ VIDMODE_V_TOTAL,
+ VIDMODE_FLAGS,
+ VIDMODE_CLOCK
+} VidModeSelectMode;
+
+typedef enum {
+ VIDMODE_MON_VENDOR,
+ VIDMODE_MON_MODEL,
+ VIDMODE_MON_NHSYNC,
+ VIDMODE_MON_NVREFRESH,
+ VIDMODE_MON_HSYNC_LO,
+ VIDMODE_MON_HSYNC_HI,
+ VIDMODE_MON_VREFRESH_LO,
+ VIDMODE_MON_VREFRESH_HI
+} VidModeSelectMonitor;
+
+typedef union {
+ const void *ptr;
+ int i;
+ float f;
+} vidMonitorValue;
+
+typedef Bool (*VidModeExtensionInitProcPtr) (ScreenPtr pScreen);
+typedef vidMonitorValue (*VidModeGetMonitorValueProcPtr) (ScreenPtr pScreen,
+ int valtyp,
+ int indx);
+typedef Bool (*VidModeGetEnabledProcPtr) (void);
+typedef Bool (*VidModeGetAllowNonLocalProcPtr) (void);
+typedef Bool (*VidModeGetCurrentModelineProcPtr) (ScreenPtr pScreen,
+ DisplayModePtr *mode,
+ int *dotClock);
+typedef Bool (*VidModeGetFirstModelineProcPtr) (ScreenPtr pScreen,
+ DisplayModePtr *mode,
+ int *dotClock);
+typedef Bool (*VidModeGetNextModelineProcPtr) (ScreenPtr pScreen,
+ DisplayModePtr *mode,
+ int *dotClock);
+typedef Bool (*VidModeDeleteModelineProcPtr) (ScreenPtr pScreen,
+ DisplayModePtr mode);
+typedef Bool (*VidModeZoomViewportProcPtr) (ScreenPtr pScreen,
+ int zoom);
+typedef Bool (*VidModeGetViewPortProcPtr) (ScreenPtr pScreen,
+ int *x,
+ int *y);
+typedef Bool (*VidModeSetViewPortProcPtr) (ScreenPtr pScreen,
+ int x,
+ int y);
+typedef Bool (*VidModeSwitchModeProcPtr) (ScreenPtr pScreen,
+ DisplayModePtr mode);
+typedef Bool (*VidModeLockZoomProcPtr) (ScreenPtr pScreen,
+ Bool lock);
+typedef int (*VidModeGetNumOfClocksProcPtr) (ScreenPtr pScreen,
+ Bool *progClock);
+typedef Bool (*VidModeGetClocksProcPtr) (ScreenPtr pScreen,
+ int *Clocks);
+typedef ModeStatus (*VidModeCheckModeForMonitorProcPtr) (ScreenPtr pScreen,
+ DisplayModePtr mode);
+typedef ModeStatus (*VidModeCheckModeForDriverProcPtr) (ScreenPtr pScreen,
+ DisplayModePtr mode);
+typedef void (*VidModeSetCrtcForModeProcPtr) (ScreenPtr pScreen,
+ DisplayModePtr mode);
+typedef Bool (*VidModeAddModelineProcPtr) (ScreenPtr pScreen,
+ DisplayModePtr mode);
+typedef int (*VidModeGetDotClockProcPtr) (ScreenPtr pScreen,
+ int Clock);
+typedef int (*VidModeGetNumOfModesProcPtr) (ScreenPtr pScreen);
+typedef Bool (*VidModeSetGammaProcPtr) (ScreenPtr pScreen,
+ float red,
+ float green,
+ float blue);
+typedef Bool (*VidModeGetGammaProcPtr) (ScreenPtr pScreen,
+ float *red,
+ float *green,
+ float *blue);
+typedef Bool (*VidModeSetGammaRampProcPtr) (ScreenPtr pScreen,
+ int size,
+ CARD16 *red,
+ CARD16 *green,
+ CARD16 *blue);
+typedef Bool (*VidModeGetGammaRampProcPtr) (ScreenPtr pScreen,
+ int size,
+ CARD16 *red,
+ CARD16 *green,
+ CARD16 *blue);
+typedef int (*VidModeGetGammaRampSizeProcPtr) (ScreenPtr pScreen);
+
+typedef struct {
+ DisplayModePtr First;
+ DisplayModePtr Next;
+ int Flags;
+
+ VidModeExtensionInitProcPtr ExtensionInit;
+ VidModeGetMonitorValueProcPtr GetMonitorValue;
+ VidModeGetCurrentModelineProcPtr GetCurrentModeline;
+ VidModeGetFirstModelineProcPtr GetFirstModeline;
+ VidModeGetNextModelineProcPtr GetNextModeline;
+ VidModeDeleteModelineProcPtr DeleteModeline;
+ VidModeZoomViewportProcPtr ZoomViewport;
+ VidModeGetViewPortProcPtr GetViewPort;
+ VidModeSetViewPortProcPtr SetViewPort;
+ VidModeSwitchModeProcPtr SwitchMode;
+ VidModeLockZoomProcPtr LockZoom;
+ VidModeGetNumOfClocksProcPtr GetNumOfClocks;
+ VidModeGetClocksProcPtr GetClocks;
+ VidModeCheckModeForMonitorProcPtr CheckModeForMonitor;
+ VidModeCheckModeForDriverProcPtr CheckModeForDriver;
+ VidModeSetCrtcForModeProcPtr SetCrtcForMode;
+ VidModeAddModelineProcPtr AddModeline;
+ VidModeGetDotClockProcPtr GetDotClock;
+ VidModeGetNumOfModesProcPtr GetNumOfModes;
+ VidModeSetGammaProcPtr SetGamma;
+ VidModeGetGammaProcPtr GetGamma;
+ VidModeSetGammaRampProcPtr SetGammaRamp;
+ VidModeGetGammaRampProcPtr GetGammaRamp;
+ VidModeGetGammaRampSizeProcPtr GetGammaRampSize;
+} VidModeRec, *VidModePtr;
+
+void VidModeAddExtension(Bool allow_non_local);
+VidModePtr VidModeGetPtr(ScreenPtr pScreen);
+VidModePtr VidModeInit(ScreenPtr pScreen);
+
+#endif
diff --git a/test/Makefile.am b/test/Makefile.am
index d151b02..9f13e26 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -56,6 +56,7 @@ libxservertest_la_LIBADD += \
$(top_builddir)/hw/xfree86/ddc/libddc.la \
$(top_builddir)/hw/xfree86/i2c/libi2c.la \
$(top_builddir)/hw/xfree86/dixmods/libxorgxkb.la \
+ $(top_builddir)/Xext/libXvidmode.la \
@XORG_LIBS@
BUILT_SOURCES = sdksyms.c
@@ -91,6 +92,7 @@ libxservertest_la_LIBADD += \
$(top_builddir)/render/librender.la \
$(top_builddir)/Xext/libXext.la \
$(top_builddir)/Xext/libXextdpmsstubs.la \
+ $(top_builddir)/Xext/libXvidmode.la \
$(top_builddir)/Xi/libXi.la \
$(top_builddir)/Xi/libXistubs.la \
$(top_builddir)/xfixes/libxfixes.la \
commit 17097e083b2392c8989474f6e0da8cc234329e9c
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Fri Feb 5 09:48:22 2016 +0100
vidmode: rename DDX functions
To avoid confusion as to what belongs on the DDX and what not.
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/hw/xfree86/common/vidmodeproc.h b/hw/xfree86/common/vidmodeproc.h
index 3919a0c..4410253 100644
--- a/hw/xfree86/common/vidmodeproc.h
+++ b/hw/xfree86/common/vidmodeproc.h
@@ -39,40 +39,40 @@ typedef union {
float f;
} vidMonitorValue;
-extern Bool VidModeExtensionInit(ScreenPtr pScreen);
+extern Bool xf86VidModeExtensionInit(ScreenPtr pScreen);
-extern Bool VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode,
- int *dotClock);
-extern Bool VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode,
- int *dotClock);
-extern Bool VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode,
- int *dotClock);
-extern Bool VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode);
-extern Bool VidModeZoomViewport(ScreenPtr pScreen, int zoom);
-extern Bool VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y);
-extern Bool VidModeSetViewPort(ScreenPtr pScreen, int x, int y);
-extern Bool VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode);
-extern Bool VidModeLockZoom(ScreenPtr pScreen, Bool lock);
-extern int VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock);
-extern Bool VidModeGetClocks(ScreenPtr pScreen, int *Clocks);
-extern ModeStatus VidModeCheckModeForMonitor(ScreenPtr pScreen,
- DisplayModePtr mode);
-extern ModeStatus VidModeCheckModeForDriver(ScreenPtr pScreen,
- DisplayModePtr mode);
-extern void VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode);
-extern Bool VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode);
-extern int VidModeGetDotClock(ScreenPtr pScreen, int Clock);
-extern int VidModeGetNumOfModes(ScreenPtr pScreen);
-extern Bool VidModeSetGamma(ScreenPtr pScreen, float red, float green,
- float blue);
-extern Bool VidModeGetGamma(ScreenPtr pScreen, float *red, float *green,
- float *blue);
-extern vidMonitorValue VidModeGetMonitorValue(ScreenPtr pScreen,
- int valtyp, int indx);
-extern Bool VidModeSetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
- CARD16 *);
-extern Bool VidModeGetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
- CARD16 *);
-extern int VidModeGetGammaRampSize(ScreenPtr pScreen);
+extern Bool xf86VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode,
+ int *dotClock);
+extern Bool xf86VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode,
+ int *dotClock);
+extern Bool xf86VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode,
+ int *dotClock);
+extern Bool xf86VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode);
+extern Bool xf86VidModeZoomViewport(ScreenPtr pScreen, int zoom);
+extern Bool xf86VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y);
+extern Bool xf86VidModeSetViewPort(ScreenPtr pScreen, int x, int y);
+extern Bool xf86VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode);
+extern Bool xf86VidModeLockZoom(ScreenPtr pScreen, Bool lock);
+extern int xf86VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock);
+extern Bool xf86VidModeGetClocks(ScreenPtr pScreen, int *Clocks);
+extern ModeStatus xf86VidModeCheckModeForMonitor(ScreenPtr pScreen,
+ DisplayModePtr mode);
+extern ModeStatus xf86VidModeCheckModeForDriver(ScreenPtr pScreen,
+ DisplayModePtr mode);
+extern void xf86VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode);
+extern Bool xf86VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode);
+extern int xf86VidModeGetDotClock(ScreenPtr pScreen, int Clock);
+extern int xf86VidModeGetNumOfModes(ScreenPtr pScreen);
+extern Bool xf86VidModeSetGamma(ScreenPtr pScreen, float red, float green,
+ float blue);
+extern Bool xf86VidModeGetGamma(ScreenPtr pScreen, float *red, float *green,
+ float *blue);
+extern vidMonitorValue xf86VidModeGetMonitorValue(ScreenPtr pScreen,
+ int valtyp, int indx);
+extern Bool xf86VidModeSetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
+ CARD16 *);
+extern Bool xf86VidModeGetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
+ CARD16 *);
+extern int xf86VidModeGetGammaRampSize(ScreenPtr pScreen);
#endif
diff --git a/hw/xfree86/common/xf86VidMode.c b/hw/xfree86/common/xf86VidMode.c
index 2d87daa..5d04738 100644
--- a/hw/xfree86/common/xf86VidMode.c
+++ b/hw/xfree86/common/xf86VidMode.c
@@ -54,36 +54,10 @@ static DevPrivateKeyRec VidModeKeyRec;
#endif
-Bool
-VidModeExtensionInit(ScreenPtr pScreen)
-{
-#ifdef XF86VIDMODE
- VidModePtr pVidMode;
-
- if (!xf86GetVidModeEnabled()) {
- DebugF("!xf86GetVidModeEnabled()\n");
- return FALSE;
- }
-
- if (!dixRegisterPrivateKey(&VidModeKeyRec, PRIVATE_SCREEN, sizeof(VidModeRec)))
- return FALSE;
-
- pVidMode = VMPTR(pScreen);
-
- pVidMode->Flags = 0;
- pVidMode->Next = NULL;
-
- return TRUE;
-#else
- DebugF("no vidmode extension\n");
- return FALSE;
-#endif
-}
-
#ifdef XF86VIDMODE
static Bool
-VidModeAvailable(ScreenPtr pScreen)
+xf86VidModeAvailable(ScreenPtr pScreen)
{
if (pScreen == NULL) {
DebugF("pScreen == NULL\n");
@@ -98,12 +72,54 @@ VidModeAvailable(ScreenPtr pScreen)
}
}
+vidMonitorValue
+xf86VidModeGetMonitorValue(ScreenPtr pScreen, int valtyp, int indx)
+{
+ vidMonitorValue ret = { NULL, };
+ MonPtr monitor;
+ ScrnInfoPtr pScrn;
+
+ if (!xf86VidModeAvailable(pScreen))
+ return ret;
+
+ pScrn = xf86ScreenToScrn(pScreen);
+ monitor = pScrn->monitor;
+
+ switch (valtyp) {
+ case VIDMODE_MON_VENDOR:
+ ret.ptr = monitor->vendor;
+ break;
+ case VIDMODE_MON_MODEL:
+ ret.ptr = monitor->model;
+ break;
+ case VIDMODE_MON_NHSYNC:
+ ret.i = monitor->nHsync;
+ break;
+ case VIDMODE_MON_NVREFRESH:
+ ret.i = monitor->nVrefresh;
+ break;
+ case VIDMODE_MON_HSYNC_LO:
+ ret.f = (100.0 * monitor->hsync[indx].lo);
+ break;
+ case VIDMODE_MON_HSYNC_HI:
+ ret.f = (100.0 * monitor->hsync[indx].hi);
+ break;
+ case VIDMODE_MON_VREFRESH_LO:
+ ret.f = (100.0 * monitor->vrefresh[indx].lo);
+ break;
+ case VIDMODE_MON_VREFRESH_HI:
+ ret.f = (100.0 * monitor->vrefresh[indx].hi);
+ break;
+ }
+ return ret;
+}
+
Bool
-VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
+xf86VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
pScrn = xf86ScreenToScrn(pScreen);
@@ -118,11 +134,11 @@ VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock
}
int
-VidModeGetDotClock(ScreenPtr pScreen, int Clock)
+xf86VidModeGetDotClock(ScreenPtr pScreen, int Clock)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return 0;
pScrn = xf86ScreenToScrn(pScreen);
@@ -133,11 +149,11 @@ VidModeGetDotClock(ScreenPtr pScreen, int Clock)
}
int
-VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock)
+xf86VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return 0;
pScrn = xf86ScreenToScrn(pScreen);
@@ -152,12 +168,12 @@ VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock)
}
Bool
-VidModeGetClocks(ScreenPtr pScreen, int *Clocks)
+xf86VidModeGetClocks(ScreenPtr pScreen, int *Clocks)
{
ScrnInfoPtr pScrn;
int i;
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
pScrn = xf86ScreenToScrn(pScreen);
@@ -172,60 +188,60 @@ VidModeGetClocks(ScreenPtr pScreen, int *Clocks)
}
Bool
-VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
+xf86VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
{
- ScrnInfoPtr pScrn;
VidModePtr pVidMode;
+ DisplayModePtr p;
- if (!VidModeAvailable(pScreen))
- return FALSE;
-
- pScrn = xf86ScreenToScrn(pScreen);
- if (pScrn->modes == NULL)
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
pVidMode = VMPTR(pScreen);
- pVidMode->First = pScrn->modes;
- pVidMode->Next = pVidMode->First->next;
- if (pVidMode->First->status == MODE_OK) {
- *mode = pVidMode->First;
- *dotClock = VidModeGetDotClock(pScreen, pVidMode->First->Clock);
- return TRUE;
+ for (p = pVidMode->Next; p != NULL && p != pVidMode->First; p = p->next) {
+ if (p->status == MODE_OK) {
+ pVidMode->Next = p->next;
+ *mode = p;
+ *dotClock = xf86VidModeGetDotClock(pScreen, p->Clock);
+ return TRUE;
+ }
}
- return VidModeGetNextModeline(pScreen, mode, dotClock);
+ return FALSE;
}
Bool
-VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
+xf86VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
{
+ ScrnInfoPtr pScrn;
VidModePtr pVidMode;
- DisplayModePtr p;
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
+ return FALSE;
+
+ pScrn = xf86ScreenToScrn(pScreen);
+ if (pScrn->modes == NULL)
return FALSE;
pVidMode = VMPTR(pScreen);
+ pVidMode->First = pScrn->modes;
+ pVidMode->Next = pVidMode->First->next;
- for (p = pVidMode->Next; p != NULL && p != pVidMode->First; p = p->next) {
- if (p->status == MODE_OK) {
- pVidMode->Next = p->next;
- *mode = p;
- *dotClock = VidModeGetDotClock(pScreen, p->Clock);
- return TRUE;
- }
+ if (pVidMode->First->status == MODE_OK) {
+ *mode = pVidMode->First;
+ *dotClock = xf86VidModeGetDotClock(pScreen, pVidMode->First->Clock);
+ return TRUE;
}
- return FALSE;
+ return xf86VidModeGetNextModeline(pScreen, mode, dotClock);
}
Bool
-VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode)
+xf86VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!VidModeAvailable(pScreen)))
+ if ((mode == NULL) || (!xf86VidModeAvailable(pScreen)))
return FALSE;
pScrn = xf86ScreenToScrn(pScreen);
@@ -234,9 +250,9 @@ VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode)
}
Bool
-VidModeZoomViewport(ScreenPtr pScreen, int zoom)
+xf86VidModeZoomViewport(ScreenPtr pScreen, int zoom)
{
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
xf86ZoomViewport(pScreen, zoom);
@@ -244,11 +260,11 @@ VidModeZoomViewport(ScreenPtr pScreen, int zoom)
}
Bool
-VidModeSetViewPort(ScreenPtr pScreen, int x, int y)
+xf86VidModeSetViewPort(ScreenPtr pScreen, int x, int y)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
pScrn = xf86ScreenToScrn(pScreen);
@@ -265,11 +281,11 @@ VidModeSetViewPort(ScreenPtr pScreen, int x, int y)
}
Bool
-VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y)
+xf86VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
pScrn = xf86ScreenToScrn(pScreen);
@@ -279,13 +295,13 @@ VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y)
}
Bool
-VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
+xf86VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
DisplayModePtr pTmpMode;
Bool retval;
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
pScrn = xf86ScreenToScrn(pScreen);
@@ -301,9 +317,9 @@ VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
}
Bool
-VidModeLockZoom(ScreenPtr pScreen, Bool lock)
+xf86VidModeLockZoom(ScreenPtr pScreen, Bool lock)
{
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
if (xf86Info.dontZoom)
@@ -314,11 +330,11 @@ VidModeLockZoom(ScreenPtr pScreen, Bool lock)
}
ModeStatus
-VidModeCheckModeForMonitor(ScreenPtr pScreen, DisplayModePtr mode)
+xf86VidModeCheckModeForMonitor(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!VidModeAvailable(pScreen)))
+ if ((mode == NULL) || (!xf86VidModeAvailable(pScreen)))
return MODE_ERROR;
pScrn = xf86ScreenToScrn(pScreen);
@@ -327,11 +343,11 @@ VidModeCheckModeForMonitor(ScreenPtr pScreen, DisplayModePtr mode)
}
ModeStatus
-VidModeCheckModeForDriver(ScreenPtr pScreen, DisplayModePtr mode)
+xf86VidModeCheckModeForDriver(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!VidModeAvailable(pScreen)))
+ if ((mode == NULL) || (!xf86VidModeAvailable(pScreen)))
return MODE_ERROR;
pScrn = xf86ScreenToScrn(pScreen);
@@ -340,12 +356,12 @@ VidModeCheckModeForDriver(ScreenPtr pScreen, DisplayModePtr mode)
}
void
-VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode)
+xf86VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
DisplayModePtr ScreenModes;
- if ((mode == NULL) || (!VidModeAvailable(pScreen)))
+ if ((mode == NULL) || (!xf86VidModeAvailable(pScreen)))
return;
/* Ugly hack so that the xf86Mode.c function can be used without change */
@@ -359,11 +375,11 @@ VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode)
}
Bool
-VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode)
+xf86VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!VidModeAvailable(pScreen)))
+ if ((mode == NULL) || (!xf86VidModeAvailable(pScreen)))
return FALSE;
pScrn = xf86ScreenToScrn(pScreen);
@@ -380,27 +396,27 @@ VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode)
}
int
-VidModeGetNumOfModes(ScreenPtr pScreen)
+xf86VidModeGetNumOfModes(ScreenPtr pScreen)
{
DisplayModePtr mode = NULL;
int dotClock = 0, nummodes = 0;
- if (!VidModeGetFirstModeline(pScreen, &mode, &dotClock))
+ if (!xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock))
return nummodes;
do {
nummodes++;
- if (!VidModeGetNextModeline(pScreen, &mode, &dotClock))
+ if (!xf86VidModeGetNextModeline(pScreen, &mode, &dotClock))
return nummodes;
} while (TRUE);
}
Bool
-VidModeSetGamma(ScreenPtr pScreen, float red, float green, float blue)
+xf86VidModeSetGamma(ScreenPtr pScreen, float red, float green, float blue)
{
Gamma gamma;
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
gamma.red = red;
@@ -413,11 +429,11 @@ VidModeSetGamma(ScreenPtr pScreen, float red, float green, float blue)
}
Bool
-VidModeGetGamma(ScreenPtr pScreen, float *red, float *green, float *blue)
+xf86VidModeGetGamma(ScreenPtr pScreen, float *red, float *green, float *blue)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
pScrn = xf86ScreenToScrn(pScreen);
@@ -428,9 +444,9 @@ VidModeGetGamma(ScreenPtr pScreen, float *red, float *green, float *blue)
}
Bool
-VidModeSetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
+xf86VidModeSetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
{
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
xf86ChangeGammaRamp(pScreen, size, r, g, b);
@@ -438,9 +454,9 @@ VidModeSetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b
}
Bool
-VidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
+xf86VidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
{
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return FALSE;
xf86GetGammaRamp(pScreen, size, r, g, b);
@@ -448,54 +464,39 @@ VidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b
}
int
-VidModeGetGammaRampSize(ScreenPtr pScreen)
+xf86VidModeGetGammaRampSize(ScreenPtr pScreen)
{
- if (!VidModeAvailable(pScreen))
+ if (!xf86VidModeAvailable(pScreen))
return 0;
return xf86GetGammaRampSize(pScreen);
}
-vidMonitorValue
-VidModeGetMonitorValue(ScreenPtr pScreen, int valtyp, int indx)
+#endif /* XF86VIDMODE */
+
+Bool
+xf86VidModeExtensionInit(ScreenPtr pScreen)
{
- vidMonitorValue ret = { NULL, };
- MonPtr monitor;
- ScrnInfoPtr pScrn;
+#ifdef XF86VIDMODE
+ VidModePtr pVidMode;
- if (!VidModeAvailable(pScreen))
- return ret;
+ if (!xf86GetVidModeEnabled()) {
+ DebugF("!xf86GetVidModeEnabled()\n");
+ return FALSE;
+ }
- pScrn = xf86ScreenToScrn(pScreen);
- monitor = pScrn->monitor;
+ if (!dixRegisterPrivateKey(&VidModeKeyRec, PRIVATE_SCREEN, sizeof(VidModeRec)))
+ return FALSE;
- switch (valtyp) {
- case VIDMODE_MON_VENDOR:
- ret.ptr = monitor->vendor;
- break;
- case VIDMODE_MON_MODEL:
- ret.ptr = monitor->model;
- break;
- case VIDMODE_MON_NHSYNC:
- ret.i = monitor->nHsync;
- break;
- case VIDMODE_MON_NVREFRESH:
- ret.i = monitor->nVrefresh;
- break;
- case VIDMODE_MON_HSYNC_LO:
- ret.f = (100.0 * monitor->hsync[indx].lo);
- break;
- case VIDMODE_MON_HSYNC_HI:
- ret.f = (100.0 * monitor->hsync[indx].hi);
- break;
- case VIDMODE_MON_VREFRESH_LO:
- ret.f = (100.0 * monitor->vrefresh[indx].lo);
- break;
- case VIDMODE_MON_VREFRESH_HI:
- ret.f = (100.0 * monitor->vrefresh[indx].hi);
- break;
- }
- return ret;
+ pVidMode = VMPTR(pScreen);
+
+ pVidMode->Flags = 0;
+ pVidMode->Next = NULL;
+
+ return TRUE;
+#else
+ DebugF("no vidmode extension\n");
+ return FALSE;
+#endif
}
-#endif /* XF86VIDMODE */
diff --git a/hw/xfree86/common/xf86vmode.c b/hw/xfree86/common/xf86vmode.c
index 90216cc..0ad1b8d 100644
--- a/hw/xfree86/common/xf86vmode.c
+++ b/hw/xfree86/common/xf86vmode.c
@@ -251,7 +251,7 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
+ if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
return BadValue;
rep.dotclock = dotClock;
@@ -343,11 +343,11 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
pScreen = screenInfo.screens[stuff->screen];
ver = ClientMajorVersion(client);
- modecount = VidModeGetNumOfModes(pScreen);
+ modecount = xf86VidModeGetNumOfModes(pScreen);
if (modecount < 1)
return VidModeErrorBase + XF86VidModeExtensionDisabled;
- if (!VidModeGetFirstModeline(pScreen, &mode, &dotClock))
+ if (!xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock))
return BadValue;
rep = (xXF86VidModeGetAllModeLinesReply) {
@@ -418,7 +418,7 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
WriteToClient(client, sizeof(xXF86VidModeModeInfo), &mdinf);
}
- } while (VidModeGetNextModeline(pScreen, &mode, &dotClock));
+ } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
return Success;
}
@@ -536,14 +536,14 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
if (stuff->after_htotal != 0 || stuff->after_vtotal != 0) {
Bool found = FALSE;
- if (VidModeGetFirstModeline(pScreen, &mode, &dotClock)) {
+ if (xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock)) {
do {
- if ((VidModeGetDotClock(pScreen, stuff->dotclock)
+ if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock)
== dotClock) && MODEMATCH(mode, stuff)) {
found = TRUE;
break;
}
- } while (VidModeGetNextModeline(pScreen, &mode, &dotClock));
+ } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
}
if (!found)
return BadValue;
@@ -569,7 +569,7 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
ErrorF("AddModeLine - Privates in request have been ignored\n");
/* Check that the mode is consistent with the monitor specs */
- switch (VidModeCheckModeForMonitor(pScreen, mode)) {
+ switch (xf86VidModeCheckModeForMonitor(pScreen, mode)) {
case MODE_OK:
break;
case MODE_HSYNC:
@@ -586,14 +586,14 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
}
/* Check that the driver is happy with the mode */
- if (VidModeCheckModeForDriver(pScreen, mode) != MODE_OK) {
+ if (xf86VidModeCheckModeForDriver(pScreen, mode) != MODE_OK) {
free(mode);
return VidModeErrorBase + XF86VidModeModeUnsuitable;
}
- VidModeSetCrtcForMode(pScreen, mode);
+ xf86VidModeSetCrtcForMode(pScreen, mode);
- VidModeAddModeline(pScreen, mode);
+ xf86VidModeAddModeline(pScreen, mode);
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
ErrorF("AddModeLine - Succeeded\n");
@@ -672,7 +672,7 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
+ if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
return BadValue;
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
@@ -691,11 +691,11 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
VidModeGetModeValue(mode, VIDMODE_FLAGS));
}
- if ((VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
+ if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
MODEMATCH(mode, stuff))
return BadValue;
- if (!VidModeGetFirstModeline(pScreen, &mode, &dotClock))
+ if (!xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock))
return BadValue;
do {
@@ -715,14 +715,14 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
VidModeGetModeValue(mode, VIDMODE_FLAGS));
}
- if ((VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
+ if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
MODEMATCH(mode, stuff)) {
- VidModeDeleteModeline(pScreen, mode);
+ xf86VidModeDeleteModeline(pScreen, mode);
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
ErrorF("DeleteModeLine - Succeeded\n");
return Success;
}
- } while (VidModeGetNextModeline(pScreen, &mode, &dotClock));
+ } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
return BadValue;
}
@@ -794,7 +794,7 @@ ProcXF86VidModeModModeLine(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
+ if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
return BadValue;
modetmp = VidModeCreateMode();
@@ -815,7 +815,7 @@ ProcXF86VidModeModModeLine(ClientPtr client)
ErrorF("ModModeLine - Privates in request have been ignored\n");
/* Check that the mode is consistent with the monitor specs */
- switch (VidModeCheckModeForMonitor(pScreen, modetmp)) {
+ switch (xf86VidModeCheckModeForMonitor(pScreen, modetmp)) {
case MODE_OK:
break;
case MODE_HSYNC:
@@ -832,7 +832,7 @@ ProcXF86VidModeModModeLine(ClientPtr client)
}
/* Check that the driver is happy with the mode */
- if (VidModeCheckModeForDriver(pScreen, modetmp) != MODE_OK) {
+ if (xf86VidModeCheckModeForDriver(pScreen, modetmp) != MODE_OK) {
free(modetmp);
return VidModeErrorBase + XF86VidModeModeUnsuitable;
}
@@ -849,8 +849,8 @@ ProcXF86VidModeModModeLine(ClientPtr client)
VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal);
VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags);
- VidModeSetCrtcForMode(pScreen, mode);
- VidModeSwitchMode(pScreen, mode);
+ xf86VidModeSetCrtcForMode(pScreen, mode);
+ xf86VidModeSwitchMode(pScreen, mode);
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
ErrorF("ModModeLine - Succeeded\n");
@@ -933,7 +933,7 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
goto status_reply;
}
- if (!VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
+ if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
return BadValue;
modetmp = VidModeCreateMode();
@@ -954,11 +954,11 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
/* Check that the mode is consistent with the monitor specs */
if ((status =
- VidModeCheckModeForMonitor(pScreen, modetmp)) != MODE_OK)
+ xf86VidModeCheckModeForMonitor(pScreen, modetmp)) != MODE_OK)
goto status_reply;
/* Check that the driver is happy with the mode */
- status = VidModeCheckModeForDriver(pScreen, modetmp);
+ status = xf86VidModeCheckModeForDriver(pScreen, modetmp);
status_reply:
free(modetmp);
@@ -995,7 +995,7 @@ ProcXF86VidModeSwitchMode(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- VidModeZoomViewport(pScreen, (short) stuff->zoom);
+ xf86VidModeZoomViewport(pScreen, (short) stuff->zoom);
return Success;
}
@@ -1064,14 +1064,14 @@ ProcXF86VidModeSwitchToMode(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
+ if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
return BadValue;
- if ((VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock)
+ if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock)
&& MODEMATCH(mode, stuff))
return Success;
- if (!VidModeGetFirstModeline(pScreen, &mode, &dotClock))
+ if (!xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock))
return BadValue;
do {
@@ -1091,17 +1091,17 @@ ProcXF86VidModeSwitchToMode(ClientPtr client)
VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
VidModeGetModeValue(mode, VIDMODE_FLAGS));
}
- if ((VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
+ if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
MODEMATCH(mode, stuff)) {
- if (!VidModeSwitchMode(pScreen, mode))
+ if (!xf86VidModeSwitchMode(pScreen, mode))
return BadValue;
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
ErrorF("SwitchToMode - Succeeded\n");
return Success;
}
- } while (VidModeGetNextModeline(pScreen, &mode, &dotClock));
+ } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
return BadValue;
}
@@ -1120,7 +1120,7 @@ ProcXF86VidModeLockModeSwitch(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeLockZoom(pScreen, (short) stuff->lock))
+ if (!xf86VidModeLockZoom(pScreen, (short) stuff->lock))
return VidModeErrorBase + XF86VidModeZoomLocked;
return Success;
@@ -1146,19 +1146,19 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- nHsync = VidModeGetMonitorValue(pScreen, VIDMODE_MON_NHSYNC, 0).i;
- nVrefresh = VidModeGetMonitorValue(pScreen, VIDMODE_MON_NVREFRESH, 0).i;
+ nHsync = xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_NHSYNC, 0).i;
+ nVrefresh = xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_NVREFRESH, 0).i;
- if ((char *) (VidModeGetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr)
- rep.vendorLength = strlen((char *) (VidModeGetMonitorValue(pScreen,
- VIDMODE_MON_VENDOR,
- 0)).ptr);
+ if ((char *) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr)
+ rep.vendorLength = strlen((char *) (xf86VidModeGetMonitorValue(pScreen,
+ VIDMODE_MON_VENDOR,
+ 0)).ptr);
else
rep.vendorLength = 0;
- if ((char *) (VidModeGetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr)
- rep.modelLength = strlen((char *) (VidModeGetMonitorValue(pScreen,
- VIDMODE_MON_MODEL,
- 0)).ptr);
+ if ((char *) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr)
+ rep.modelLength = strlen((char *) (xf86VidModeGetMonitorValue(pScreen,
+ VIDMODE_MON_MODEL,
+ 0)).ptr);
else
rep.modelLength = 0;
rep.length =
@@ -1181,20 +1181,20 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
}
for (i = 0; i < nHsync; i++) {
- hsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(pScreen,
- VIDMODE_MON_HSYNC_LO,
- i)).f |
+ hsyncdata[i] = (unsigned short) (xf86VidModeGetMonitorValue(pScreen,
+ VIDMODE_MON_HSYNC_LO,
+ i)).f |
(unsigned
- short) (VidModeGetMonitorValue(pScreen, VIDMODE_MON_HSYNC_HI,
+ short) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_HSYNC_HI,
i)).f << 16;
}
for (i = 0; i < nVrefresh; i++) {
- vsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(pScreen,
- VIDMODE_MON_VREFRESH_LO,
- i)).f |
+ vsyncdata[i] = (unsigned short) (xf86VidModeGetMonitorValue(pScreen,
+ VIDMODE_MON_VREFRESH_LO,
+ i)).f |
(unsigned
- short) (VidModeGetMonitorValue(pScreen, VIDMODE_MON_VREFRESH_HI,
- i)).f << 16;
+ short) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_VREFRESH_HI,
+ i)).f << 16;
}
if (client->swapped) {
@@ -1207,10 +1207,10 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
WriteSwappedDataToClient(client, nVrefresh * sizeof(CARD32), vsyncdata);
if (rep.vendorLength)
WriteToClient(client, rep.vendorLength,
- (VidModeGetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr);
+ (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr);
if (rep.modelLength)
WriteToClient(client, rep.modelLength,
- (VidModeGetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr);
+ (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr);
free(hsyncdata);
free(vsyncdata);
@@ -1234,7 +1234,7 @@ ProcXF86VidModeGetViewPort(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- VidModeGetViewPort(pScreen, &x, &y);
+ xf86VidModeGetViewPort(pScreen, &x, &y);
rep = (xXF86VidModeGetViewPortReply) {
.type = X_Reply,
@@ -1268,7 +1268,7 @@ ProcXF86VidModeSetViewPort(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeSetViewPort(pScreen, stuff->x, stuff->y))
+ if (!xf86VidModeSetViewPort(pScreen, stuff->x, stuff->y))
return BadValue;
return Success;
@@ -1294,7 +1294,7 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- numClocks = VidModeGetNumOfClocks(pScreen, &ClockProg);
+ numClocks = xf86VidModeGetNumOfClocks(pScreen, &ClockProg);
rep = (xXF86VidModeGetDotClocksReply) {
.type = X_Reply,
@@ -1310,7 +1310,7 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
Clocks = calloc(numClocks, sizeof(int));
if (!Clocks)
return BadValue;
- if (!VidModeGetClocks(pScreen, Clocks)) {
+ if (!xf86VidModeGetClocks(pScreen, Clocks)) {
free(Clocks);
return BadValue;
}
@@ -1356,9 +1356,9 @@ ProcXF86VidModeSetGamma(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeSetGamma(pScreen, ((float) stuff->red) / 10000.,
- ((float) stuff->green) / 10000.,
- ((float) stuff->blue) / 10000.))
+ if (!xf86VidModeSetGamma(pScreen, ((float) stuff->red) / 10000.,
+ ((float) stuff->green) / 10000.,
+ ((float) stuff->blue) / 10000.))
return BadValue;
return Success;
@@ -1380,7 +1380,7 @@ ProcXF86VidModeGetGamma(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetGamma(pScreen, &red, &green, &blue))
+ if (!xf86VidModeGetGamma(pScreen, &red, &green, &blue))
return BadValue;
rep = (xXF86VidModeGetGammaReply) {
.type = X_Reply,
@@ -1415,7 +1415,7 @@ ProcXF86VidModeSetGammaRamp(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- if (stuff->size != VidModeGetGammaRampSize(pScreen))
+ if (stuff->size != xf86VidModeGetGammaRampSize(pScreen))
return BadValue;
length = (stuff->size + 1) & ~1;
@@ -1426,7 +1426,7 @@ ProcXF86VidModeSetGammaRamp(ClientPtr client)
g = r + length;
b = g + length;
- if (!VidModeSetGammaRamp(pScreen, stuff->size, r, g, b))
+ if (!xf86VidModeSetGammaRamp(pScreen, stuff->size, r, g, b))
return BadValue;
return Success;
@@ -1449,7 +1449,7 @@ ProcXF86VidModeGetGammaRamp(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- if (stuff->size != VidModeGetGammaRampSize(pScreen))
+ if (stuff->size != xf86VidModeGetGammaRampSize(pScreen))
return BadValue;
length = (stuff->size + 1) & ~1;
@@ -1459,8 +1459,8 @@ ProcXF86VidModeGetGammaRamp(ClientPtr client)
return BadAlloc;
ramplen = length * 3 * sizeof(CARD16);
- if (!VidModeGetGammaRamp(pScreen, stuff->size,
- ramp, ramp + length, ramp + (length * 2))) {
+ if (!xf86VidModeGetGammaRamp(pScreen, stuff->size,
+ ramp, ramp + length, ramp + (length * 2))) {
free(ramp);
return BadValue;
}
@@ -1505,7 +1505,7 @@ ProcXF86VidModeGetGammaRampSize(ClientPtr client)
.type = X_Reply,
.sequenceNumber = client->sequence,
.length = 0,
- .size = VidModeGetGammaRampSize(pScreen)
+ .size = xf86VidModeGetGammaRampSize(pScreen)
};
if (client->swapped) {
swaps(&rep.sequenceNumber);
@@ -2072,7 +2072,7 @@ XFree86VidModeExtensionInit(void)
for (i = 0; i < screenInfo.numScreens; i++) {
pScreen = screenInfo.screens[i];
- if (VidModeExtensionInit(pScreen))
+ if (xf86VidModeExtensionInit(pScreen))
enabled = TRUE;
}
/* This means that the DDX doesn't want the vidmode extension enabled */
commit ddfb8c009ac651209eb0087aaf86b54e1446e8b2
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Fri Feb 5 09:48:21 2016 +0100
vidmode: move display mode definitions
To be able to reuse the VidMode extension in a non-hardware server, the
display mode definitions need to be accessible from DIX.
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/hw/xfree86/common/xf86str.h b/hw/xfree86/common/xf86str.h
index a58fafe..5e6e977 100644
--- a/hw/xfree86/common/xf86str.h
+++ b/hw/xfree86/common/xf86str.h
@@ -41,6 +41,7 @@
#include "colormapst.h"
#include "xf86Module.h"
#include "xf86Opt.h"
+#include "displaymode.h"
/**
* Integer type that is of the size of the addressable memory (machine size).
@@ -84,48 +85,6 @@ typedef enum {
MODECHECK_FINAL = 1
} ModeCheckFlags;
-/* These are possible return values for xf86CheckMode() and ValidMode() */
-typedef enum {
- MODE_OK = 0, /* Mode OK */
- MODE_HSYNC, /* hsync out of range */
- MODE_VSYNC, /* vsync out of range */
- MODE_H_ILLEGAL, /* mode has illegal horizontal timings */
- MODE_V_ILLEGAL, /* mode has illegal horizontal timings */
- MODE_BAD_WIDTH, /* requires an unsupported linepitch */
- MODE_NOMODE, /* no mode with a maching name */
- MODE_NO_INTERLACE, /* interlaced mode not supported */
- MODE_NO_DBLESCAN, /* doublescan mode not supported */
- MODE_NO_VSCAN, /* multiscan mode not supported */
- MODE_MEM, /* insufficient video memory */
- MODE_VIRTUAL_X, /* mode width too large for specified virtual size */
- MODE_VIRTUAL_Y, /* mode height too large for specified virtual size */
- MODE_MEM_VIRT, /* insufficient video memory given virtual size */
- MODE_NOCLOCK, /* no fixed clock available */
- MODE_CLOCK_HIGH, /* clock required is too high */
- MODE_CLOCK_LOW, /* clock required is too low */
- MODE_CLOCK_RANGE, /* clock/mode isn't in a ClockRange */
- MODE_BAD_HVALUE, /* horizontal timing was out of range */
- MODE_BAD_VVALUE, /* vertical timing was out of range */
- MODE_BAD_VSCAN, /* VScan value out of range */
- MODE_HSYNC_NARROW, /* horizontal sync too narrow */
- MODE_HSYNC_WIDE, /* horizontal sync too wide */
- MODE_HBLANK_NARROW, /* horizontal blanking too narrow */
- MODE_HBLANK_WIDE, /* horizontal blanking too wide */
- MODE_VSYNC_NARROW, /* vertical sync too narrow */
- MODE_VSYNC_WIDE, /* vertical sync too wide */
- MODE_VBLANK_NARROW, /* vertical blanking too narrow */
- MODE_VBLANK_WIDE, /* vertical blanking too wide */
- MODE_PANEL, /* exceeds panel dimensions */
- MODE_INTERLACE_WIDTH, /* width too large for interlaced mode */
- MODE_ONE_WIDTH, /* only one width is supported */
- MODE_ONE_HEIGHT, /* only one height is supported */
- MODE_ONE_SIZE, /* only one resolution is supported */
- MODE_NO_REDUCED, /* monitor doesn't accept reduced blanking */
- MODE_BANDWIDTH, /* mode requires too much memory bandwidth */
- MODE_BAD = -2, /* unspecified reason */
- MODE_ERROR = -1 /* error condition */
-} ModeStatus;
-
/*
* The mode sets are, from best to worst: USERDEF, DRIVER, and DEFAULT/BUILTIN.
* Preferred will bubble a mode to the top within a set.
@@ -141,54 +100,6 @@ typedef enum {
#define M_T_DRIVER 0x40 /* Supplied by the driver (EDID, etc) */
#define M_T_USERPREF 0x80 /* mode preferred by the user config */
-/* Video mode */
-typedef struct _DisplayModeRec {
- struct _DisplayModeRec *prev;
- struct _DisplayModeRec *next;
- const char *name; /* identifier for the mode */
- ModeStatus status;
- int type;
-
- /* These are the values that the user sees/provides */
- int Clock; /* pixel clock freq (kHz) */
- int HDisplay; /* horizontal timing */
- int HSyncStart;
- int HSyncEnd;
- int HTotal;
- int HSkew;
- int VDisplay; /* vertical timing */
- int VSyncStart;
- int VSyncEnd;
- int VTotal;
- int VScan;
- int Flags;
-
- /* These are the values the hardware uses */
- int ClockIndex;
- int SynthClock; /* Actual clock freq to
- * be programmed (kHz) */
- int CrtcHDisplay;
- int CrtcHBlankStart;
- int CrtcHSyncStart;
- int CrtcHSyncEnd;
- int CrtcHBlankEnd;
- int CrtcHTotal;
- int CrtcHSkew;
- int CrtcVDisplay;
- int CrtcVBlankStart;
- int CrtcVSyncStart;
- int CrtcVSyncEnd;
- int CrtcVBlankEnd;
- int CrtcVTotal;
- Bool CrtcHAdjusted;
- Bool CrtcVAdjusted;
- int PrivSize;
- INT32 *Private;
- int PrivFlags;
-
- float HSync, VRefresh;
-} DisplayModeRec, *DisplayModePtr;
-
/* The monitor description */
#define MAX_HSYNC 8
@@ -377,7 +288,6 @@ typedef struct _bus {
} id;
} BusRec, *BusPtr;
-#define MAXCLOCKS 128
typedef enum {
DAC_BPP8 = 0,
DAC_BPP16,
diff --git a/include/Makefile.am b/include/Makefile.am
index 70b83ff..4c8ea6a 100644
--- a/include/Makefile.am
+++ b/include/Makefile.am
@@ -53,6 +53,7 @@ sdk_HEADERS = \
servermd.h \
site.h \
validate.h \
+ displaymode.h \
window.h \
windowstr.h \
xkbfile.h \
diff --git a/include/displaymode.h b/include/displaymode.h
new file mode 100644
index 0000000..ad01b87
--- /dev/null
+++ b/include/displaymode.h
@@ -0,0 +1,102 @@
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef _DISMODEPROC_H_
+#define _DISMODEPROC_H_
+
+#include "scrnintstr.h"
+
+#define MAXCLOCKS 128
+
+/* These are possible return values for xf86CheckMode() and ValidMode() */
+typedef enum {
+ MODE_OK = 0, /* Mode OK */
+ MODE_HSYNC, /* hsync out of range */
+ MODE_VSYNC, /* vsync out of range */
+ MODE_H_ILLEGAL, /* mode has illegal horizontal timings */
+ MODE_V_ILLEGAL, /* mode has illegal horizontal timings */
+ MODE_BAD_WIDTH, /* requires an unsupported linepitch */
+ MODE_NOMODE, /* no mode with a matching name */
+ MODE_NO_INTERLACE, /* interlaced mode not supported */
+ MODE_NO_DBLESCAN, /* doublescan mode not supported */
+ MODE_NO_VSCAN, /* multiscan mode not supported */
+ MODE_MEM, /* insufficient video memory */
+ MODE_VIRTUAL_X, /* mode width too large for specified virtual size */
+ MODE_VIRTUAL_Y, /* mode height too large for specified virtual size */
+ MODE_MEM_VIRT, /* insufficient video memory given virtual size */
+ MODE_NOCLOCK, /* no fixed clock available */
+ MODE_CLOCK_HIGH, /* clock required is too high */
+ MODE_CLOCK_LOW, /* clock required is too low */
+ MODE_CLOCK_RANGE, /* clock/mode isn't in a ClockRange */
+ MODE_BAD_HVALUE, /* horizontal timing was out of range */
+ MODE_BAD_VVALUE, /* vertical timing was out of range */
+ MODE_BAD_VSCAN, /* VScan value out of range */
+ MODE_HSYNC_NARROW, /* horizontal sync too narrow */
+ MODE_HSYNC_WIDE, /* horizontal sync too wide */
+ MODE_HBLANK_NARROW, /* horizontal blanking too narrow */
+ MODE_HBLANK_WIDE, /* horizontal blanking too wide */
+ MODE_VSYNC_NARROW, /* vertical sync too narrow */
+ MODE_VSYNC_WIDE, /* vertical sync too wide */
+ MODE_VBLANK_NARROW, /* vertical blanking too narrow */
+ MODE_VBLANK_WIDE, /* vertical blanking too wide */
+ MODE_PANEL, /* exceeds panel dimensions */
+ MODE_INTERLACE_WIDTH, /* width too large for interlaced mode */
+ MODE_ONE_WIDTH, /* only one width is supported */
+ MODE_ONE_HEIGHT, /* only one height is supported */
+ MODE_ONE_SIZE, /* only one resolution is supported */
+ MODE_NO_REDUCED, /* monitor doesn't accept reduced blanking */
+ MODE_BANDWIDTH, /* mode requires too much memory bandwidth */
+ MODE_BAD = -2, /* unspecified reason */
+ MODE_ERROR = -1 /* error condition */
+} ModeStatus;
+
+/* Video mode */
+typedef struct _DisplayModeRec {
+ struct _DisplayModeRec *prev;
+ struct _DisplayModeRec *next;
+ const char *name; /* identifier for the mode */
+ ModeStatus status;
+ int type;
+
+ /* These are the values that the user sees/provides */
+ int Clock; /* pixel clock freq (kHz) */
+ int HDisplay; /* horizontal timing */
+ int HSyncStart;
+ int HSyncEnd;
+ int HTotal;
+ int HSkew;
+ int VDisplay; /* vertical timing */
+ int VSyncStart;
+ int VSyncEnd;
+ int VTotal;
+ int VScan;
+ int Flags;
+
+ /* These are the values the hardware uses */
+ int ClockIndex;
+ int SynthClock; /* Actual clock freq to
+ * be programmed (kHz) */
+ int CrtcHDisplay;
+ int CrtcHBlankStart;
+ int CrtcHSyncStart;
+ int CrtcHSyncEnd;
+ int CrtcHBlankEnd;
+ int CrtcHTotal;
+ int CrtcHSkew;
+ int CrtcVDisplay;
+ int CrtcVBlankStart;
+ int CrtcVSyncStart;
+ int CrtcVSyncEnd;
+ int CrtcVBlankEnd;
+ int CrtcVTotal;
+ Bool CrtcHAdjusted;
+ Bool CrtcVAdjusted;
+ int PrivSize;
+ INT32 *Private;
+ int PrivFlags;
+
+ float HSync, VRefresh;
+} DisplayModeRec, *DisplayModePtr;
+
+#endif
commit e29a64de662112b8ebcd3f20c89df0e8c51890ef
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Fri Feb 5 09:48:20 2016 +0100
vidmode: remove mode access from public API
The mode access functions (namely VidModeCreateMode(),
VidModeCopyMode(), VidModeGetModeValue() and VidModeSetModeValue()) are
used only in xf86VidMode code and do not need to be available anywhere
else.
Remove these functions from the public VidMode API and move them as
static where they are used.
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/hw/xfree86/common/vidmodeproc.h b/hw/xfree86/common/vidmodeproc.h
index 3cc8fc1..3919a0c 100644
--- a/hw/xfree86/common/vidmodeproc.h
+++ b/hw/xfree86/common/vidmodeproc.h
@@ -67,10 +67,6 @@ extern Bool VidModeSetGamma(ScreenPtr pScreen, float red, float green,
float blue);
extern Bool VidModeGetGamma(ScreenPtr pScreen, float *red, float *green,
float *blue);
-extern DisplayModePtr VidModeCreateMode(void);
-extern void VidModeCopyMode(DisplayModePtr modefrom, DisplayModePtr modeto);
-extern int VidModeGetModeValue(DisplayModePtr mode, int valtyp);
-extern void VidModeSetModeValue(DisplayModePtr mode, int valtyp, int val);
extern vidMonitorValue VidModeGetMonitorValue(ScreenPtr pScreen,
int valtyp, int indx);
extern Bool VidModeSetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
diff --git a/hw/xfree86/common/xf86VidMode.c b/hw/xfree86/common/xf86VidMode.c
index 5f596b5..2d87daa 100644
--- a/hw/xfree86/common/xf86VidMode.c
+++ b/hw/xfree86/common/xf86VidMode.c
@@ -456,112 +456,6 @@ VidModeGetGammaRampSize(ScreenPtr pScreen)
return xf86GetGammaRampSize(pScreen);
}
-DisplayModePtr
-VidModeCreateMode(void)
-{
- DisplayModePtr mode;
-
- mode = malloc(sizeof(DisplayModeRec));
- if (mode != NULL) {
- mode->name = "";
- mode->VScan = 1; /* divides refresh rate. default = 1 */
- mode->Private = NULL;
- mode->next = mode;
- mode->prev = mode;
- }
- return mode;
-}
-
-void
-VidModeCopyMode(DisplayModePtr modefrom, DisplayModePtr modeto)
-{
- memcpy(modeto, modefrom, sizeof(DisplayModeRec));
-}
-
-int
-VidModeGetModeValue(DisplayModePtr mode, int valtyp)
-{
- int ret = 0;
-
- switch (valtyp) {
- case VIDMODE_H_DISPLAY:
- ret = mode->HDisplay;
- break;
- case VIDMODE_H_SYNCSTART:
- ret = mode->HSyncStart;
- break;
- case VIDMODE_H_SYNCEND:
- ret = mode->HSyncEnd;
- break;
- case VIDMODE_H_TOTAL:
- ret = mode->HTotal;
- break;
- case VIDMODE_H_SKEW:
- ret = mode->HSkew;
- break;
- case VIDMODE_V_DISPLAY:
- ret = mode->VDisplay;
- break;
- case VIDMODE_V_SYNCSTART:
- ret = mode->VSyncStart;
- break;
- case VIDMODE_V_SYNCEND:
- ret = mode->VSyncEnd;
- break;
- case VIDMODE_V_TOTAL:
- ret = mode->VTotal;
- break;
- case VIDMODE_FLAGS:
- ret = mode->Flags;
- break;
- case VIDMODE_CLOCK:
- ret = mode->Clock;
- break;
- }
- return ret;
-}
-
-void
-VidModeSetModeValue(DisplayModePtr mode, int valtyp, int val)
-{
- switch (valtyp) {
- case VIDMODE_H_DISPLAY:
- mode->HDisplay = val;
- break;
- case VIDMODE_H_SYNCSTART:
- mode->HSyncStart = val;
- break;
- case VIDMODE_H_SYNCEND:
- mode->HSyncEnd = val;
- break;
- case VIDMODE_H_TOTAL:
- mode->HTotal = val;
- break;
- case VIDMODE_H_SKEW:
- mode->HSkew = val;
- break;
- case VIDMODE_V_DISPLAY:
- mode->VDisplay = val;
- break;
- case VIDMODE_V_SYNCSTART:
- mode->VSyncStart = val;
- break;
- case VIDMODE_V_SYNCEND:
- mode->VSyncEnd = val;
- break;
- case VIDMODE_V_TOTAL:
- mode->VTotal = val;
- break;
- case VIDMODE_FLAGS:
- mode->Flags = val;
- break;
- case VIDMODE_CLOCK:
- mode->Clock = val;
- break;
- }
- return;
-}
-
vidMonitorValue
VidModeGetMonitorValue(ScreenPtr pScreen, int valtyp, int indx)
{
diff --git a/hw/xfree86/common/xf86vmode.c b/hw/xfree86/common/xf86vmode.c
index b74ec6e..90216cc 100644
--- a/hw/xfree86/common/xf86vmode.c
+++ b/hw/xfree86/common/xf86vmode.c
@@ -76,7 +76,114 @@ static unsigned char XF86VidModeReqCode = 0;
#else
#define DEBUG_P(x) /**/
#endif
- static int
+
+static DisplayModePtr
+VidModeCreateMode(void)
+{
+ DisplayModePtr mode;
+
+ mode = malloc(sizeof(DisplayModeRec));
+ if (mode != NULL) {
+ mode->name = "";
+ mode->VScan = 1; /* divides refresh rate. default = 1 */
+ mode->Private = NULL;
+ mode->next = mode;
+ mode->prev = mode;
+ }
+ return mode;
+}
+
+static void
+VidModeCopyMode(DisplayModePtr modefrom, DisplayModePtr modeto)
+{
+ memcpy(modeto, modefrom, sizeof(DisplayModeRec));
+}
+
+static int
+VidModeGetModeValue(DisplayModePtr mode, int valtyp)
+{
+ int ret = 0;
+
+ switch (valtyp) {
+ case VIDMODE_H_DISPLAY:
+ ret = mode->HDisplay;
+ break;
+ case VIDMODE_H_SYNCSTART:
+ ret = mode->HSyncStart;
+ break;
+ case VIDMODE_H_SYNCEND:
+ ret = mode->HSyncEnd;
+ break;
+ case VIDMODE_H_TOTAL:
+ ret = mode->HTotal;
+ break;
+ case VIDMODE_H_SKEW:
+ ret = mode->HSkew;
+ break;
+ case VIDMODE_V_DISPLAY:
+ ret = mode->VDisplay;
+ break;
+ case VIDMODE_V_SYNCSTART:
+ ret = mode->VSyncStart;
+ break;
+ case VIDMODE_V_SYNCEND:
+ ret = mode->VSyncEnd;
+ break;
+ case VIDMODE_V_TOTAL:
+ ret = mode->VTotal;
+ break;
+ case VIDMODE_FLAGS:
+ ret = mode->Flags;
+ break;
+ case VIDMODE_CLOCK:
+ ret = mode->Clock;
+ break;
+ }
+ return ret;
+}
+
+static void
+VidModeSetModeValue(DisplayModePtr mode, int valtyp, int val)
+{
+ switch (valtyp) {
+ case VIDMODE_H_DISPLAY:
+ mode->HDisplay = val;
+ break;
+ case VIDMODE_H_SYNCSTART:
+ mode->HSyncStart = val;
+ break;
+ case VIDMODE_H_SYNCEND:
+ mode->HSyncEnd = val;
+ break;
+ case VIDMODE_H_TOTAL:
+ mode->HTotal = val;
+ break;
+ case VIDMODE_H_SKEW:
+ mode->HSkew = val;
+ break;
+ case VIDMODE_V_DISPLAY:
+ mode->VDisplay = val;
+ break;
+ case VIDMODE_V_SYNCSTART:
+ mode->VSyncStart = val;
+ break;
+ case VIDMODE_V_SYNCEND:
+ mode->VSyncEnd = val;
+ break;
+ case VIDMODE_V_TOTAL:
+ mode->VTotal = val;
+ break;
+ case VIDMODE_FLAGS:
+ mode->Flags = val;
+ break;
+ case VIDMODE_CLOCK:
+ mode->Clock = val;
+ break;
+ }
+ return;
+}
+
+static int
ClientMajorVersion(ClientPtr client)
{
VidModePrivPtr pPriv;
commit b7962ade5265a21ac7c60da6cc07ece15ef7e648
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Fri Feb 5 09:48:19 2016 +0100
vidmode: use appropriate DisplayModePtr type
The API uses an untyped pointer (void *) where a DisplayModePtr is
expected.
Clean up the API to use the appropriate type, as DisplayModePtr is
really all that will be passed there.
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/hw/xfree86/common/vidmodeproc.h b/hw/xfree86/common/vidmodeproc.h
index 792be9b..3cc8fc1 100644
--- a/hw/xfree86/common/vidmodeproc.h
+++ b/hw/xfree86/common/vidmodeproc.h
@@ -41,36 +41,36 @@ typedef union {
extern Bool VidModeExtensionInit(ScreenPtr pScreen);
-extern Bool VidModeGetCurrentModeline(ScreenPtr pScreen, void **mode,
+extern Bool VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode,
int *dotClock);
-extern Bool VidModeGetFirstModeline(ScreenPtr pScreen, void **mode,
+extern Bool VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode,
int *dotClock);
-extern Bool VidModeGetNextModeline(ScreenPtr pScreen, void **mode,
+extern Bool VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode,
int *dotClock);
-extern Bool VidModeDeleteModeline(ScreenPtr pScreen, void *mode);
+extern Bool VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode);
extern Bool VidModeZoomViewport(ScreenPtr pScreen, int zoom);
extern Bool VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y);
extern Bool VidModeSetViewPort(ScreenPtr pScreen, int x, int y);
-extern Bool VidModeSwitchMode(ScreenPtr pScreen, void *mode);
+extern Bool VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode);
extern Bool VidModeLockZoom(ScreenPtr pScreen, Bool lock);
extern int VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock);
extern Bool VidModeGetClocks(ScreenPtr pScreen, int *Clocks);
extern ModeStatus VidModeCheckModeForMonitor(ScreenPtr pScreen,
- void *mode);
+ DisplayModePtr mode);
extern ModeStatus VidModeCheckModeForDriver(ScreenPtr pScreen,
- void *mode);
-extern void VidModeSetCrtcForMode(ScreenPtr pScreen, void *mode);
-extern Bool VidModeAddModeline(ScreenPtr pScreen, void *mode);
+ DisplayModePtr mode);
+extern void VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode);
+extern Bool VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode);
extern int VidModeGetDotClock(ScreenPtr pScreen, int Clock);
extern int VidModeGetNumOfModes(ScreenPtr pScreen);
extern Bool VidModeSetGamma(ScreenPtr pScreen, float red, float green,
float blue);
extern Bool VidModeGetGamma(ScreenPtr pScreen, float *red, float *green,
float *blue);
-extern void *VidModeCreateMode(void);
-extern void VidModeCopyMode(void *modefrom, void *modeto);
-extern int VidModeGetModeValue(void *mode, int valtyp);
-extern void VidModeSetModeValue(void *mode, int valtyp, int val);
+extern DisplayModePtr VidModeCreateMode(void);
+extern void VidModeCopyMode(DisplayModePtr modefrom, DisplayModePtr modeto);
+extern int VidModeGetModeValue(DisplayModePtr mode, int valtyp);
+extern void VidModeSetModeValue(DisplayModePtr mode, int valtyp, int val);
extern vidMonitorValue VidModeGetMonitorValue(ScreenPtr pScreen,
int valtyp, int indx);
extern Bool VidModeSetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
diff --git a/hw/xfree86/common/xf86VidMode.c b/hw/xfree86/common/xf86VidMode.c
index 9182d93..5f596b5 100644
--- a/hw/xfree86/common/xf86VidMode.c
+++ b/hw/xfree86/common/xf86VidMode.c
@@ -99,7 +99,7 @@ VidModeAvailable(ScreenPtr pScreen)
}
Bool
-VidModeGetCurrentModeline(ScreenPtr pScreen, void **mode, int *dotClock)
+VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
{
ScrnInfoPtr pScrn;
@@ -109,7 +109,7 @@ VidModeGetCurrentModeline(ScreenPtr pScreen, void **mode, int *dotClock)
pScrn = xf86ScreenToScrn(pScreen);
if (pScrn->currentMode) {
- *mode = (void *) (pScrn->currentMode);
+ *mode = pScrn->currentMode;
*dotClock = pScrn->currentMode->Clock;
return TRUE;
@@ -172,7 +172,7 @@ VidModeGetClocks(ScreenPtr pScreen, int *Clocks)
}
Bool
-VidModeGetFirstModeline(ScreenPtr pScreen, void **mode, int *dotClock)
+VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
{
ScrnInfoPtr pScrn;
VidModePtr pVidMode;
@@ -189,7 +189,7 @@ VidModeGetFirstModeline(ScreenPtr pScreen, void **mode, int *dotClock)
pVidMode->Next = pVidMode->First->next;
if (pVidMode->First->status == MODE_OK) {
- *mode = (void *) (pVidMode->First);
+ *mode = pVidMode->First;
*dotClock = VidModeGetDotClock(pScreen, pVidMode->First->Clock);
return TRUE;
}
@@ -198,7 +198,7 @@ VidModeGetFirstModeline(ScreenPtr pScreen, void **mode, int *dotClock)
}
Bool
-VidModeGetNextModeline(ScreenPtr pScreen, void **mode, int *dotClock)
+VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
{
VidModePtr pVidMode;
DisplayModePtr p;
@@ -211,7 +211,7 @@ VidModeGetNextModeline(ScreenPtr pScreen, void **mode, int *dotClock)
for (p = pVidMode->Next; p != NULL && p != pVidMode->First; p = p->next) {
if (p->status == MODE_OK) {
pVidMode->Next = p->next;
- *mode = (void *) p;
+ *mode = p;
*dotClock = VidModeGetDotClock(pScreen, p->Clock);
return TRUE;
}
@@ -221,7 +221,7 @@ VidModeGetNextModeline(ScreenPtr pScreen, void **mode, int *dotClock)
}
Bool
-VidModeDeleteModeline(ScreenPtr pScreen, void *mode)
+VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
@@ -229,7 +229,7 @@ VidModeDeleteModeline(ScreenPtr pScreen, void *mode)
return FALSE;
pScrn = xf86ScreenToScrn(pScreen);
- xf86DeleteMode(&(pScrn->modes), (DisplayModePtr) mode);
+ xf86DeleteMode(&(pScrn->modes), mode);
return TRUE;
}
@@ -279,7 +279,7 @@ VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y)
}
Bool
-VidModeSwitchMode(ScreenPtr pScreen, void *mode)
+VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
DisplayModePtr pTmpMode;
@@ -314,7 +314,7 @@ VidModeLockZoom(ScreenPtr pScreen, Bool lock)
}
ModeStatus
-VidModeCheckModeForMonitor(ScreenPtr pScreen, void *mode)
+VidModeCheckModeForMonitor(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
@@ -323,11 +323,11 @@ VidModeCheckModeForMonitor(ScreenPtr pScreen, void *mode)
pScrn = xf86ScreenToScrn(pScreen);
- return xf86CheckModeForMonitor((DisplayModePtr) mode, pScrn->monitor);
+ return xf86CheckModeForMonitor(mode, pScrn->monitor);
}
ModeStatus
-VidModeCheckModeForDriver(ScreenPtr pScreen, void *mode)
+VidModeCheckModeForDriver(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
@@ -336,11 +336,11 @@ VidModeCheckModeForDriver(ScreenPtr pScreen, void *mode)
pScrn = xf86ScreenToScrn(pScreen);
- return xf86CheckModeForDriver(pScrn, (DisplayModePtr) mode, 0);
+ return xf86CheckModeForDriver(pScrn, mode, 0);
}
void
-VidModeSetCrtcForMode(ScreenPtr pScreen, void *mode)
+VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
DisplayModePtr ScreenModes;
@@ -351,7 +351,7 @@ VidModeSetCrtcForMode(ScreenPtr pScreen, void *mode)
/* Ugly hack so that the xf86Mode.c function can be used without change */
pScrn = xf86ScreenToScrn(pScreen);
ScreenModes = pScrn->modes;
- pScrn->modes = (DisplayModePtr) mode;
+ pScrn->modes = mode;
xf86SetCrtcForModes(pScrn, pScrn->adjustFlags);
pScrn->modes = ScreenModes;
@@ -359,7 +359,7 @@ VidModeSetCrtcForMode(ScreenPtr pScreen, void *mode)
}
Bool
-VidModeAddModeline(ScreenPtr pScreen, void *mode)
+VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScrn;
@@ -368,13 +368,13 @@ VidModeAddModeline(ScreenPtr pScreen, void *mode)
pScrn = xf86ScreenToScrn(pScreen);
- ((DisplayModePtr) mode)->name = strdup(""); /* freed by deletemode */
- ((DisplayModePtr) mode)->status = MODE_OK;
- ((DisplayModePtr) mode)->next = pScrn->modes->next;
- ((DisplayModePtr) mode)->prev = pScrn->modes;
- pScrn->modes->next = (DisplayModePtr) mode;
- if (((DisplayModePtr) mode)->next != NULL)
- ((DisplayModePtr) mode)->next->prev = (DisplayModePtr) mode;
+ mode->name = strdup(""); /* freed by deletemode */
+ mode->status = MODE_OK;
+ mode->next = pScrn->modes->next;
+ mode->prev = pScrn->modes;
+ pScrn->modes->next = mode;
+ if (mode->next != NULL)
+ mode->next->prev = mode;
return TRUE;
}
@@ -382,7 +382,7 @@ VidModeAddModeline(ScreenPtr pScreen, void *mode)
int
VidModeGetNumOfModes(ScreenPtr pScreen)
{
- void *mode = NULL;
+ DisplayModePtr mode = NULL;
int dotClock = 0, nummodes = 0;
if (!VidModeGetFirstModeline(pScreen, &mode, &dotClock))
@@ -456,7 +456,7 @@ VidModeGetGammaRampSize(ScreenPtr pScreen)
return xf86GetGammaRampSize(pScreen);
}
-void *
+DisplayModePtr
VidModeCreateMode(void)
{
DisplayModePtr mode;
@@ -473,90 +473,90 @@ VidModeCreateMode(void)
}
void
-VidModeCopyMode(void *modefrom, void *modeto)
+VidModeCopyMode(DisplayModePtr modefrom, DisplayModePtr modeto)
{
memcpy(modeto, modefrom, sizeof(DisplayModeRec));
}
int
-VidModeGetModeValue(void *mode, int valtyp)
+VidModeGetModeValue(DisplayModePtr mode, int valtyp)
{
int ret = 0;
switch (valtyp) {
case VIDMODE_H_DISPLAY:
- ret = ((DisplayModePtr) mode)->HDisplay;
+ ret = mode->HDisplay;
break;
case VIDMODE_H_SYNCSTART:
- ret = ((DisplayModePtr) mode)->HSyncStart;
+ ret = mode->HSyncStart;
break;
case VIDMODE_H_SYNCEND:
- ret = ((DisplayModePtr) mode)->HSyncEnd;
+ ret = mode->HSyncEnd;
break;
case VIDMODE_H_TOTAL:
- ret = ((DisplayModePtr) mode)->HTotal;
+ ret = mode->HTotal;
break;
case VIDMODE_H_SKEW:
- ret = ((DisplayModePtr) mode)->HSkew;
+ ret = mode->HSkew;
break;
case VIDMODE_V_DISPLAY:
- ret = ((DisplayModePtr) mode)->VDisplay;
+ ret = mode->VDisplay;
break;
case VIDMODE_V_SYNCSTART:
- ret = ((DisplayModePtr) mode)->VSyncStart;
+ ret = mode->VSyncStart;
break;
case VIDMODE_V_SYNCEND:
- ret = ((DisplayModePtr) mode)->VSyncEnd;
+ ret = mode->VSyncEnd;
break;
case VIDMODE_V_TOTAL:
- ret = ((DisplayModePtr) mode)->VTotal;
+ ret = mode->VTotal;
break;
case VIDMODE_FLAGS:
- ret = ((DisplayModePtr) mode)->Flags;
+ ret = mode->Flags;
break;
case VIDMODE_CLOCK:
- ret = ((DisplayModePtr) mode)->Clock;
+ ret = mode->Clock;
break;
}
return ret;
}
void
-VidModeSetModeValue(void *mode, int valtyp, int val)
+VidModeSetModeValue(DisplayModePtr mode, int valtyp, int val)
{
switch (valtyp) {
case VIDMODE_H_DISPLAY:
- ((DisplayModePtr) mode)->HDisplay = val;
+ mode->HDisplay = val;
break;
case VIDMODE_H_SYNCSTART:
- ((DisplayModePtr) mode)->HSyncStart = val;
+ mode->HSyncStart = val;
break;
case VIDMODE_H_SYNCEND:
- ((DisplayModePtr) mode)->HSyncEnd = val;
+ mode->HSyncEnd = val;
break;
case VIDMODE_H_TOTAL:
- ((DisplayModePtr) mode)->HTotal = val;
+ mode->HTotal = val;
break;
case VIDMODE_H_SKEW:
- ((DisplayModePtr) mode)->HSkew = val;
+ mode->HSkew = val;
break;
case VIDMODE_V_DISPLAY:
- ((DisplayModePtr) mode)->VDisplay = val;
+ mode->VDisplay = val;
break;
case VIDMODE_V_SYNCSTART:
- ((DisplayModePtr) mode)->VSyncStart = val;
+ mode->VSyncStart = val;
break;
case VIDMODE_V_SYNCEND:
- ((DisplayModePtr) mode)->VSyncEnd = val;
+ mode->VSyncEnd = val;
break;
case VIDMODE_V_TOTAL:
- ((DisplayModePtr) mode)->VTotal = val;
+ mode->VTotal = val;
break;
case VIDMODE_FLAGS:
- ((DisplayModePtr) mode)->Flags = val;
+ mode->Flags = val;
break;
case VIDMODE_CLOCK:
- ((DisplayModePtr) mode)->Clock = val;
+ mode->Clock = val;
break;
}
return;
diff --git a/hw/xfree86/common/xf86vmode.c b/hw/xfree86/common/xf86vmode.c
index d4f0234..b74ec6e 100644
--- a/hw/xfree86/common/xf86vmode.c
+++ b/hw/xfree86/common/xf86vmode.c
@@ -122,7 +122,7 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
.sequenceNumber = client->sequence
};
ScreenPtr pScreen;
- void *mode;
+ DisplayModePtr mode;
int dotClock;
int ver;
@@ -223,7 +223,7 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
REQUEST(xXF86VidModeGetAllModeLinesReq);
xXF86VidModeGetAllModeLinesReply rep;
ScreenPtr pScreen;
- void *mode;
+ DisplayModePtr mode;
int modecount, dotClock;
int ver;
@@ -335,7 +335,7 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
(xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
xXF86VidModeAddModeLineReq newstuff;
ScreenPtr pScreen;
- void *mode;
+ DisplayModePtr mode;
int len;
int dotClock;
int ver;
@@ -501,7 +501,7 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
(xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
xXF86VidModeDeleteModeLineReq newstuff;
ScreenPtr pScreen;
- void *mode;
+ DisplayModePtr mode;
int len, dotClock;
int ver;
@@ -628,7 +628,7 @@ ProcXF86VidModeModModeLine(ClientPtr client)
(xXF86OldVidModeModModeLineReq *) client->requestBuffer;
xXF86VidModeModModeLineReq newstuff;
ScreenPtr pScreen;
- void *mode, *modetmp;
+ DisplayModePtr mode, modetmp;
int len, dotClock;
int ver;
@@ -759,7 +759,7 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
xXF86VidModeValidateModeLineReq newstuff;
xXF86VidModeValidateModeLineReply rep;
ScreenPtr pScreen;
- void *mode, *modetmp = NULL;
+ DisplayModePtr mode, modetmp = NULL;
int len, status, dotClock;
int ver;
@@ -901,7 +901,7 @@ ProcXF86VidModeSwitchToMode(ClientPtr client)
(xXF86OldVidModeSwitchToModeReq *) client->requestBuffer;
xXF86VidModeSwitchToModeReq newstuff;
ScreenPtr pScreen;
- void *mode;
+ DisplayModePtr mode;
int len, dotClock;
int ver;
commit 12f714fd95dc9d912c0bf2524005a73ec6e8ee4f
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Fri Feb 5 09:48:18 2016 +0100
vidmode: remove VidModeGetMonitor()
VidModeGetMonitor() is used solely in ProcXF86VidModeGetMonitor() to
get a untyped monitor pointer that is passed back straight again to
VidModeGetMonitorValue().
This is actually useless as VidModeGetMonitorValue() could as well get
the monitor from the ScreenPtr just like VidModeGetMonitor() does.
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/hw/xfree86/common/vidmodeproc.h b/hw/xfree86/common/vidmodeproc.h
index 53d5835..792be9b 100644
--- a/hw/xfree86/common/vidmodeproc.h
+++ b/hw/xfree86/common/vidmodeproc.h
@@ -53,7 +53,6 @@ extern Bool VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y);
extern Bool VidModeSetViewPort(ScreenPtr pScreen, int x, int y);
extern Bool VidModeSwitchMode(ScreenPtr pScreen, void *mode);
extern Bool VidModeLockZoom(ScreenPtr pScreen, Bool lock);
-extern Bool VidModeGetMonitor(ScreenPtr pScreen, void **monitor);
extern int VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock);
extern Bool VidModeGetClocks(ScreenPtr pScreen, int *Clocks);
extern ModeStatus VidModeCheckModeForMonitor(ScreenPtr pScreen,
@@ -72,7 +71,7 @@ extern void *VidModeCreateMode(void);
extern void VidModeCopyMode(void *modefrom, void *modeto);
extern int VidModeGetModeValue(void *mode, int valtyp);
extern void VidModeSetModeValue(void *mode, int valtyp, int val);
-extern vidMonitorValue VidModeGetMonitorValue(void *monitor,
+extern vidMonitorValue VidModeGetMonitorValue(ScreenPtr pScreen,
int valtyp, int indx);
extern Bool VidModeSetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
CARD16 *);
diff --git a/hw/xfree86/common/xf86VidMode.c b/hw/xfree86/common/xf86VidMode.c
index 414700e..9182d93 100644
--- a/hw/xfree86/common/xf86VidMode.c
+++ b/hw/xfree86/common/xf86VidMode.c
@@ -313,20 +313,6 @@ VidModeLockZoom(ScreenPtr pScreen, Bool lock)
return TRUE;
}
-Bool
-VidModeGetMonitor(ScreenPtr pScreen, void **monitor)
-{
- ScrnInfoPtr pScrn;
-
- if (!VidModeAvailable(pScreen))
- return FALSE;
-
- pScrn = xf86ScreenToScrn(pScreen);
- *monitor = (void *) (pScrn->monitor);
-
- return TRUE;
-}
-
ModeStatus
VidModeCheckModeForMonitor(ScreenPtr pScreen, void *mode)
{
@@ -577,34 +563,42 @@ VidModeSetModeValue(void *mode, int valtyp, int val)
}
vidMonitorValue
-VidModeGetMonitorValue(void *monitor, int valtyp, int indx)
+VidModeGetMonitorValue(ScreenPtr pScreen, int valtyp, int indx)
{
vidMonitorValue ret = { NULL, };
+ MonPtr monitor;
+ ScrnInfoPtr pScrn;
+
+ if (!VidModeAvailable(pScreen))
+ return ret;
+
+ pScrn = xf86ScreenToScrn(pScreen);
+ monitor = pScrn->monitor;
switch (valtyp) {
case VIDMODE_MON_VENDOR:
- ret.ptr = (((MonPtr) monitor)->vendor);
+ ret.ptr = monitor->vendor;
break;
case VIDMODE_MON_MODEL:
- ret.ptr = (((MonPtr) monitor)->model);
+ ret.ptr = monitor->model;
break;
case VIDMODE_MON_NHSYNC:
- ret.i = ((MonPtr) monitor)->nHsync;
+ ret.i = monitor->nHsync;
break;
case VIDMODE_MON_NVREFRESH:
- ret.i = ((MonPtr) monitor)->nVrefresh;
+ ret.i = monitor->nVrefresh;
break;
case VIDMODE_MON_HSYNC_LO:
- ret.f = (100.0 * ((MonPtr) monitor)->hsync[indx].lo);
+ ret.f = (100.0 * monitor->hsync[indx].lo);
break;
case VIDMODE_MON_HSYNC_HI:
- ret.f = (100.0 * ((MonPtr) monitor)->hsync[indx].hi);
+ ret.f = (100.0 * monitor->hsync[indx].hi);
break;
case VIDMODE_MON_VREFRESH_LO:
- ret.f = (100.0 * ((MonPtr) monitor)->vrefresh[indx].lo);
+ ret.f = (100.0 * monitor->vrefresh[indx].lo);
break;
case VIDMODE_MON_VREFRESH_HI:
- ret.f = (100.0 * ((MonPtr) monitor)->vrefresh[indx].hi);
+ ret.f = (100.0 * monitor->vrefresh[indx].hi);
break;
}
return ret;
diff --git a/hw/xfree86/common/xf86vmode.c b/hw/xfree86/common/xf86vmode.c
index 3a2df59..d4f0234 100644
--- a/hw/xfree86/common/xf86vmode.c
+++ b/hw/xfree86/common/xf86vmode.c
@@ -1029,7 +1029,6 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
};
CARD32 *hsyncdata, *vsyncdata;
int i, nHsync, nVrefresh;
- void *monitor;
ScreenPtr pScreen;
DEBUG_P("XF86VidModeGetMonitor");
@@ -1040,20 +1039,17 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
return BadValue;
pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetMonitor(pScreen, &monitor))
- return BadValue;
-
- nHsync = VidModeGetMonitorValue(monitor, VIDMODE_MON_NHSYNC, 0).i;
- nVrefresh = VidModeGetMonitorValue(monitor, VIDMODE_MON_NVREFRESH, 0).i;
+ nHsync = VidModeGetMonitorValue(pScreen, VIDMODE_MON_NHSYNC, 0).i;
+ nVrefresh = VidModeGetMonitorValue(pScreen, VIDMODE_MON_NVREFRESH, 0).i;
- if ((char *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VENDOR, 0)).ptr)
- rep.vendorLength = strlen((char *) (VidModeGetMonitorValue(monitor,
+ if ((char *) (VidModeGetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr)
+ rep.vendorLength = strlen((char *) (VidModeGetMonitorValue(pScreen,
VIDMODE_MON_VENDOR,
0)).ptr);
else
rep.vendorLength = 0;
- if ((char *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_MODEL, 0)).ptr)
- rep.modelLength = strlen((char *) (VidModeGetMonitorValue(monitor,
+ if ((char *) (VidModeGetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr)
+ rep.modelLength = strlen((char *) (VidModeGetMonitorValue(pScreen,
VIDMODE_MON_MODEL,
0)).ptr);
else
@@ -1078,19 +1074,19 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
}
for (i = 0; i < nHsync; i++) {
- hsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(monitor,
+ hsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(pScreen,
VIDMODE_MON_HSYNC_LO,
i)).f |
(unsigned
- short) (VidModeGetMonitorValue(monitor, VIDMODE_MON_HSYNC_HI,
+ short) (VidModeGetMonitorValue(pScreen, VIDMODE_MON_HSYNC_HI,
i)).f << 16;
}
for (i = 0; i < nVrefresh; i++) {
- vsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(monitor,
+ vsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(pScreen,
VIDMODE_MON_VREFRESH_LO,
i)).f |
(unsigned
- short) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VREFRESH_HI,
+ short) (VidModeGetMonitorValue(pScreen, VIDMODE_MON_VREFRESH_HI,
i)).f << 16;
}
@@ -1104,10 +1100,10 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
WriteSwappedDataToClient(client, nVrefresh * sizeof(CARD32), vsyncdata);
if (rep.vendorLength)
WriteToClient(client, rep.vendorLength,
- (VidModeGetMonitorValue(monitor, VIDMODE_MON_VENDOR, 0)).ptr);
+ (VidModeGetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr);
if (rep.modelLength)
WriteToClient(client, rep.modelLength,
- (VidModeGetMonitorValue(monitor, VIDMODE_MON_MODEL, 0)).ptr);
+ (VidModeGetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr);
free(hsyncdata);
free(vsyncdata);
commit f6f7e21133c13c34f306a191137d566e83b40929
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Fri Feb 5 09:48:17 2016 +0100
vidmode: use ScreenPtr instead of screen index
New code passes ScreenPtr instead of the screen index.
Change the VidMode functions to take a ScreenPtr.
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/hw/xfree86/common/vidmodeproc.h b/hw/xfree86/common/vidmodeproc.h
index 59d714c..53d5835 100644
--- a/hw/xfree86/common/vidmodeproc.h
+++ b/hw/xfree86/common/vidmodeproc.h
@@ -41,32 +41,32 @@ typedef union {
extern Bool VidModeExtensionInit(ScreenPtr pScreen);
-extern Bool VidModeGetCurrentModeline(int scrnIndex, void **mode,
+extern Bool VidModeGetCurrentModeline(ScreenPtr pScreen, void **mode,
int *dotClock);
-extern Bool VidModeGetFirstModeline(int scrnIndex, void **mode,
+extern Bool VidModeGetFirstModeline(ScreenPtr pScreen, void **mode,
int *dotClock);
-extern Bool VidModeGetNextModeline(int scrnIndex, void **mode,
+extern Bool VidModeGetNextModeline(ScreenPtr pScreen, void **mode,
int *dotClock);
-extern Bool VidModeDeleteModeline(int scrnIndex, void *mode);
-extern Bool VidModeZoomViewport(int scrnIndex, int zoom);
-extern Bool VidModeGetViewPort(int scrnIndex, int *x, int *y);
-extern Bool VidModeSetViewPort(int scrnIndex, int x, int y);
-extern Bool VidModeSwitchMode(int scrnIndex, void *mode);
-extern Bool VidModeLockZoom(int scrnIndex, Bool lock);
-extern Bool VidModeGetMonitor(int scrnIndex, void **monitor);
-extern int VidModeGetNumOfClocks(int scrnIndex, Bool *progClock);
-extern Bool VidModeGetClocks(int scrnIndex, int *Clocks);
-extern ModeStatus VidModeCheckModeForMonitor(int scrnIndex,
+extern Bool VidModeDeleteModeline(ScreenPtr pScreen, void *mode);
+extern Bool VidModeZoomViewport(ScreenPtr pScreen, int zoom);
+extern Bool VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y);
+extern Bool VidModeSetViewPort(ScreenPtr pScreen, int x, int y);
+extern Bool VidModeSwitchMode(ScreenPtr pScreen, void *mode);
+extern Bool VidModeLockZoom(ScreenPtr pScreen, Bool lock);
+extern Bool VidModeGetMonitor(ScreenPtr pScreen, void **monitor);
+extern int VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock);
+extern Bool VidModeGetClocks(ScreenPtr pScreen, int *Clocks);
+extern ModeStatus VidModeCheckModeForMonitor(ScreenPtr pScreen,
void *mode);
-extern ModeStatus VidModeCheckModeForDriver(int scrnIndex,
+extern ModeStatus VidModeCheckModeForDriver(ScreenPtr pScreen,
void *mode);
-extern void VidModeSetCrtcForMode(int scrnIndex, void *mode);
-extern Bool VidModeAddModeline(int scrnIndex, void *mode);
-extern int VidModeGetDotClock(int scrnIndex, int Clock);
-extern int VidModeGetNumOfModes(int scrnIndex);
-extern Bool VidModeSetGamma(int scrnIndex, float red, float green,
+extern void VidModeSetCrtcForMode(ScreenPtr pScreen, void *mode);
+extern Bool VidModeAddModeline(ScreenPtr pScreen, void *mode);
+extern int VidModeGetDotClock(ScreenPtr pScreen, int Clock);
+extern int VidModeGetNumOfModes(ScreenPtr pScreen);
+extern Bool VidModeSetGamma(ScreenPtr pScreen, float red, float green,
float blue);
-extern Bool VidModeGetGamma(int scrnIndex, float *red, float *green,
+extern Bool VidModeGetGamma(ScreenPtr pScreen, float *red, float *green,
float *blue);
extern void *VidModeCreateMode(void);
extern void VidModeCopyMode(void *modefrom, void *modeto);
@@ -74,10 +74,10 @@ extern int VidModeGetModeValue(void *mode, int valtyp);
extern void VidModeSetModeValue(void *mode, int valtyp, int val);
extern vidMonitorValue VidModeGetMonitorValue(void *monitor,
int valtyp, int indx);
-extern Bool VidModeSetGammaRamp(int, int, CARD16 *, CARD16 *,
+extern Bool VidModeSetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
CARD16 *);
-extern Bool VidModeGetGammaRamp(int, int, CARD16 *, CARD16 *,
+extern Bool VidModeGetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
CARD16 *);
-extern int VidModeGetGammaRampSize(int scrnIndex);
+extern int VidModeGetGammaRampSize(ScreenPtr pScreen);
#endif
diff --git a/hw/xfree86/common/xf86VidMode.c b/hw/xfree86/common/xf86VidMode.c
index 04637f1..414700e 100644
--- a/hw/xfree86/common/xf86VidMode.c
+++ b/hw/xfree86/common/xf86VidMode.c
@@ -83,19 +83,14 @@ VidModeExtensionInit(ScreenPtr pScreen)
#ifdef XF86VIDMODE
static Bool
-VidModeAvailable(int scrnIndex)
+VidModeAvailable(ScreenPtr pScreen)
{
- ScrnInfoPtr pScrn;
- VidModePtr pVidMode;
-
- pScrn = xf86Screens[scrnIndex];
- if (pScrn == NULL) {
- DebugF("pScrn == NULL\n");
+ if (pScreen == NULL) {
+ DebugF("pScreen == NULL\n");
return FALSE;
}
- pVidMode = VMPTR(pScrn->pScreen);
- if (pVidMode)
+ if (VMPTR(pScreen))
return TRUE;
else {
DebugF("pVidMode == NULL\n");
@@ -104,14 +99,14 @@ VidModeAvailable(int scrnIndex)
}
Bool
-VidModeGetCurrentModeline(int scrnIndex, void **mode, int *dotClock)
+VidModeGetCurrentModeline(ScreenPtr pScreen, void **mode, int *dotClock)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
if (pScrn->currentMode) {
*mode = (void *) (pScrn->currentMode);
@@ -123,14 +118,14 @@ VidModeGetCurrentModeline(int scrnIndex, void **mode, int *dotClock)
}
int
-VidModeGetDotClock(int scrnIndex, int Clock)
+VidModeGetDotClock(ScreenPtr pScreen, int Clock)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return 0;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
if ((pScrn->progClock) || (Clock >= MAXCLOCKS))
return Clock;
else
@@ -138,14 +133,14 @@ VidModeGetDotClock(int scrnIndex, int Clock)
}
int
-VidModeGetNumOfClocks(int scrnIndex, Bool *progClock)
+VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return 0;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
if (pScrn->progClock) {
*progClock = TRUE;
return 0;
@@ -157,15 +152,15 @@ VidModeGetNumOfClocks(int scrnIndex, Bool *progClock)
}
Bool
-VidModeGetClocks(int scrnIndex, int *Clocks)
+VidModeGetClocks(ScreenPtr pScreen, int *Clocks)
{
ScrnInfoPtr pScrn;
int i;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
if (pScrn->progClock)
return FALSE;
@@ -177,49 +172,47 @@ VidModeGetClocks(int scrnIndex, int *Clocks)
}
Bool
-VidModeGetFirstModeline(int scrnIndex, void **mode, int *dotClock)
+VidModeGetFirstModeline(ScreenPtr pScreen, void **mode, int *dotClock)
{
ScrnInfoPtr pScrn;
VidModePtr pVidMode;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
if (pScrn->modes == NULL)
return FALSE;
- pVidMode = VMPTR(pScrn->pScreen);
+ pVidMode = VMPTR(pScreen);
pVidMode->First = pScrn->modes;
pVidMode->Next = pVidMode->First->next;
if (pVidMode->First->status == MODE_OK) {
*mode = (void *) (pVidMode->First);
- *dotClock = VidModeGetDotClock(scrnIndex, pVidMode->First->Clock);
+ *dotClock = VidModeGetDotClock(pScreen, pVidMode->First->Clock);
return TRUE;
}
- return VidModeGetNextModeline(scrnIndex, mode, dotClock);
+ return VidModeGetNextModeline(pScreen, mode, dotClock);
}
Bool
-VidModeGetNextModeline(int scrnIndex, void **mode, int *dotClock)
+VidModeGetNextModeline(ScreenPtr pScreen, void **mode, int *dotClock)
{
- ScrnInfoPtr pScrn;
VidModePtr pVidMode;
DisplayModePtr p;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
- pVidMode = VMPTR(pScrn->pScreen);
+ pVidMode = VMPTR(pScreen);
for (p = pVidMode->Next; p != NULL && p != pVidMode->First; p = p->next) {
if (p->status == MODE_OK) {
pVidMode->Next = p->next;
*mode = (void *) p;
- *dotClock = VidModeGetDotClock(scrnIndex, p->Clock);
+ *dotClock = VidModeGetDotClock(pScreen, p->Clock);
return TRUE;
}
}
@@ -228,40 +221,37 @@ VidModeGetNextModeline(int scrnIndex, void **mode, int *dotClock)
}
Bool
-VidModeDeleteModeline(int scrnIndex, void *mode)
+VidModeDeleteModeline(ScreenPtr pScreen, void *mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
+ if ((mode == NULL) || (!VidModeAvailable(pScreen)))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
xf86DeleteMode(&(pScrn->modes), (DisplayModePtr) mode);
return TRUE;
}
Bool
-VidModeZoomViewport(int scrnIndex, int zoom)
+VidModeZoomViewport(ScreenPtr pScreen, int zoom)
{
- ScrnInfoPtr pScrn;
-
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
- xf86ZoomViewport(pScrn->pScreen, zoom);
+ xf86ZoomViewport(pScreen, zoom);
return TRUE;
}
Bool
-VidModeSetViewPort(int scrnIndex, int x, int y)
+VidModeSetViewPort(ScreenPtr pScreen, int x, int y)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
pScrn->frameX0 = min(max(x, 0),
pScrn->virtualX - pScrn->currentMode->HDisplay);
pScrn->frameX1 = pScrn->frameX0 + pScrn->currentMode->HDisplay - 1;
@@ -275,30 +265,30 @@ VidModeSetViewPort(int scrnIndex, int x, int y)
}
Bool
-VidModeGetViewPort(int scrnIndex, int *x, int *y)
+VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
*x = pScrn->frameX0;
*y = pScrn->frameY0;
return TRUE;
}
Bool
-VidModeSwitchMode(int scrnIndex, void *mode)
+VidModeSwitchMode(ScreenPtr pScreen, void *mode)
{
ScrnInfoPtr pScrn;
DisplayModePtr pTmpMode;
Bool retval;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
/* save in case we fail */
pTmpMode = pScrn->currentMode;
/* Force a mode switch */
@@ -311,73 +301,69 @@ VidModeSwitchMode(int scrnIndex, void *mode)
}
Bool
-VidModeLockZoom(int scrnIndex, Bool lock)
+VidModeLockZoom(ScreenPtr pScreen, Bool lock)
{
- ScrnInfoPtr pScrn;
-
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
-
if (xf86Info.dontZoom)
return FALSE;
- xf86LockZoom(pScrn->pScreen, lock);
+ xf86LockZoom(pScreen, lock);
return TRUE;
}
Bool
-VidModeGetMonitor(int scrnIndex, void **monitor)
+VidModeGetMonitor(ScreenPtr pScreen, void **monitor)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
*monitor = (void *) (pScrn->monitor);
return TRUE;
}
ModeStatus
-VidModeCheckModeForMonitor(int scrnIndex, void *mode)
+VidModeCheckModeForMonitor(ScreenPtr pScreen, void *mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
+ if ((mode == NULL) || (!VidModeAvailable(pScreen)))
return MODE_ERROR;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
return xf86CheckModeForMonitor((DisplayModePtr) mode, pScrn->monitor);
}
ModeStatus
-VidModeCheckModeForDriver(int scrnIndex, void *mode)
+VidModeCheckModeForDriver(ScreenPtr pScreen, void *mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
+ if ((mode == NULL) || (!VidModeAvailable(pScreen)))
return MODE_ERROR;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
return xf86CheckModeForDriver(pScrn, (DisplayModePtr) mode, 0);
}
void
-VidModeSetCrtcForMode(int scrnIndex, void *mode)
+VidModeSetCrtcForMode(ScreenPtr pScreen, void *mode)
{
ScrnInfoPtr pScrn;
DisplayModePtr ScreenModes;
- if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
+ if ((mode == NULL) || (!VidModeAvailable(pScreen)))
return;
/* Ugly hack so that the xf86Mode.c function can be used without change */
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
ScreenModes = pScrn->modes;
pScrn->modes = (DisplayModePtr) mode;
@@ -387,14 +373,14 @@ VidModeSetCrtcForMode(int scrnIndex, void *mode)
}
Bool
-VidModeAddModeline(int scrnIndex, void *mode)
+VidModeAddModeline(ScreenPtr pScreen, void *mode)
{
ScrnInfoPtr pScrn;
- if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
+ if ((mode == NULL) || (!VidModeAvailable(pScreen)))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
((DisplayModePtr) mode)->name = strdup(""); /* freed by deletemode */
((DisplayModePtr) mode)->status = MODE_OK;
@@ -408,49 +394,47 @@ VidModeAddModeline(int scrnIndex, void *mode)
}
int
-VidModeGetNumOfModes(int scrnIndex)
+VidModeGetNumOfModes(ScreenPtr pScreen)
{
void *mode = NULL;
int dotClock = 0, nummodes = 0;
- if (!VidModeGetFirstModeline(scrnIndex, &mode, &dotClock))
+ if (!VidModeGetFirstModeline(pScreen, &mode, &dotClock))
return nummodes;
do {
nummodes++;
- if (!VidModeGetNextModeline(scrnIndex, &mode, &dotClock))
+ if (!VidModeGetNextModeline(pScreen, &mode, &dotClock))
return nummodes;
} while (TRUE);
}
Bool
-VidModeSetGamma(int scrnIndex, float red, float green, float blue)
+VidModeSetGamma(ScreenPtr pScreen, float red, float green, float blue)
{
- ScrnInfoPtr pScrn;
Gamma gamma;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
gamma.red = red;
gamma.green = green;
gamma.blue = blue;
- if (xf86ChangeGamma(pScrn->pScreen, gamma) != Success)
+ if (xf86ChangeGamma(pScreen, gamma) != Success)
return FALSE;
else
return TRUE;
}
Bool
-VidModeGetGamma(int scrnIndex, float *red, float *green, float *blue)
+VidModeGetGamma(ScreenPtr pScreen, float *red, float *green, float *blue)
{
ScrnInfoPtr pScrn;
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
+ pScrn = xf86ScreenToScrn(pScreen);
*red = pScrn->gamma.red;
*green = pScrn->gamma.green;
*blue = pScrn->gamma.blue;
@@ -458,38 +442,32 @@ VidModeGetGamma(int scrnIndex, float *red, float *green, float *blue)
}
Bool
-VidModeSetGammaRamp(int scrnIndex, int size, CARD16 *r, CARD16 *g, CARD16 *b)
+VidModeSetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
{
- ScrnInfoPtr pScrn;
-
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
- xf86ChangeGammaRamp(pScrn->pScreen, size, r, g, b);
+ xf86ChangeGammaRamp(pScreen, size, r, g, b);
return TRUE;
}
Bool
-VidModeGetGammaRamp(int scrnIndex, int size, CARD16 *r, CARD16 *g, CARD16 *b)
+VidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
{
- ScrnInfoPtr pScrn;
-
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return FALSE;
- pScrn = xf86Screens[scrnIndex];
- xf86GetGammaRamp(pScrn->pScreen, size, r, g, b);
+ xf86GetGammaRamp(pScreen, size, r, g, b);
return TRUE;
}
int
-VidModeGetGammaRampSize(int scrnIndex)
+VidModeGetGammaRampSize(ScreenPtr pScreen)
{
- if (!VidModeAvailable(scrnIndex))
+ if (!VidModeAvailable(pScreen))
return 0;
- return xf86GetGammaRampSize(xf86Screens[scrnIndex]->pScreen);
+ return xf86GetGammaRampSize(pScreen);
}
void *
diff --git a/hw/xfree86/common/xf86vmode.c b/hw/xfree86/common/xf86vmode.c
index d133687..3a2df59 100644
--- a/hw/xfree86/common/xf86vmode.c
+++ b/hw/xfree86/common/xf86vmode.c
@@ -121,6 +121,7 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
.type = X_Reply,
.sequenceNumber = client->sequence
};
+ ScreenPtr pScreen;
void *mode;
int dotClock;
int ver;
@@ -141,8 +142,9 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetCurrentModeline(stuff->screen, &mode, &dotClock))
+ if (!VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
return BadValue;
rep.dotclock = dotClock;
@@ -220,6 +222,7 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
{
REQUEST(xXF86VidModeGetAllModeLinesReq);
xXF86VidModeGetAllModeLinesReply rep;
+ ScreenPtr pScreen;
void *mode;
int modecount, dotClock;
int ver;
@@ -230,14 +233,14 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
-
+ pScreen = screenInfo.screens[stuff->screen];
ver = ClientMajorVersion(client);
- modecount = VidModeGetNumOfModes(stuff->screen);
+ modecount = VidModeGetNumOfModes(pScreen);
if (modecount < 1)
return VidModeErrorBase + XF86VidModeExtensionDisabled;
- if (!VidModeGetFirstModeline(stuff->screen, &mode, &dotClock))
+ if (!VidModeGetFirstModeline(pScreen, &mode, &dotClock))
return BadValue;
rep = (xXF86VidModeGetAllModeLinesReply) {
@@ -308,7 +311,7 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
WriteToClient(client, sizeof(xXF86VidModeModeInfo), &mdinf);
}
- } while (VidModeGetNextModeline(stuff->screen, &mode, &dotClock));
+ } while (VidModeGetNextModeline(pScreen, &mode, &dotClock));
return Success;
}
@@ -331,6 +334,7 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
xXF86OldVidModeAddModeLineReq *oldstuff =
(xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
xXF86VidModeAddModeLineReq newstuff;
+ ScreenPtr pScreen;
void *mode;
int len;
int dotClock;
@@ -405,6 +409,7 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
if (stuff->hsyncstart < stuff->hdisplay ||
stuff->hsyncend < stuff->hsyncstart ||
@@ -424,14 +429,14 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
if (stuff->after_htotal != 0 || stuff->after_vtotal != 0) {
Bool found = FALSE;
- if (VidModeGetFirstModeline(stuff->screen, &mode, &dotClock)) {
+ if (VidModeGetFirstModeline(pScreen, &mode, &dotClock)) {
do {
- if ((VidModeGetDotClock(stuff->screen, stuff->dotclock)
+ if ((VidModeGetDotClock(pScreen, stuff->dotclock)
== dotClock) && MODEMATCH(mode, stuff)) {
found = TRUE;
break;
}
- } while (VidModeGetNextModeline(stuff->screen, &mode, &dotClock));
+ } while (VidModeGetNextModeline(pScreen, &mode, &dotClock));
}
if (!found)
return BadValue;
@@ -457,7 +462,7 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
ErrorF("AddModeLine - Privates in request have been ignored\n");
/* Check that the mode is consistent with the monitor specs */
- switch (VidModeCheckModeForMonitor(stuff->screen, mode)) {
+ switch (VidModeCheckModeForMonitor(pScreen, mode)) {
case MODE_OK:
break;
case MODE_HSYNC:
@@ -474,14 +479,14 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
}
/* Check that the driver is happy with the mode */
- if (VidModeCheckModeForDriver(stuff->screen, mode) != MODE_OK) {
+ if (VidModeCheckModeForDriver(pScreen, mode) != MODE_OK) {
free(mode);
return VidModeErrorBase + XF86VidModeModeUnsuitable;
}
- VidModeSetCrtcForMode(stuff->screen, mode);
+ VidModeSetCrtcForMode(pScreen, mode);
- VidModeAddModeline(stuff->screen, mode);
+ VidModeAddModeline(pScreen, mode);
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
ErrorF("AddModeLine - Succeeded\n");
@@ -495,6 +500,7 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
xXF86OldVidModeDeleteModeLineReq *oldstuff =
(xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
xXF86VidModeDeleteModeLineReq newstuff;
+ ScreenPtr pScreen;
void *mode;
int len, dotClock;
int ver;
@@ -557,8 +563,9 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetCurrentModeline(stuff->screen, &mode, &dotClock))
+ if (!VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
return BadValue;
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
@@ -577,11 +584,11 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
VidModeGetModeValue(mode, VIDMODE_FLAGS));
}
- if ((VidModeGetDotClock(stuff->screen, stuff->dotclock) == dotClock) &&
+ if ((VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
MODEMATCH(mode, stuff))
return BadValue;
- if (!VidModeGetFirstModeline(stuff->screen, &mode, &dotClock))
+ if (!VidModeGetFirstModeline(pScreen, &mode, &dotClock))
return BadValue;
do {
@@ -601,14 +608,14 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
VidModeGetModeValue(mode, VIDMODE_FLAGS));
}
- if ((VidModeGetDotClock(stuff->screen, stuff->dotclock) == dotClock) &&
+ if ((VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
MODEMATCH(mode, stuff)) {
- VidModeDeleteModeline(stuff->screen, mode);
+ VidModeDeleteModeline(pScreen, mode);
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
ErrorF("DeleteModeLine - Succeeded\n");
return Success;
}
- } while (VidModeGetNextModeline(stuff->screen, &mode, &dotClock));
+ } while (VidModeGetNextModeline(pScreen, &mode, &dotClock));
return BadValue;
}
@@ -620,6 +627,7 @@ ProcXF86VidModeModModeLine(ClientPtr client)
xXF86OldVidModeModModeLineReq *oldstuff =
(xXF86OldVidModeModModeLineReq *) client->requestBuffer;
xXF86VidModeModModeLineReq newstuff;
+ ScreenPtr pScreen;
void *mode, *modetmp;
int len, dotClock;
int ver;
@@ -677,8 +685,9 @@ ProcXF86VidModeModModeLine(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetCurrentModeline(stuff->screen, &mode, &dotClock))
+ if (!VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
return BadValue;
modetmp = VidModeCreateMode();
@@ -699,7 +708,7 @@ ProcXF86VidModeModModeLine(ClientPtr client)
ErrorF("ModModeLine - Privates in request have been ignored\n");
/* Check that the mode is consistent with the monitor specs */
- switch (VidModeCheckModeForMonitor(stuff->screen, modetmp)) {
+ switch (VidModeCheckModeForMonitor(pScreen, modetmp)) {
case MODE_OK:
break;
case MODE_HSYNC:
@@ -716,7 +725,7 @@ ProcXF86VidModeModModeLine(ClientPtr client)
}
/* Check that the driver is happy with the mode */
- if (VidModeCheckModeForDriver(stuff->screen, modetmp) != MODE_OK) {
+ if (VidModeCheckModeForDriver(pScreen, modetmp) != MODE_OK) {
free(modetmp);
return VidModeErrorBase + XF86VidModeModeUnsuitable;
}
@@ -733,8 +742,8 @@ ProcXF86VidModeModModeLine(ClientPtr client)
VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal);
VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags);
- VidModeSetCrtcForMode(stuff->screen, mode);
- VidModeSwitchMode(stuff->screen, mode);
+ VidModeSetCrtcForMode(pScreen, mode);
+ VidModeSwitchMode(pScreen, mode);
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
ErrorF("ModModeLine - Succeeded\n");
@@ -749,6 +758,7 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
(xXF86OldVidModeValidateModeLineReq *) client->requestBuffer;
xXF86VidModeValidateModeLineReq newstuff;
xXF86VidModeValidateModeLineReply rep;
+ ScreenPtr pScreen;
void *mode, *modetmp = NULL;
int len, status, dotClock;
int ver;
@@ -802,6 +812,7 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
status = MODE_OK;
@@ -815,7 +826,7 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
goto status_reply;
}
- if (!VidModeGetCurrentModeline(stuff->screen, &mode, &dotClock))
+ if (!VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
return BadValue;
modetmp = VidModeCreateMode();
@@ -836,11 +847,11 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
/* Check that the mode is consistent with the monitor specs */
if ((status =
- VidModeCheckModeForMonitor(stuff->screen, modetmp)) != MODE_OK)
+ VidModeCheckModeForMonitor(pScreen, modetmp)) != MODE_OK)
goto status_reply;
/* Check that the driver is happy with the mode */
- status = VidModeCheckModeForDriver(stuff->screen, modetmp);
+ status = VidModeCheckModeForDriver(pScreen, modetmp);
status_reply:
free(modetmp);
@@ -867,6 +878,7 @@ static int
ProcXF86VidModeSwitchMode(ClientPtr client)
{
REQUEST(xXF86VidModeSwitchModeReq);
+ ScreenPtr pScreen;
DEBUG_P("XF86VidModeSwitchMode");
@@ -874,8 +886,9 @@ ProcXF86VidModeSwitchMode(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- VidModeZoomViewport(stuff->screen, (short) stuff->zoom);
+ VidModeZoomViewport(pScreen, (short) stuff->zoom);
return Success;
}
@@ -887,6 +900,7 @@ ProcXF86VidModeSwitchToMode(ClientPtr client)
xXF86OldVidModeSwitchToModeReq *oldstuff =
(xXF86OldVidModeSwitchToModeReq *) client->requestBuffer;
xXF86VidModeSwitchToModeReq newstuff;
+ ScreenPtr pScreen;
void *mode;
int len, dotClock;
int ver;
@@ -941,15 +955,16 @@ ProcXF86VidModeSwitchToMode(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetCurrentModeline(stuff->screen, &mode, &dotClock))
+ if (!VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
return BadValue;
- if ((VidModeGetDotClock(stuff->screen, stuff->dotclock) == dotClock)
+ if ((VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock)
&& MODEMATCH(mode, stuff))
return Success;
- if (!VidModeGetFirstModeline(stuff->screen, &mode, &dotClock))
+ if (!VidModeGetFirstModeline(pScreen, &mode, &dotClock))
return BadValue;
do {
@@ -969,17 +984,17 @@ ProcXF86VidModeSwitchToMode(ClientPtr client)
VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
VidModeGetModeValue(mode, VIDMODE_FLAGS));
}
- if ((VidModeGetDotClock(stuff->screen, stuff->dotclock) == dotClock) &&
+ if ((VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
MODEMATCH(mode, stuff)) {
- if (!VidModeSwitchMode(stuff->screen, mode))
+ if (!VidModeSwitchMode(pScreen, mode))
return BadValue;
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
ErrorF("SwitchToMode - Succeeded\n");
return Success;
}
- } while (VidModeGetNextModeline(stuff->screen, &mode, &dotClock));
+ } while (VidModeGetNextModeline(pScreen, &mode, &dotClock));
return BadValue;
}
@@ -988,6 +1003,7 @@ static int
ProcXF86VidModeLockModeSwitch(ClientPtr client)
{
REQUEST(xXF86VidModeLockModeSwitchReq);
+ ScreenPtr pScreen;
REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
@@ -995,8 +1011,9 @@ ProcXF86VidModeLockModeSwitch(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeLockZoom(stuff->screen, (short) stuff->lock))
+ if (!VidModeLockZoom(pScreen, (short) stuff->lock))
return VidModeErrorBase + XF86VidModeZoomLocked;
return Success;
@@ -1013,6 +1030,7 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
CARD32 *hsyncdata, *vsyncdata;
int i, nHsync, nVrefresh;
void *monitor;
+ ScreenPtr pScreen;
DEBUG_P("XF86VidModeGetMonitor");
@@ -1020,8 +1038,9 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetMonitor(stuff->screen, &monitor))
+ if (!VidModeGetMonitor(pScreen, &monitor))
return BadValue;
nHsync = VidModeGetMonitorValue(monitor, VIDMODE_MON_NHSYNC, 0).i;
@@ -1101,6 +1120,7 @@ ProcXF86VidModeGetViewPort(ClientPtr client)
{
REQUEST(xXF86VidModeGetViewPortReq);
xXF86VidModeGetViewPortReply rep;
+ ScreenPtr pScreen;
int x, y;
DEBUG_P("XF86VidModeGetViewPort");
@@ -1109,8 +1129,9 @@ ProcXF86VidModeGetViewPort(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- VidModeGetViewPort(stuff->screen, &x, &y);
+ VidModeGetViewPort(pScreen, &x, &y);
rep = (xXF86VidModeGetViewPortReply) {
.type = X_Reply,
@@ -1134,6 +1155,7 @@ static int
ProcXF86VidModeSetViewPort(ClientPtr client)
{
REQUEST(xXF86VidModeSetViewPortReq);
+ ScreenPtr pScreen;
DEBUG_P("XF86VidModeSetViewPort");
@@ -1141,8 +1163,9 @@ ProcXF86VidModeSetViewPort(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeSetViewPort(stuff->screen, stuff->x, stuff->y))
+ if (!VidModeSetViewPort(pScreen, stuff->x, stuff->y))
return BadValue;
return Success;
@@ -1153,6 +1176,7 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
{
REQUEST(xXF86VidModeGetDotClocksReq);
xXF86VidModeGetDotClocksReply rep;
+ ScreenPtr pScreen;
int n;
int numClocks;
CARD32 dotclock;
@@ -1165,8 +1189,9 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- numClocks = VidModeGetNumOfClocks(stuff->screen, &ClockProg);
+ numClocks = VidModeGetNumOfClocks(pScreen, &ClockProg);
rep = (xXF86VidModeGetDotClocksReply) {
.type = X_Reply,
@@ -1182,7 +1207,7 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
Clocks = calloc(numClocks, sizeof(int));
if (!Clocks)
return BadValue;
- if (!VidModeGetClocks(stuff->screen, Clocks)) {
+ if (!VidModeGetClocks(pScreen, Clocks)) {
free(Clocks);
return BadValue;
}
@@ -1218,6 +1243,7 @@ static int
ProcXF86VidModeSetGamma(ClientPtr client)
{
REQUEST(xXF86VidModeSetGammaReq);
+ ScreenPtr pScreen;
DEBUG_P("XF86VidModeSetGamma");
@@ -1225,8 +1251,9 @@ ProcXF86VidModeSetGamma(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeSetGamma(stuff->screen, ((float) stuff->red) / 10000.,
+ if (!VidModeSetGamma(pScreen, ((float) stuff->red) / 10000.,
((float) stuff->green) / 10000.,
((float) stuff->blue) / 10000.))
return BadValue;
@@ -1239,6 +1266,7 @@ ProcXF86VidModeGetGamma(ClientPtr client)
{
REQUEST(xXF86VidModeGetGammaReq);
xXF86VidModeGetGammaReply rep;
+ ScreenPtr pScreen;
float red, green, blue;
DEBUG_P("XF86VidModeGetGamma");
@@ -1247,8 +1275,9 @@ ProcXF86VidModeGetGamma(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- if (!VidModeGetGamma(stuff->screen, &red, &green, &blue))
+ if (!VidModeGetGamma(pScreen, &red, &green, &blue))
return BadValue;
rep = (xXF86VidModeGetGammaReply) {
.type = X_Reply,
@@ -1273,6 +1302,7 @@ ProcXF86VidModeGetGamma(ClientPtr client)
static int
ProcXF86VidModeSetGammaRamp(ClientPtr client)
{
+ ScreenPtr pScreen;
CARD16 *r, *g, *b;
int length;
@@ -1280,8 +1310,9 @@ ProcXF86VidModeSetGammaRamp(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- if (stuff->size != VidModeGetGammaRampSize(stuff->screen))
+ if (stuff->size != VidModeGetGammaRampSize(pScreen))
return BadValue;
length = (stuff->size + 1) & ~1;
@@ -1292,7 +1323,7 @@ ProcXF86VidModeSetGammaRamp(ClientPtr client)
g = r + length;
b = g + length;
- if (!VidModeSetGammaRamp(stuff->screen, stuff->size, r, g, b))
+ if (!VidModeSetGammaRamp(pScreen, stuff->size, r, g, b))
return BadValue;
return Success;
@@ -1305,6 +1336,7 @@ ProcXF86VidModeGetGammaRamp(ClientPtr client)
int length;
size_t ramplen = 0;
xXF86VidModeGetGammaRampReply rep;
+ ScreenPtr pScreen;
REQUEST(xXF86VidModeGetGammaRampReq);
@@ -1312,8 +1344,9 @@ ProcXF86VidModeGetGammaRamp(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
- if (stuff->size != VidModeGetGammaRampSize(stuff->screen))
+ if (stuff->size != VidModeGetGammaRampSize(pScreen))
return BadValue;
length = (stuff->size + 1) & ~1;
@@ -1323,7 +1356,7 @@ ProcXF86VidModeGetGammaRamp(ClientPtr client)
return BadAlloc;
ramplen = length * 3 * sizeof(CARD16);
- if (!VidModeGetGammaRamp(stuff->screen, stuff->size,
+ if (!VidModeGetGammaRamp(pScreen, stuff->size,
ramp, ramp + length, ramp + (length * 2))) {
free(ramp);
return BadValue;
@@ -1355,6 +1388,7 @@ static int
ProcXF86VidModeGetGammaRampSize(ClientPtr client)
{
xXF86VidModeGetGammaRampSizeReply rep;
+ ScreenPtr pScreen;
REQUEST(xXF86VidModeGetGammaRampSizeReq);
@@ -1362,12 +1396,13 @@ ProcXF86VidModeGetGammaRampSize(ClientPtr client)
if (stuff->screen >= screenInfo.numScreens)
return BadValue;
+ pScreen = screenInfo.screens[stuff->screen];
rep = (xXF86VidModeGetGammaRampSizeReply) {
.type = X_Reply,
.sequenceNumber = client->sequence,
.length = 0,
- .size = VidModeGetGammaRampSize(stuff->screen)
+ .size = VidModeGetGammaRampSize(pScreen)
};
if (client->swapped) {
swaps(&rep.sequenceNumber);
commit 6e898ef080df93e885ead9d6fee8854b34e0216f
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Fri Feb 5 09:48:16 2016 +0100
vidmode: get rid of the CloseScreen wrapper
As we rely on dixRegisterPrivateKey() to allocate the memory for us that
will be free automatically, we do not need the CloseScreen wrapper
anymore.
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/hw/xfree86/common/xf86Privstr.h b/hw/xfree86/common/xf86Privstr.h
index 2eefeaf..f2b8e8a 100644
--- a/hw/xfree86/common/xf86Privstr.h
+++ b/hw/xfree86/common/xf86Privstr.h
@@ -121,7 +121,6 @@ typedef struct {
DisplayModePtr First;
DisplayModePtr Next;
int Flags;
- CloseScreenProcPtr CloseScreen;
} VidModeRec, *VidModePtr;
#endif
diff --git a/hw/xfree86/common/xf86VidMode.c b/hw/xfree86/common/xf86VidMode.c
index b25fe26..04637f1 100644
--- a/hw/xfree86/common/xf86VidMode.c
+++ b/hw/xfree86/common/xf86VidMode.c
@@ -49,7 +49,6 @@
static DevPrivateKeyRec VidModeKeyRec;
#define VidModeKey (&VidModeKeyRec)
-static Bool VidModeClose(ScreenPtr pScreen);
#define VMPTR(p) ((VidModePtr)dixLookupPrivate(&(p)->devPrivates, VidModeKey))
@@ -73,8 +72,6 @@ VidModeExtensionInit(ScreenPtr pScreen)
pVidMode->Flags = 0;
pVidMode->Next = NULL;
- pVidMode->CloseScreen = pScreen->CloseScreen;
- pScreen->CloseScreen = VidModeClose;
return TRUE;
#else
@@ -86,20 +83,6 @@ VidModeExtensionInit(ScreenPtr pScreen)
#ifdef XF86VIDMODE
static Bool
-VidModeClose(ScreenPtr pScreen)
-{
- VidModePtr pVidMode = VMPTR(pScreen);
-
- /* This shouldn't happen */
- if (!pVidMode)
- return FALSE;
-
- pScreen->CloseScreen = pVidMode->CloseScreen;
-
- return pScreen->CloseScreen(pScreen);
-}
-
-static Bool
VidModeAvailable(int scrnIndex)
{
ScrnInfoPtr pScrn;
commit 341f3bccafde71754a9ed2303df9908e509c6d31
Author: Olivier Fourdan <ofourdan at redhat.com>
Date: Fri Feb 5 09:48:15 2016 +0100
vidmode: use appropriate API
dixRegisterPrivateKey() can allocate memory that will be freed when the
screen is teared down.
No need to calloc() and free the memory ourself using a broken ref
counting method.
Reviewed-by: Adam Jackson <ajax at redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan at redhat.com>
diff --git a/hw/xfree86/common/xf86VidMode.c b/hw/xfree86/common/xf86VidMode.c
index 10c7b4b..b25fe26 100644
--- a/hw/xfree86/common/xf86VidMode.c
+++ b/hw/xfree86/common/xf86VidMode.c
@@ -48,8 +48,7 @@
#include "xf86cmap.h"
static DevPrivateKeyRec VidModeKeyRec;
-static DevPrivateKey VidModeKey;
-static int VidModeCount = 0;
+#define VidModeKey (&VidModeKeyRec)
static Bool VidModeClose(ScreenPtr pScreen);
#define VMPTR(p) ((VidModePtr)dixLookupPrivate(&(p)->devPrivates, VidModeKey))
@@ -67,22 +66,16 @@ VidModeExtensionInit(ScreenPtr pScreen)
return FALSE;
}
- VidModeKey = &VidModeKeyRec;
-
- if (!dixRegisterPrivateKey(&VidModeKeyRec, PRIVATE_SCREEN, 0))
+ if (!dixRegisterPrivateKey(&VidModeKeyRec, PRIVATE_SCREEN, sizeof(VidModeRec)))
return FALSE;
- pVidMode = calloc(sizeof(VidModeRec), 1);
- if (!pVidMode)
- return FALSE;
-
- dixSetPrivate(&pScreen->devPrivates, VidModeKey, pVidMode);
+ pVidMode = VMPTR(pScreen);
pVidMode->Flags = 0;
pVidMode->Next = NULL;
pVidMode->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = VidModeClose;
- VidModeCount++;
+
return TRUE;
#else
DebugF("no vidmode extension\n");
@@ -103,11 +96,6 @@ VidModeClose(ScreenPtr pScreen)
pScreen->CloseScreen = pVidMode->CloseScreen;
- if (--VidModeCount == 0) {
- free(dixLookupPrivate(&pScreen->devPrivates, VidModeKey));
- dixSetPrivate(&pScreen->devPrivates, VidModeKey, NULL);
- VidModeKey = NULL;
- }
return pScreen->CloseScreen(pScreen);
}
@@ -117,11 +105,6 @@ VidModeAvailable(int scrnIndex)
ScrnInfoPtr pScrn;
VidModePtr pVidMode;
- if (VidModeKey == NULL) {
- DebugF("VidModeKey == NULL\n");
- return FALSE;
- }
-
pScrn = xf86Screens[scrnIndex];
if (pScrn == NULL) {
DebugF("pScrn == NULL\n");
More information about the xorg-commit
mailing list