diff options
Diffstat (limited to 'xserver/Xext/vidmode.c')
| -rw-r--r-- | xserver/Xext/vidmode.c | 2151 |
1 files changed, 2151 insertions, 0 deletions
diff --git a/xserver/Xext/vidmode.c b/xserver/Xext/vidmode.c new file mode 100644 index 000000000..499a2a841 --- /dev/null +++ b/xserver/Xext/vidmode.c @@ -0,0 +1,2151 @@ +/* + +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 + +#ifdef XF86VIDMODE + +#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) DebugF(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); + + DebugF("GetModeLine - scrn: %d clock: %ld\n", + stuff->screen, (unsigned long) rep.dotclock); + DebugF("GetModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n", + rep.hdisplay, rep.hsyncstart, rep.hsyncend, rep.htotal); + DebugF(" 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; + } + DebugF("AddModeLine - scrn: %d clock: %ld\n", + (int) stuff->screen, (unsigned long) stuff->dotclock); + DebugF("AddModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n", + stuff->hdisplay, stuff->hsyncstart, + stuff->hsyncend, stuff->htotal); + DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n", + stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, + stuff->vtotal, (unsigned long) stuff->flags); + DebugF(" after - scrn: %d clock: %ld\n", + (int) stuff->screen, (unsigned long) stuff->after_dotclock); + DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", + stuff->after_hdisplay, stuff->after_hsyncstart, + stuff->after_hsyncend, stuff->after_htotal); + DebugF(" 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) + DebugF("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); + + DebugF("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; + } + DebugF("DeleteModeLine - scrn: %d clock: %ld\n", + (int) stuff->screen, (unsigned long) stuff->dotclock); + DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", + stuff->hdisplay, stuff->hsyncstart, + stuff->hsyncend, stuff->htotal); + DebugF(" 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) { + DebugF("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; + + DebugF("Checking against clock: %d (%d)\n", + VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock); + DebugF(" 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)); + DebugF(" 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 { + DebugF("Checking against clock: %d (%d)\n", + VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock); + DebugF(" 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)); + DebugF(" 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); + DebugF("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; + } + DebugF("ModModeLine - scrn: %d hdsp: %d hbeg: %d hend: %d httl: %d\n", + (int) stuff->screen, stuff->hdisplay, stuff->hsyncstart, + stuff->hsyncend, stuff->htotal); + DebugF(" 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) + DebugF("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); + + DebugF("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; + } + + DebugF("ValidateModeLine - scrn: %d clock: %ld\n", + (int) stuff->screen, (unsigned long) stuff->dotclock); + DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", + stuff->hdisplay, stuff->hsyncstart, + stuff->hsyncend, stuff->htotal); + DebugF(" 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) + DebugF("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); + DebugF("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; + } + + DebugF("SwitchToMode - scrn: %d clock: %ld\n", + (int) stuff->screen, (unsigned long) stuff->dotclock); + DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", + stuff->hdisplay, stuff->hsyncstart, + stuff->hsyncend, stuff->htotal); + DebugF(" 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 { + DebugF("Checking against clock: %d (%d)\n", + VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock); + DebugF(" 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)); + DebugF(" 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; + + DebugF("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); +} + +#endif /* XF86VIDMODE */ |