2151 lines
69 KiB
C
2151 lines
69 KiB
C
|
|
/*
|
|
|
|
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 "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
|
|
|
|
/* The XF86VIDMODE_EVENTS code is far from complete */
|
|
|
|
#ifdef XF86VIDMODE_EVENTS
|
|
static int XF86VidModeEventBase = 0;
|
|
|
|
static void SXF86VidModeNotifyEvent(xXF86VidModeNotifyEvent * /* from */ , xXF86VidModeNotifyEvent * /* to */
|
|
);
|
|
|
|
static RESTYPE EventType; /* resource type for event masks */
|
|
|
|
typedef struct _XF86VidModeEvent *XF86VidModeEventPtr;
|
|
|
|
typedef struct _XF86VidModeEvent {
|
|
XF86VidModeEventPtr next;
|
|
ClientPtr client;
|
|
ScreenPtr screen;
|
|
XID resource;
|
|
CARD32 mask;
|
|
} XF86VidModeEventRec;
|
|
|
|
static int XF86VidModeFreeEvents();
|
|
|
|
typedef struct _XF86VidModeScreenPrivate {
|
|
XF86VidModeEventPtr events;
|
|
Bool hasWindow;
|
|
} XF86VidModeScreenPrivateRec, *XF86VidModeScreenPrivatePtr;
|
|
|
|
static DevPrivateKeyRec ScreenPrivateKeyRec;
|
|
|
|
#define ScreenPrivateKey (&ScreenPrivateKeyRec)
|
|
|
|
#define GetScreenPrivate(s) ((ScreenSaverScreenPrivatePtr) \
|
|
dixLookupPrivate(&(s)->devPrivates, ScreenPrivateKey))
|
|
#define SetScreenPrivate(s,v) \
|
|
dixSetPrivate(&(s)->devPrivates, ScreenPrivateKey, v)
|
|
#define SetupScreen(s) ScreenSaverScreenPrivatePtr pPriv = GetScreenPrivate(s)
|
|
|
|
#define New(t) (malloc(sizeof (t)))
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
#define DEBUG_P(x) ErrorF(x"\n");
|
|
#else
|
|
#define DEBUG_P(x) /**/
|
|
#endif
|
|
static int
|
|
ClientMajorVersion(ClientPtr client)
|
|
{
|
|
VidModePrivPtr pPriv;
|
|
|
|
pPriv = VM_GETPRIV(client);
|
|
if (!pPriv)
|
|
return 0;
|
|
else
|
|
return pPriv->major;
|
|
}
|
|
|
|
#ifdef XF86VIDMODE_EVENTS
|
|
static void
|
|
CheckScreenPrivate(pScreen)
|
|
ScreenPtr
|
|
pScreen;
|
|
{
|
|
SetupScreen(pScreen);
|
|
|
|
if (!pPriv)
|
|
return;
|
|
if (!pPriv->events && !pPriv->hasWindow) {
|
|
free(pPriv);
|
|
SetScreenPrivate(pScreen, NULL);
|
|
}
|
|
}
|
|
|
|
static XF86VidModeScreenPrivatePtr
|
|
MakeScreenPrivate(pScreen)
|
|
ScreenPtr
|
|
pScreen;
|
|
{
|
|
SetupScreen(pScreen);
|
|
|
|
if (pPriv)
|
|
return pPriv;
|
|
pPriv = New(XF86VidModeScreenPrivateRec);
|
|
if (!pPriv)
|
|
return 0;
|
|
pPriv->events = 0;
|
|
pPriv->hasWindow = FALSE;
|
|
SetScreenPrivate(pScreen, pPriv);
|
|
return pPriv;
|
|
}
|
|
|
|
static unsigned long
|
|
getEventMask(ScreenPtr pScreen, ClientPtr client)
|
|
{
|
|
SetupScreen(pScreen);
|
|
XF86VidModeEventPtr pEv;
|
|
|
|
if (!pPriv)
|
|
return 0;
|
|
for (pEv = pPriv->events; pEv; pEv = pEv->next)
|
|
if (pEv->client == client)
|
|
return pEv->mask;
|
|
return 0;
|
|
}
|
|
|
|
static Bool
|
|
setEventMask(ScreenPtr pScreen, ClientPtr client, unsigned long mask)
|
|
{
|
|
SetupScreen(pScreen);
|
|
XF86VidModeEventPtr pEv, *pPrev;
|
|
|
|
if (getEventMask(pScreen, client) == mask)
|
|
return TRUE;
|
|
if (!pPriv) {
|
|
pPriv = MakeScreenPrivate(pScreen);
|
|
if (!pPriv)
|
|
return FALSE;
|
|
}
|
|
for (pPrev = &pPriv->events; pEv = *pPrev; pPrev = &pEv->next)
|
|
if (pEv->client == client)
|
|
break;
|
|
if (mask == 0) {
|
|
*pPrev = pEv->next;
|
|
free(pEv);
|
|
CheckScreenPrivate(pScreen);
|
|
}
|
|
else {
|
|
if (!pEv) {
|
|
pEv = New(ScreenSaverEventRec);
|
|
if (!pEv) {
|
|
CheckScreenPrivate(pScreen);
|
|
return FALSE;
|
|
}
|
|
*pPrev = pEv;
|
|
pEv->next = NULL;
|
|
pEv->client = client;
|
|
pEv->screen = pScreen;
|
|
pEv->resource = FakeClientID(client->index);
|
|
}
|
|
pEv->mask = mask;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static int
|
|
XF86VidModeFreeEvents(pointer value, XID id)
|
|
{
|
|
XF86VidModeEventPtr pOld = (XF86VidModeEventPtr) value;
|
|
ScreenPtr pScreen = pOld->screen;
|
|
|
|
SetupScreen(pScreen);
|
|
XF86VidModeEventPtr pEv, *pPrev;
|
|
|
|
if (!pPriv)
|
|
return TRUE;
|
|
for (pPrev = &pPriv->events; pEv = *pPrev; pPrev = &pEv->next)
|
|
if (pEv == pOld)
|
|
break;
|
|
if (!pEv)
|
|
return TRUE;
|
|
*pPrev = pEv->next;
|
|
free(pEv);
|
|
CheckScreenPrivate(pScreen);
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
SendXF86VidModeNotify(ScreenPtr pScreen, int state, Bool forced)
|
|
{
|
|
XF86VidModeScreenPrivatePtr pPriv;
|
|
XF86VidModeEventPtr pEv;
|
|
unsigned long mask;
|
|
xXF86VidModeNotifyEvent ev;
|
|
int kind;
|
|
|
|
UpdateCurrentTimeIf();
|
|
mask = XF86VidModeNotifyMask;
|
|
pScreen = screenInfo.screens[pScreen->myNum];
|
|
pPriv = GetScreenPrivate(pScreen);
|
|
if (!pPriv)
|
|
return;
|
|
kind = XF86VidModeModeChange;
|
|
for (pEv = pPriv->events; pEv; pEv = pEv->next) {
|
|
if (!(pEv->mask & mask))
|
|
continue;
|
|
ev.type = XF86VidModeNotify + XF86VidModeEventBase;
|
|
ev.state = state;
|
|
ev.timestamp = currentTime.milliseconds;
|
|
ev.root = pScreen->root->drawable.id;
|
|
ev.kind = kind;
|
|
ev.forced = forced;
|
|
WriteEventsToClient(pEv->client, 1, (xEvent *) &ev);
|
|
}} static void
|
|
|
|
SXF86VidModeNotifyEvent(xXF86VidModeNotifyEvent * from,
|
|
xXF86VidModeNotifyEvent * to)
|
|
{
|
|
to->type = from->type;
|
|
to->state = from->state;
|
|
cpswaps(from->sequenceNumber, to->sequenceNumber);
|
|
cpswapl(from->timestamp, to->timestamp);
|
|
cpswapl(from->root, to->root);
|
|
to->kind = from->kind;
|
|
to->forced = from->forced;
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
ProcXF86VidModeQueryVersion(ClientPtr client)
|
|
{
|
|
xXF86VidModeQueryVersionReply rep;
|
|
|
|
DEBUG_P("XF86VidModeQueryVersion");
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeQueryVersionReq);
|
|
rep.type = X_Reply;
|
|
rep.length = 0;
|
|
rep.sequenceNumber = client->sequence;
|
|
rep.majorVersion = SERVER_XF86VIDMODE_MAJOR_VERSION;
|
|
rep.minorVersion = SERVER_XF86VIDMODE_MINOR_VERSION;
|
|
if (client->swapped) {
|
|
swaps(&rep.sequenceNumber);
|
|
swapl(&rep.length);
|
|
swaps(&rep.majorVersion);
|
|
swaps(&rep.minorVersion);
|
|
}
|
|
WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), (char *) &rep);
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeGetModeLine(ClientPtr client)
|
|
{
|
|
REQUEST(xXF86VidModeGetModeLineReq);
|
|
xXF86VidModeGetModeLineReply rep;
|
|
xXF86OldVidModeGetModeLineReply oldrep;
|
|
pointer mode;
|
|
int dotClock;
|
|
int ver;
|
|
|
|
DEBUG_P("XF86VidModeGetModeline");
|
|
|
|
ver = ClientMajorVersion(client);
|
|
REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
|
|
rep.type = X_Reply;
|
|
if (ver < 2) {
|
|
rep.length = bytes_to_int32(SIZEOF(xXF86OldVidModeGetModeLineReply) -
|
|
SIZEOF(xGenericReply));
|
|
}
|
|
else {
|
|
rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetModeLineReply) -
|
|
SIZEOF(xGenericReply));
|
|
}
|
|
rep.sequenceNumber = client->sequence;
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
if (!VidModeGetCurrentModeline(stuff->screen, &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) {
|
|
oldrep.type = rep.type;
|
|
oldrep.sequenceNumber = rep.sequenceNumber;
|
|
oldrep.length = rep.length;
|
|
oldrep.dotclock = rep.dotclock;
|
|
oldrep.hdisplay = rep.hdisplay;
|
|
oldrep.hsyncstart = rep.hsyncstart;
|
|
oldrep.hsyncend = rep.hsyncend;
|
|
oldrep.htotal = rep.htotal;
|
|
oldrep.vdisplay = rep.vdisplay;
|
|
oldrep.vsyncstart = rep.vsyncstart;
|
|
oldrep.vsyncend = rep.vsyncend;
|
|
oldrep.vtotal = rep.vtotal;
|
|
oldrep.flags = rep.flags;
|
|
oldrep.privsize = rep.privsize;
|
|
WriteToClient(client, sizeof(xXF86OldVidModeGetModeLineReply),
|
|
(char *) &oldrep);
|
|
}
|
|
else {
|
|
WriteToClient(client, sizeof(xXF86VidModeGetModeLineReply),
|
|
(char *) &rep);
|
|
}
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeGetAllModeLines(ClientPtr client)
|
|
{
|
|
REQUEST(xXF86VidModeGetAllModeLinesReq);
|
|
xXF86VidModeGetAllModeLinesReply rep;
|
|
xXF86VidModeModeInfo mdinf;
|
|
xXF86OldVidModeModeInfo oldmdinf;
|
|
pointer mode;
|
|
int modecount, dotClock;
|
|
int ver;
|
|
|
|
DEBUG_P("XF86VidModeGetAllModelines");
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
ver = ClientMajorVersion(client);
|
|
|
|
modecount = VidModeGetNumOfModes(stuff->screen);
|
|
if (modecount < 1)
|
|
return VidModeErrorBase + XF86VidModeExtensionDisabled;
|
|
|
|
if (!VidModeGetFirstModeline(stuff->screen, &mode, &dotClock))
|
|
return BadValue;
|
|
|
|
rep.type = X_Reply;
|
|
rep.length = SIZEOF(xXF86VidModeGetAllModeLinesReply) -
|
|
SIZEOF(xGenericReply);
|
|
if (ver < 2)
|
|
rep.length += modecount * sizeof(xXF86OldVidModeModeInfo);
|
|
else
|
|
rep.length += modecount * sizeof(xXF86VidModeModeInfo);
|
|
rep.length >>= 2;
|
|
rep.sequenceNumber = client->sequence;
|
|
rep.modecount = modecount;
|
|
if (client->swapped) {
|
|
swaps(&rep.sequenceNumber);
|
|
swapl(&rep.length);
|
|
swapl(&rep.modecount);
|
|
}
|
|
WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply),
|
|
(char *) &rep);
|
|
|
|
do {
|
|
mdinf.dotclock = dotClock;
|
|
mdinf.hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY);
|
|
mdinf.hsyncstart = VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART);
|
|
mdinf.hsyncend = VidModeGetModeValue(mode, VIDMODE_H_SYNCEND);
|
|
mdinf.htotal = VidModeGetModeValue(mode, VIDMODE_H_TOTAL);
|
|
mdinf.hskew = VidModeGetModeValue(mode, VIDMODE_H_SKEW);
|
|
mdinf.vdisplay = VidModeGetModeValue(mode, VIDMODE_V_DISPLAY);
|
|
mdinf.vsyncstart = VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART);
|
|
mdinf.vsyncend = VidModeGetModeValue(mode, VIDMODE_V_SYNCEND);
|
|
mdinf.vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL);
|
|
mdinf.flags = VidModeGetModeValue(mode, VIDMODE_FLAGS);
|
|
mdinf.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) {
|
|
oldmdinf.dotclock = mdinf.dotclock;
|
|
oldmdinf.hdisplay = mdinf.hdisplay;
|
|
oldmdinf.hsyncstart = mdinf.hsyncstart;
|
|
oldmdinf.hsyncend = mdinf.hsyncend;
|
|
oldmdinf.htotal = mdinf.htotal;
|
|
oldmdinf.vdisplay = mdinf.vdisplay;
|
|
oldmdinf.vsyncstart = mdinf.vsyncstart;
|
|
oldmdinf.vsyncend = mdinf.vsyncend;
|
|
oldmdinf.vtotal = mdinf.vtotal;
|
|
oldmdinf.flags = mdinf.flags;
|
|
oldmdinf.privsize = mdinf.privsize;
|
|
WriteToClient(client, sizeof(xXF86OldVidModeModeInfo),
|
|
(char *) &oldmdinf);
|
|
}
|
|
else {
|
|
WriteToClient(client, sizeof(xXF86VidModeModeInfo),
|
|
(char *) &mdinf);
|
|
}
|
|
|
|
} while (VidModeGetNextModeline(stuff->screen, &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;
|
|
pointer 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;
|
|
|
|
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 (VidModeGetFirstModeline(stuff->screen, &mode, &dotClock)) {
|
|
do {
|
|
if ((VidModeGetDotClock(stuff->screen, stuff->dotclock)
|
|
== dotClock) && MODEMATCH(mode, stuff)) {
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
} while (VidModeGetNextModeline(stuff->screen, &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 (VidModeCheckModeForMonitor(stuff->screen, 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 (VidModeCheckModeForDriver(stuff->screen, mode) != MODE_OK) {
|
|
free(mode);
|
|
return VidModeErrorBase + XF86VidModeModeUnsuitable;
|
|
}
|
|
|
|
VidModeSetCrtcForMode(stuff->screen, mode);
|
|
|
|
VidModeAddModeline(stuff->screen, 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;
|
|
pointer 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;
|
|
|
|
if (!VidModeGetCurrentModeline(stuff->screen, &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 ((VidModeGetDotClock(stuff->screen, stuff->dotclock) == dotClock) &&
|
|
MODEMATCH(mode, stuff))
|
|
return BadValue;
|
|
|
|
if (!VidModeGetFirstModeline(stuff->screen, &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 ((VidModeGetDotClock(stuff->screen, stuff->dotclock) == dotClock) &&
|
|
MODEMATCH(mode, stuff)) {
|
|
VidModeDeleteModeline(stuff->screen, mode);
|
|
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
|
|
ErrorF("DeleteModeLine - Succeeded\n");
|
|
return Success;
|
|
}
|
|
} while (VidModeGetNextModeline(stuff->screen, &mode, &dotClock));
|
|
|
|
return BadValue;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeModModeLine(ClientPtr client)
|
|
{
|
|
REQUEST(xXF86VidModeModModeLineReq);
|
|
xXF86OldVidModeModModeLineReq *oldstuff =
|
|
(xXF86OldVidModeModModeLineReq *) client->requestBuffer;
|
|
xXF86VidModeModModeLineReq newstuff;
|
|
pointer 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;
|
|
|
|
if (!VidModeGetCurrentModeline(stuff->screen, &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 (VidModeCheckModeForMonitor(stuff->screen, 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 (VidModeCheckModeForDriver(stuff->screen, 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);
|
|
|
|
VidModeSetCrtcForMode(stuff->screen, mode);
|
|
VidModeSwitchMode(stuff->screen, 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;
|
|
pointer 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;
|
|
|
|
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 (!VidModeGetCurrentModeline(stuff->screen, &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 =
|
|
VidModeCheckModeForMonitor(stuff->screen, modetmp)) != MODE_OK)
|
|
goto status_reply;
|
|
|
|
/* Check that the driver is happy with the mode */
|
|
status = VidModeCheckModeForDriver(stuff->screen, modetmp);
|
|
|
|
status_reply:
|
|
free(modetmp);
|
|
|
|
rep.type = X_Reply;
|
|
rep.length = bytes_to_int32(SIZEOF(xXF86VidModeValidateModeLineReply)
|
|
- SIZEOF(xGenericReply));
|
|
rep.sequenceNumber = client->sequence;
|
|
rep.status = status;
|
|
if (client->swapped) {
|
|
swaps(&rep.sequenceNumber);
|
|
swapl(&rep.length);
|
|
swapl(&rep.status);
|
|
}
|
|
WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply),
|
|
(char *) &rep);
|
|
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
|
|
ErrorF("ValidateModeLine - Succeeded (status = %d)\n", status);
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeSwitchMode(ClientPtr client)
|
|
{
|
|
REQUEST(xXF86VidModeSwitchModeReq);
|
|
|
|
DEBUG_P("XF86VidModeSwitchMode");
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq);
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
VidModeZoomViewport(stuff->screen, (short) stuff->zoom);
|
|
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeSwitchToMode(ClientPtr client)
|
|
{
|
|
REQUEST(xXF86VidModeSwitchToModeReq);
|
|
xXF86OldVidModeSwitchToModeReq *oldstuff =
|
|
(xXF86OldVidModeSwitchToModeReq *) client->requestBuffer;
|
|
xXF86VidModeSwitchToModeReq newstuff;
|
|
pointer 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;
|
|
|
|
if (!VidModeGetCurrentModeline(stuff->screen, &mode, &dotClock))
|
|
return BadValue;
|
|
|
|
if ((VidModeGetDotClock(stuff->screen, stuff->dotclock) == dotClock)
|
|
&& MODEMATCH(mode, stuff))
|
|
return Success;
|
|
|
|
if (!VidModeGetFirstModeline(stuff->screen, &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 ((VidModeGetDotClock(stuff->screen, stuff->dotclock) == dotClock) &&
|
|
MODEMATCH(mode, stuff)) {
|
|
|
|
if (!VidModeSwitchMode(stuff->screen, mode))
|
|
return BadValue;
|
|
|
|
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
|
|
ErrorF("SwitchToMode - Succeeded\n");
|
|
return Success;
|
|
}
|
|
} while (VidModeGetNextModeline(stuff->screen, &mode, &dotClock));
|
|
|
|
return BadValue;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeLockModeSwitch(ClientPtr client)
|
|
{
|
|
REQUEST(xXF86VidModeLockModeSwitchReq);
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
|
|
|
|
DEBUG_P("XF86VidModeLockModeSwitch");
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
if (!VidModeLockZoom(stuff->screen, (short) stuff->lock))
|
|
return VidModeErrorBase + XF86VidModeZoomLocked;
|
|
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeGetMonitor(ClientPtr client)
|
|
{
|
|
REQUEST(xXF86VidModeGetMonitorReq);
|
|
xXF86VidModeGetMonitorReply rep;
|
|
CARD32 *hsyncdata, *vsyncdata;
|
|
int i, nHsync, nVrefresh;
|
|
pointer monitor;
|
|
|
|
DEBUG_P("XF86VidModeGetMonitor");
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq);
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
if (!VidModeGetMonitor(stuff->screen, &monitor))
|
|
return BadValue;
|
|
|
|
nHsync = VidModeGetMonitorValue(monitor, VIDMODE_MON_NHSYNC, 0).i;
|
|
nVrefresh = VidModeGetMonitorValue(monitor, VIDMODE_MON_NVREFRESH, 0).i;
|
|
|
|
rep.type = X_Reply;
|
|
if ((char *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VENDOR, 0)).ptr)
|
|
rep.vendorLength = strlen((char *) (VidModeGetMonitorValue(monitor,
|
|
VIDMODE_MON_VENDOR,
|
|
0)).ptr);
|
|
else
|
|
rep.vendorLength = 0;
|
|
if ((char *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_MODEL, 0)).ptr)
|
|
rep.modelLength = strlen((char *) (VidModeGetMonitorValue(monitor,
|
|
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.sequenceNumber = client->sequence;
|
|
rep.nhsync = nHsync;
|
|
rep.nvsync = nVrefresh;
|
|
hsyncdata = malloc(nHsync * sizeof(CARD32));
|
|
if (!hsyncdata) {
|
|
return BadAlloc;
|
|
}
|
|
vsyncdata = malloc(nVrefresh * sizeof(CARD32));
|
|
|
|
if (!vsyncdata) {
|
|
free(hsyncdata);
|
|
return BadAlloc;
|
|
}
|
|
|
|
for (i = 0; i < nHsync; i++) {
|
|
hsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(monitor,
|
|
VIDMODE_MON_HSYNC_LO,
|
|
i)).f |
|
|
(unsigned
|
|
short) (VidModeGetMonitorValue(monitor, VIDMODE_MON_HSYNC_HI,
|
|
i)).f << 16;
|
|
}
|
|
for (i = 0; i < nVrefresh; i++) {
|
|
vsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(monitor,
|
|
VIDMODE_MON_VREFRESH_LO,
|
|
i)).f |
|
|
(unsigned
|
|
short) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VREFRESH_HI,
|
|
i)).f << 16;
|
|
}
|
|
|
|
if (client->swapped) {
|
|
swaps(&rep.sequenceNumber);
|
|
swapl(&rep.length);
|
|
}
|
|
WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply), (char *) &rep);
|
|
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
|
|
WriteSwappedDataToClient(client, nHsync * sizeof(CARD32), hsyncdata);
|
|
WriteSwappedDataToClient(client, nVrefresh * sizeof(CARD32), vsyncdata);
|
|
if (rep.vendorLength)
|
|
WriteToClient(client, rep.vendorLength,
|
|
(char
|
|
*) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VENDOR,
|
|
0)).ptr);
|
|
if (rep.modelLength)
|
|
WriteToClient(client, rep.modelLength,
|
|
(char
|
|
*) (VidModeGetMonitorValue(monitor, VIDMODE_MON_MODEL,
|
|
0)).ptr);
|
|
|
|
free(hsyncdata);
|
|
free(vsyncdata);
|
|
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeGetViewPort(ClientPtr client)
|
|
{
|
|
REQUEST(xXF86VidModeGetViewPortReq);
|
|
xXF86VidModeGetViewPortReply rep;
|
|
int x, y;
|
|
|
|
DEBUG_P("XF86VidModeGetViewPort");
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq);
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
rep.type = X_Reply;
|
|
rep.length = 0;
|
|
rep.sequenceNumber = client->sequence;
|
|
|
|
VidModeGetViewPort(stuff->screen, &x, &y);
|
|
rep.x = x;
|
|
rep.y = y;
|
|
|
|
if (client->swapped) {
|
|
swaps(&rep.sequenceNumber);
|
|
swapl(&rep.length);
|
|
swapl(&rep.x);
|
|
swapl(&rep.y);
|
|
}
|
|
WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), (char *) &rep);
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeSetViewPort(ClientPtr client)
|
|
{
|
|
REQUEST(xXF86VidModeSetViewPortReq);
|
|
|
|
DEBUG_P("XF86VidModeSetViewPort");
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq);
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
if (!VidModeSetViewPort(stuff->screen, stuff->x, stuff->y))
|
|
return BadValue;
|
|
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeGetDotClocks(ClientPtr client)
|
|
{
|
|
REQUEST(xXF86VidModeGetDotClocksReq);
|
|
xXF86VidModeGetDotClocksReply rep;
|
|
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;
|
|
|
|
numClocks = VidModeGetNumOfClocks(stuff->screen, &ClockProg);
|
|
|
|
rep.type = X_Reply;
|
|
rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetDotClocksReply)
|
|
- SIZEOF(xGenericReply) + numClocks);
|
|
rep.sequenceNumber = client->sequence;
|
|
rep.clocks = numClocks;
|
|
rep.maxclocks = MAXCLOCKS;
|
|
rep.flags = 0;
|
|
|
|
if (!ClockProg) {
|
|
Clocks = malloc(numClocks * sizeof(int));
|
|
if (!Clocks)
|
|
return BadValue;
|
|
if (!VidModeGetClocks(stuff->screen, 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), (char *) &rep);
|
|
if (!ClockProg) {
|
|
for (n = 0; n < numClocks; n++) {
|
|
dotclock = *Clocks++;
|
|
if (client->swapped) {
|
|
WriteSwappedDataToClient(client, 4, (char *) &dotclock);
|
|
}
|
|
else {
|
|
WriteToClient(client, 4, (char *) &dotclock);
|
|
}
|
|
}
|
|
}
|
|
|
|
free(Clocks);
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeSetGamma(ClientPtr client)
|
|
{
|
|
REQUEST(xXF86VidModeSetGammaReq);
|
|
|
|
DEBUG_P("XF86VidModeSetGamma");
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq);
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
if (!VidModeSetGamma(stuff->screen, ((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;
|
|
float red, green, blue;
|
|
|
|
DEBUG_P("XF86VidModeGetGamma");
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq);
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
rep.type = X_Reply;
|
|
rep.length = 0;
|
|
rep.sequenceNumber = client->sequence;
|
|
if (!VidModeGetGamma(stuff->screen, &red, &green, &blue))
|
|
return BadValue;
|
|
rep.red = (CARD32) (red * 10000.);
|
|
rep.green = (CARD32) (green * 10000.);
|
|
rep.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), (char *) &rep);
|
|
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeSetGammaRamp(ClientPtr client)
|
|
{
|
|
CARD16 *r, *g, *b;
|
|
int length;
|
|
|
|
REQUEST(xXF86VidModeSetGammaRampReq);
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
if (stuff->size != VidModeGetGammaRampSize(stuff->screen))
|
|
return BadValue;
|
|
|
|
length = (stuff->size + 1) & ~1;
|
|
|
|
REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length * 6);
|
|
|
|
r = (CARD16 *) &stuff[1];
|
|
g = r + length;
|
|
b = g + length;
|
|
|
|
if (!VidModeSetGammaRamp(stuff->screen, 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;
|
|
|
|
REQUEST(xXF86VidModeGetGammaRampReq);
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
if (stuff->size != VidModeGetGammaRampSize(stuff->screen))
|
|
return BadValue;
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq);
|
|
|
|
length = (stuff->size + 1) & ~1;
|
|
|
|
if (stuff->size) {
|
|
ramplen = length * 3 * sizeof(CARD16);
|
|
if (!(ramp = malloc(ramplen)))
|
|
return BadAlloc;
|
|
|
|
if (!VidModeGetGammaRamp(stuff->screen, stuff->size,
|
|
ramp, ramp + length, ramp + (length * 2))) {
|
|
free(ramp);
|
|
return BadValue;
|
|
}
|
|
}
|
|
rep.type = X_Reply;
|
|
rep.length = (length >> 1) * 3;
|
|
rep.sequenceNumber = client->sequence;
|
|
rep.size = stuff->size;
|
|
if (client->swapped) {
|
|
swaps(&rep.sequenceNumber);
|
|
swapl(&rep.length);
|
|
swaps(&rep.size);
|
|
SwapShorts((short *) ramp, length * 3);
|
|
}
|
|
WriteToClient(client, sizeof(xXF86VidModeGetGammaRampReply), (char *) &rep);
|
|
|
|
if (stuff->size) {
|
|
WriteToClient(client, ramplen, (char *) ramp);
|
|
free(ramp);
|
|
}
|
|
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeGetGammaRampSize(ClientPtr client)
|
|
{
|
|
xXF86VidModeGetGammaRampSizeReply rep;
|
|
|
|
REQUEST(xXF86VidModeGetGammaRampSizeReq);
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq);
|
|
|
|
rep.type = X_Reply;
|
|
rep.length = 0;
|
|
rep.sequenceNumber = client->sequence;
|
|
rep.size = VidModeGetGammaRampSize(stuff->screen);
|
|
if (client->swapped) {
|
|
swaps(&rep.sequenceNumber);
|
|
swapl(&rep.length);
|
|
swaps(&rep.size);
|
|
}
|
|
WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply),
|
|
(char *) &rep);
|
|
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
ProcXF86VidModeGetPermissions(ClientPtr client)
|
|
{
|
|
xXF86VidModeGetPermissionsReply rep;
|
|
|
|
REQUEST(xXF86VidModeGetPermissionsReq);
|
|
|
|
if (stuff->screen >= screenInfo.numScreens)
|
|
return BadValue;
|
|
|
|
REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq);
|
|
|
|
rep.type = X_Reply;
|
|
rep.length = 0;
|
|
rep.sequenceNumber = client->sequence;
|
|
rep.permissions = XF86VM_READ_PERMISSION;
|
|
if (xf86GetVidModeEnabled() &&
|
|
(xf86GetVidModeAllowNonLocal() || LocalClient(client))) {
|
|
rep.permissions |= XF86VM_WRITE_PERMISSION;
|
|
}
|
|
if (client->swapped) {
|
|
swaps(&rep.sequenceNumber);
|
|
swapl(&rep.length);
|
|
swapl(&rep.permissions);
|
|
}
|
|
WriteToClient(client, sizeof(xXF86VidModeGetPermissionsReply),
|
|
(char *) &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() || LocalClient(client)) {
|
|
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() || LocalClient(client)) {
|
|
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;
|
|
#ifdef XF86VIDMODE_EVENTS
|
|
if (!dixRegisterPrivateKey(&ScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
|
|
return;
|
|
#endif
|
|
|
|
#ifdef XF86VIDMODE_EVENTS
|
|
EventType = CreateNewResourceType(XF86VidModeFreeEvents, "VidModeEvent");
|
|
#endif
|
|
|
|
for (i = 0; i < screenInfo.numScreens; i++) {
|
|
pScreen = screenInfo.screens[i];
|
|
if (VidModeExtensionInit(pScreen))
|
|
enabled = TRUE;
|
|
}
|
|
/* This means that the DDX doesn't want the vidmode extension enabled */
|
|
if (!enabled)
|
|
return;
|
|
|
|
if (
|
|
#ifdef XF86VIDMODE_EVENTS
|
|
EventType &&
|
|
#endif
|
|
(extEntry = AddExtension(XF86VIDMODENAME,
|
|
XF86VidModeNumberEvents,
|
|
XF86VidModeNumberErrors,
|
|
ProcXF86VidModeDispatch,
|
|
SProcXF86VidModeDispatch,
|
|
NULL, StandardMinorOpcode))) {
|
|
#if 0
|
|
XF86VidModeReqCode = (unsigned char) extEntry->base;
|
|
#endif
|
|
VidModeErrorBase = extEntry->errorBase;
|
|
#ifdef XF86VIDMODE_EVENTS
|
|
XF86VidModeEventBase = extEntry->eventBase;
|
|
EventSwapVector[XF86VidModeEventBase] =
|
|
(EventSwapPtr) SXF86VidModeNotifyEvent;
|
|
#endif
|
|
}
|
|
}
|