diff options
Diffstat (limited to 'hw/xfree86/dixmods/extmod/xf86vmode.c')
| -rw-r--r-- | hw/xfree86/dixmods/extmod/xf86vmode.c | 2458 |
1 files changed, 1188 insertions, 1270 deletions
diff --git a/hw/xfree86/dixmods/extmod/xf86vmode.c b/hw/xfree86/dixmods/extmod/xf86vmode.c index 6d3d5fcbc..6e2a8e9b2 100644 --- a/hw/xfree86/dixmods/extmod/xf86vmode.c +++ b/hw/xfree86/dixmods/extmod/xf86vmode.c @@ -52,12 +52,13 @@ from Kaleb S. KEITHLEY static int VidModeErrorBase; static DevPrivateKeyRec VidModeClientPrivateKeyRec; + #define VidModeClientPrivateKey (&VidModeClientPrivateKeyRec) /* This holds the client's version information */ typedef struct { - int major; - int minor; + int major; + int minor; } VidModePrivRec, *VidModePrivPtr; #define VM_GETPRIV(c) ((VidModePrivPtr) \ @@ -65,7 +66,6 @@ typedef struct { #define VM_SETPRIV(c,p) \ dixSetPrivate(&(c)->devPrivates, VidModeClientPrivateKey, p) - #if 0 static unsigned char XF86VidModeReqCode = 0; #endif @@ -76,30 +76,30 @@ static unsigned char XF86VidModeReqCode = 0; static int XF86VidModeEventBase = 0; static void SXF86VidModeNotifyEvent(); - xXF86VidModeNotifyEvent * /* from */, - xXF86VidModeNotifyEvent * /* to */ -); +xXF86VidModeNotifyEvent * /* from */ , xXF86VidModeNotifyEvent * /* to */ + ); -static RESTYPE EventType; /* resource type for event masks */ +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; + XF86VidModeEventPtr next; + ClientPtr client; + ScreenPtr screen; + XID resource; + CARD32 mask; } XF86VidModeEventRec; static int XF86VidModeFreeEvents(); typedef struct _XF86VidModeScreenPrivate { - XF86VidModeEventPtr events; - Bool hasWindow; + XF86VidModeEventPtr events; + Bool hasWindow; } XF86VidModeScreenPrivateRec, *XF86VidModeScreenPrivatePtr; static DevPrivateKeyRec ScreenPrivateKeyRec; + #define ScreenPrivateKey (&ScreenPrivateKeyRec) #define GetScreenPrivate(s) ((ScreenSaverScreenPrivatePtr) \ @@ -112,198 +112,181 @@ static DevPrivateKeyRec ScreenPrivateKeyRec; #endif #ifdef DEBUG -# define DEBUG_P(x) ErrorF(x"\n"); +#define DEBUG_P(x) ErrorF(x"\n"); #else -# define DEBUG_P(x) /**/ +#define DEBUG_P(x) /**/ #endif - -static int -ClientMajorVersion(ClientPtr client) -{ + static int + ClientMajorVersion(ClientPtr client) { VidModePrivPtr pPriv; - pPriv = VM_GETPRIV(client); + pPriv = VM_GETPRIV(client); if (!pPriv) - return 0; + return 0; else - return pPriv->major; + return pPriv->major; } - #ifdef XF86VIDMODE_EVENTS static void -CheckScreenPrivate (pScreen) - ScreenPtr pScreen; + CheckScreenPrivate(pScreen) +ScreenPtr + pScreen; { - SetupScreen (pScreen); + SetupScreen(pScreen); if (!pPriv) - return; + return; if (!pPriv->events && !pPriv->hasWindow) { - free(pPriv); - SetScreenPrivate (pScreen, NULL); + free(pPriv); + SetScreenPrivate(pScreen, NULL); } } - -static XF86VidModeScreenPrivatePtr -MakeScreenPrivate (pScreen) - ScreenPtr pScreen; + +static XF86VidModeScreenPrivatePtr MakeScreenPrivate(pScreen) +ScreenPtr + pScreen; { - SetupScreen (pScreen); + SetupScreen(pScreen); if (pPriv) - return pPriv; - pPriv = New (XF86VidModeScreenPrivateRec); + return pPriv; + pPriv = New(XF86VidModeScreenPrivateRec); if (!pPriv) - return 0; + return 0; pPriv->events = 0; pPriv->hasWindow = FALSE; - SetScreenPrivate (pScreen, pPriv); + SetScreenPrivate(pScreen, pPriv); return pPriv; } static unsigned long -getEventMask (ScreenPtr pScreen, ClientPtr client) -{ + getEventMask(ScreenPtr pScreen, ClientPtr client) { SetupScreen(pScreen); XF86VidModeEventPtr pEv; if (!pPriv) - return 0; + 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) -{ + 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 (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; + 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; + *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; + XF86VidModeFreeEvents(pointer value, XID id) { + XF86VidModeEventPtr pOld = (XF86VidModeEventPtr) value; ScreenPtr pScreen = pOld->screen; - SetupScreen (pScreen); - XF86VidModeEventPtr pEv, *pPrev; + SetupScreen(pScreen); + XF86VidModeEventPtr pEv, *pPrev; if (!pPriv) - return TRUE; + return TRUE; for (pPrev = &pPriv->events; pEv = *pPrev; pPrev = &pEv->next) - if (pEv == pOld) - break; + if (pEv == pOld) + break; if (!pEv) - return TRUE; + 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); + 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) -{ + 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); + 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) -{ + ProcXF86VidModeQueryVersion(ClientPtr client) { xXF86VidModeQueryVersionReply rep; - DEBUG_P("XF86VidModeQueryVersion"); + 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; + 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); + 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) -{ + ProcXF86VidModeGetModeLine(ClientPtr client) { REQUEST(xXF86VidModeGetModeLineReq); xXF86VidModeGetModeLineReply rep; xXF86OldVidModeGetModeLineReply oldrep; @@ -311,25 +294,26 @@ ProcXF86VidModeGetModeLine(ClientPtr client) int dotClock; int ver; - DEBUG_P("XF86VidModeGetModeline"); + DEBUG_P("XF86VidModeGetModeline"); - ver = ClientMajorVersion(client); - REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq); - rep.type = X_Reply; + 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.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) + if (stuff->screen >= screenInfo.numScreens) return BadValue; if (!VidModeGetCurrentModeline(stuff->screen, &mode, &dotClock)) - return BadValue; + return BadValue; rep.dotclock = dotClock; rep.hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY); @@ -344,16 +328,15 @@ ProcXF86VidModeGetModeLine(ClientPtr client) 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); + 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 @@ -362,48 +345,48 @@ ProcXF86VidModeGetModeLine(ClientPtr 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); + 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); + 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) -{ + ProcXF86VidModeGetAllModeLines(ClientPtr client) { REQUEST(xXF86VidModeGetAllModeLinesReq); xXF86VidModeGetAllModeLinesReply rep; xXF86VidModeModeInfo mdinf; @@ -412,85 +395,87 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client) int modecount, dotClock; int ver; - DEBUG_P("XF86VidModeGetAllModelines"); + DEBUG_P("XF86VidModeGetAllModelines"); - REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq); + REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq); - if(stuff->screen >= screenInfo.numScreens) - return BadValue; + if (stuff->screen >= screenInfo.numScreens) + return BadValue; - ver = ClientMajorVersion(client); + ver = ClientMajorVersion(client); - modecount = VidModeGetNumOfModes(stuff->screen); + modecount = VidModeGetNumOfModes(stuff->screen); if (modecount < 1) - return VidModeErrorBase + XF86VidModeExtensionDisabled; + return VidModeErrorBase + XF86VidModeExtensionDisabled; if (!VidModeGetFirstModeline(stuff->screen, &mode, &dotClock)) - return BadValue; - - rep.type = X_Reply; - rep.length = SIZEOF(xXF86VidModeGetAllModeLinesReply) - - SIZEOF(xGenericReply); + return BadValue; + + rep.type = X_Reply; + rep.length = SIZEOF(xXF86VidModeGetAllModeLinesReply) - + SIZEOF(xGenericReply); if (ver < 2) - rep.length += modecount * sizeof(xXF86OldVidModeModeInfo); + rep.length += modecount * sizeof(xXF86OldVidModeModeInfo); else - rep.length += modecount * sizeof(xXF86VidModeModeInfo); - rep.length >>= 2; - rep.sequenceNumber = client->sequence; - rep.modecount = modecount; + 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); + 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; + 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; + 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); - } + (char *) &oldmdinf); + } + else { + WriteToClient(client, sizeof(xXF86VidModeModeInfo), + (char *) &mdinf); + } - } while (VidModeGetNextModeline(stuff->screen, &mode, &dotClock)); + } while (VidModeGetNextModeline(stuff->screen, &mode, &dotClock)); return Success; } @@ -507,394 +492,404 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client) && VidModeGetModeValue(mode, VIDMODE_FLAGS) == stuff->flags ) static int -ProcXF86VidModeAddModeLine(ClientPtr client) -{ + ProcXF86VidModeAddModeLine(ClientPtr client) { REQUEST(xXF86VidModeAddModeLineReq); xXF86OldVidModeAddModeLineReq *oldstuff = - (xXF86OldVidModeAddModeLineReq *)client->requestBuffer; + (xXF86OldVidModeAddModeLineReq *) client->requestBuffer; xXF86VidModeAddModeLineReq newstuff; pointer mode; int len; int dotClock; int ver; - DEBUG_P("XF86VidModeAddModeline"); + DEBUG_P("XF86VidModeAddModeline"); - ver = ClientMajorVersion(client); + 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); + /* 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)); + 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; + return BadLength; + + if (stuff->screen >= screenInfo.numScreens) + return BadValue; - if(stuff->screen >= screenInfo.numScreens) + 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->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_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; + 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; + 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_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_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"); + 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; + 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; + free(mode); + return VidModeErrorBase + XF86VidModeModeUnsuitable; } VidModeSetCrtcForMode(stuff->screen, mode); - + VidModeAddModeline(stuff->screen, mode); - + if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) - ErrorF("AddModeLine - Succeeded\n"); + ErrorF("AddModeLine - Succeeded\n"); return Success; } static int -ProcXF86VidModeDeleteModeLine(ClientPtr client) -{ + ProcXF86VidModeDeleteModeLine(ClientPtr client) { REQUEST(xXF86VidModeDeleteModeLineReq); xXF86OldVidModeDeleteModeLineReq *oldstuff = - (xXF86OldVidModeDeleteModeLineReq *)client->requestBuffer; + (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer; xXF86VidModeDeleteModeLineReq newstuff; pointer mode; int len, dotClock; int ver; - DEBUG_P("XF86VidModeDeleteModeline"); + DEBUG_P("XF86VidModeDeleteModeline"); - ver = ClientMajorVersion(client); + 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); + /* 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)); + 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 (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) + if (stuff->screen >= screenInfo.numScreens) return BadValue; if (!VidModeGetCurrentModeline(stuff->screen, &mode, &dotClock)) - return BadValue; + 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)); + 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; + 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; - } + 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) -{ + ProcXF86VidModeModModeLine(ClientPtr client) { REQUEST(xXF86VidModeModModeLineReq); xXF86OldVidModeModModeLineReq *oldstuff = - (xXF86OldVidModeModModeLineReq *)client->requestBuffer; + (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); + 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)); + 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; + 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->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) + if (stuff->screen >= screenInfo.numScreens) return BadValue; if (!VidModeGetCurrentModeline(stuff->screen, &mode, &dotClock)) - return BadValue; + 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_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_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"); + 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; + 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); + return VidModeErrorBase + XF86VidModeModeUnsuitable; } free(modetmp); VidModeSetModeValue(mode, VIDMODE_H_DISPLAY, stuff->hdisplay); - VidModeSetModeValue(mode, VIDMODE_H_SYNCSTART, stuff->hsyncstart); + 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_SYNCSTART, stuff->vsyncstart); VidModeSetModeValue(mode, VIDMODE_V_SYNCEND, stuff->vsyncend); VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal); VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags); @@ -903,337 +898,349 @@ ProcXF86VidModeModModeLine(ClientPtr client) VidModeSwitchMode(stuff->screen, mode); if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) - ErrorF("ModModeLine - Succeeded\n"); + ErrorF("ModModeLine - Succeeded\n"); return Success; } static int -ProcXF86VidModeValidateModeLine(ClientPtr client) -{ + ProcXF86VidModeValidateModeLine(ClientPtr client) { REQUEST(xXF86VidModeValidateModeLineReq); xXF86OldVidModeValidateModeLineReq *oldstuff = - (xXF86OldVidModeValidateModeLineReq *)client->requestBuffer; + (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer; xXF86VidModeValidateModeLineReq newstuff; xXF86VidModeValidateModeLineReply rep; pointer mode, modetmp = NULL; int len, status, dotClock; int ver; - DEBUG_P("XF86VidModeValidateModeline"); + DEBUG_P("XF86VidModeValidateModeline"); - ver = ClientMajorVersion(client); + 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); + /* 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)); + 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; + return BadLength; - if(stuff->screen >= screenInfo.numScreens) + 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 (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; + 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_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_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"); + 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; + 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: + status_reply: free(modetmp); rep.type = X_Reply; rep.length = bytes_to_int32(SIZEOF(xXF86VidModeValidateModeLineReply) - - SIZEOF(xGenericReply)); + - SIZEOF(xGenericReply)); rep.sequenceNumber = client->sequence; rep.status = status; if (client->swapped) { - swaps(&rep.sequenceNumber); - swapl(&rep.length); - swapl(&rep.status); + swaps(&rep.sequenceNumber); + swapl(&rep.length); + swapl(&rep.status); } - WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply), (char *)&rep); + WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply), + (char *) &rep); if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) - ErrorF("ValidateModeLine - Succeeded (status = %d)\n", status); + ErrorF("ValidateModeLine - Succeeded (status = %d)\n", status); return Success; } static int -ProcXF86VidModeSwitchMode(ClientPtr client) -{ + ProcXF86VidModeSwitchMode(ClientPtr client) { REQUEST(xXF86VidModeSwitchModeReq); DEBUG_P("XF86VidModeSwitchMode"); REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq); - if(stuff->screen >= screenInfo.numScreens) + if (stuff->screen >= screenInfo.numScreens) return BadValue; - VidModeZoomViewport(stuff->screen, (short)stuff->zoom); + VidModeZoomViewport(stuff->screen, (short) stuff->zoom); return Success; -} - -static int -ProcXF86VidModeSwitchToMode(ClientPtr client) -{ +} static int + ProcXF86VidModeSwitchToMode(ClientPtr client) { REQUEST(xXF86VidModeSwitchToModeReq); xXF86OldVidModeSwitchToModeReq *oldstuff = - (xXF86OldVidModeSwitchToModeReq *)client->requestBuffer; + (xXF86OldVidModeSwitchToModeReq *) client->requestBuffer; xXF86VidModeSwitchToModeReq newstuff; pointer mode; int len, dotClock; int ver; - DEBUG_P("XF86VidModeSwitchToMode"); + DEBUG_P("XF86VidModeSwitchToMode"); - ver = ClientMajorVersion(client); + 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); + /* 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)); + 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; + return BadLength; - if(stuff->screen >= screenInfo.numScreens) + if (stuff->screen >= screenInfo.numScreens) return BadValue; if (!VidModeGetCurrentModeline(stuff->screen, &mode, &dotClock)) - return BadValue; + return BadValue; if ((VidModeGetDotClock(stuff->screen, stuff->dotclock) == dotClock) - && MODEMATCH(mode, stuff)) - return Success; + && MODEMATCH(mode, stuff)) + return Success; if (!VidModeGetFirstModeline(stuff->screen, &mode, &dotClock)) - return BadValue; + 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; - } + 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) -{ + ProcXF86VidModeLockModeSwitch(ClientPtr client) { REQUEST(xXF86VidModeLockModeSwitchReq); REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq); DEBUG_P("XF86VidModeLockModeSwitch"); - if(stuff->screen >= screenInfo.numScreens) + if (stuff->screen >= screenInfo.numScreens) return BadValue; - if (!VidModeLockZoom(stuff->screen, (short)stuff->lock)) - return VidModeErrorBase + XF86VidModeZoomLocked; + if (!VidModeLockZoom(stuff->screen, (short) stuff->lock)) + return VidModeErrorBase + XF86VidModeZoomLocked; return Success; -} - -static int -ProcXF86VidModeGetMonitor(ClientPtr client) -{ +} 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); + DEBUG_P("XF86VidModeGetMonitor"); - if(stuff->screen >= screenInfo.numScreens) - return BadValue; + REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq); + + if (stuff->screen >= screenInfo.numScreens) + return BadValue; if (!VidModeGetMonitor(stuff->screen, &monitor)) - return BadValue; + 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); + 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); + 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)); + 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; - } + return BadAlloc; + } vsyncdata = malloc(nVrefresh * sizeof(CARD32)); - vsyncdata = malloc(nVrefresh * sizeof(CARD32)); if (!vsyncdata) { - free(hsyncdata); - return BadAlloc; + 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; + 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; + 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); + swaps(&rep.sequenceNumber); + swapl(&rep.length); } - WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply), (char *)&rep); + WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply), (char *) &rep); client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write; - WriteSwappedDataToClient(client, nHsync * sizeof(CARD32), - hsyncdata); - WriteSwappedDataToClient(client, nVrefresh * sizeof(CARD32), - vsyncdata); + 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); + 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); + WriteToClient(client, rep.modelLength, + (char + *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_MODEL, + 0)).ptr); free(hsyncdata); free(vsyncdata); @@ -1242,113 +1249,106 @@ ProcXF86VidModeGetMonitor(ClientPtr client) } static int -ProcXF86VidModeGetViewPort(ClientPtr client) -{ + ProcXF86VidModeGetViewPort(ClientPtr client) { REQUEST(xXF86VidModeGetViewPortReq); xXF86VidModeGetViewPortReply rep; int x, y; - DEBUG_P("XF86VidModeGetViewPort"); + DEBUG_P("XF86VidModeGetViewPort"); - REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq); + REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq); - if(stuff->screen >= screenInfo.numScreens) - return BadValue; + if (stuff->screen >= screenInfo.numScreens) + return BadValue; - rep.type = X_Reply; - rep.length = 0; - rep.sequenceNumber = client->sequence; + rep.type = X_Reply; + rep.length = 0; + rep.sequenceNumber = client->sequence; - VidModeGetViewPort(stuff->screen, &x, &y); - rep.x = x; - rep.y = y; + 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); + 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) -{ + ProcXF86VidModeSetViewPort(ClientPtr client) { REQUEST(xXF86VidModeSetViewPortReq); DEBUG_P("XF86VidModeSetViewPort"); REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq); - if(stuff->screen >= screenInfo.numScreens) + if (stuff->screen >= screenInfo.numScreens) return BadValue; if (!VidModeSetViewPort(stuff->screen, stuff->x, stuff->y)) - return BadValue; + return BadValue; return Success; -} - -static int -ProcXF86VidModeGetDotClocks(ClientPtr client) -{ +} static int + ProcXF86VidModeGetDotClocks(ClientPtr client) { REQUEST(xXF86VidModeGetDotClocksReq); xXF86VidModeGetDotClocksReply rep; - int n; + int n; int numClocks; CARD32 dotclock; int *Clocks = NULL; Bool ClockProg; - DEBUG_P("XF86VidModeGetDotClocks"); + DEBUG_P("XF86VidModeGetDotClocks"); - REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq); + REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq); - if(stuff->screen >= screenInfo.numScreens) - return BadValue; + if (stuff->screen >= screenInfo.numScreens) + return BadValue; - numClocks = VidModeGetNumOfClocks(stuff->screen, &ClockProg); + 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; + 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; + 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); + swaps(&rep.sequenceNumber); + swapl(&rep.length); + swapl(&rep.clocks); + swapl(&rep.maxclocks); + swapl(&rep.flags); } - WriteToClient(client, sizeof(xXF86VidModeGetDotClocksReply), (char *)&rep); + 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); - } - } + for (n = 0; n < numClocks; n++) { + dotclock = *Clocks++; + if (client->swapped) { + WriteSwappedDataToClient(client, 4, (char *) &dotclock); + } + else { + WriteToClient(client, 4, (char *) &dotclock); + } + } } free(Clocks); @@ -1356,534 +1356,486 @@ ProcXF86VidModeGetDotClocks(ClientPtr client) } static int -ProcXF86VidModeSetGamma(ClientPtr client) -{ + ProcXF86VidModeSetGamma(ClientPtr client) { REQUEST(xXF86VidModeSetGammaReq); DEBUG_P("XF86VidModeSetGamma"); REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq); - if(stuff->screen >= screenInfo.numScreens) + 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; + 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) -{ +} static int + ProcXF86VidModeGetGamma(ClientPtr client) { REQUEST(xXF86VidModeGetGammaReq); xXF86VidModeGetGammaReply rep; float red, green, blue; - DEBUG_P("XF86VidModeGetGamma"); + DEBUG_P("XF86VidModeGetGamma"); - REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq); + REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq); - if(stuff->screen >= screenInfo.numScreens) - return BadValue; + if (stuff->screen >= screenInfo.numScreens) + return BadValue; - rep.type = X_Reply; - rep.length = 0; - rep.sequenceNumber = client->sequence; + 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.); + 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); + 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) -{ + ProcXF86VidModeSetGammaRamp(ClientPtr client) { CARD16 *r, *g, *b; int length; - REQUEST(xXF86VidModeSetGammaRampReq); + REQUEST(xXF86VidModeSetGammaRampReq); - if(stuff->screen >= screenInfo.numScreens) - return BadValue; + if (stuff->screen >= screenInfo.numScreens) + return BadValue; - if(stuff->size != VidModeGetGammaRampSize(stuff->screen)) - return BadValue; + if (stuff->size != VidModeGetGammaRampSize(stuff->screen)) + return BadValue; - length = (stuff->size + 1) & ~1; + length = (stuff->size + 1) & ~1; - REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length * 6); + REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length * 6); - r = (CARD16*)&stuff[1]; - g = r + length; - b = g + length; + r = (CARD16 *) &stuff[1]; + g = r + length; + b = g + length; if (!VidModeSetGammaRamp(stuff->screen, stuff->size, r, g, b)) - return BadValue; - - return Success; -} + return BadValue; -static int -ProcXF86VidModeGetGammaRamp(ClientPtr client) -{ + return Success; +} static int + ProcXF86VidModeGetGammaRamp(ClientPtr client) { CARD16 *ramp = NULL; int length; size_t ramplen = 0; xXF86VidModeGetGammaRampReply rep; - REQUEST(xXF86VidModeGetGammaRampReq); + REQUEST(xXF86VidModeGetGammaRampReq); - if(stuff->screen >= screenInfo.numScreens) - return BadValue; + if (stuff->screen >= screenInfo.numScreens) + return BadValue; - if(stuff->size != VidModeGetGammaRampSize(stuff->screen)) - return BadValue; + if (stuff->size != VidModeGetGammaRampSize(stuff->screen)) + return BadValue; - REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq); + REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq); - length = (stuff->size + 1) & ~1; + 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; - } - } + if (stuff->size) { + ramplen = length * 3 * sizeof(CARD16); + if (!(ramp = malloc(ramplen))) + return BadAlloc; - rep.type = X_Reply; + 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); + if (client->swapped) { + swaps(&rep.sequenceNumber); + swapl(&rep.length); + swaps(&rep.size); + SwapShorts((short *) ramp, length * 3); } - WriteToClient(client, sizeof(xXF86VidModeGetGammaRampReply), (char *)&rep); + WriteToClient(client, sizeof(xXF86VidModeGetGammaRampReply), (char *) &rep); - if(stuff->size) { - WriteToClient(client, ramplen, (char*)ramp); + if (stuff->size) { + WriteToClient(client, ramplen, (char *) ramp); free(ramp); } return Success; } - static int -ProcXF86VidModeGetGammaRampSize(ClientPtr client) -{ + ProcXF86VidModeGetGammaRampSize(ClientPtr client) { xXF86VidModeGetGammaRampSizeReply rep; - REQUEST(xXF86VidModeGetGammaRampSizeReq); + REQUEST(xXF86VidModeGetGammaRampSizeReq); - if(stuff->screen >= screenInfo.numScreens) - return BadValue; + if (stuff->screen >= screenInfo.numScreens) + return BadValue; - REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq); + REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq); - rep.type = X_Reply; - rep.length = 0; - rep.sequenceNumber = client->sequence; - rep.size = VidModeGetGammaRampSize(stuff->screen); - if(client->swapped) { + 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); + } WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply), + (char *) &rep); return Success; } static int -ProcXF86VidModeGetPermissions(ClientPtr client) -{ + ProcXF86VidModeGetPermissions(ClientPtr client) { xXF86VidModeGetPermissionsReply rep; - REQUEST(xXF86VidModeGetPermissionsReq); + REQUEST(xXF86VidModeGetPermissionsReq); - if(stuff->screen >= screenInfo.numScreens) - return BadValue; + if (stuff->screen >= screenInfo.numScreens) + return BadValue; - REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq); + REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq); - rep.type = X_Reply; - rep.length = 0; - rep.sequenceNumber = client->sequence; - rep.permissions = XF86VM_READ_PERMISSION; + 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) { + (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); + WriteToClient(client, sizeof(xXF86VidModeGetPermissionsReply), + (char *) &rep); return Success; } - static int -ProcXF86VidModeSetClientVersion(ClientPtr client) -{ + ProcXF86VidModeSetClientVersion(ClientPtr client) { REQUEST(xXF86VidModeSetClientVersionReq); VidModePrivPtr pPriv; - DEBUG_P("XF86VidModeSetClientVersion"); + DEBUG_P("XF86VidModeSetClientVersion"); - REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq); + 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 = 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) -{ + ProcXF86VidModeDispatch(ClientPtr client) { REQUEST(xReq); - switch (stuff->data) - { + 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; + 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) -{ + SProcXF86VidModeQueryVersion(ClientPtr client) { REQUEST(xXF86VidModeQueryVersionReq); swaps(&stuff->length); return ProcXF86VidModeQueryVersion(client); -} - -static int -SProcXF86VidModeGetModeLine(ClientPtr 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) -{ +} 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) -{ +} static int + SProcXF86VidModeAddModeLine(ClientPtr client) { xXF86OldVidModeAddModeLineReq *oldstuff = - (xXF86OldVidModeAddModeLineReq *)client->requestBuffer; + (xXF86OldVidModeAddModeLineReq *) client->requestBuffer; int ver; - - REQUEST(xXF86VidModeAddModeLineReq); - ver = ClientMajorVersion(client); + + 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); + 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) -{ + SProcXF86VidModeDeleteModeLine(ClientPtr client) { xXF86OldVidModeDeleteModeLineReq *oldstuff = - (xXF86OldVidModeDeleteModeLineReq *)client->requestBuffer; + (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer; int ver; - REQUEST(xXF86VidModeDeleteModeLineReq); - ver = ClientMajorVersion(client); + 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); + 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) -{ + SProcXF86VidModeModModeLine(ClientPtr client) { xXF86OldVidModeModModeLineReq *oldstuff = - (xXF86OldVidModeModModeLineReq *)client->requestBuffer; + (xXF86OldVidModeModModeLineReq *) client->requestBuffer; int ver; - REQUEST(xXF86VidModeModModeLineReq); - ver = ClientMajorVersion(client); + 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); + 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) -{ + SProcXF86VidModeValidateModeLine(ClientPtr client) { xXF86OldVidModeValidateModeLineReq *oldstuff = - (xXF86OldVidModeValidateModeLineReq *)client->requestBuffer; + (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer; int ver; - REQUEST(xXF86VidModeValidateModeLineReq); - ver = ClientMajorVersion(client); + 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); + 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) -{ + 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) -{ +} 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) -{ +} 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) -{ +} 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) -{ +} 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) -{ +} static int + SProcXF86VidModeSetViewPort(ClientPtr client) { REQUEST(xXF86VidModeSetViewPortReq); swaps(&stuff->length); REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq); @@ -1891,32 +1843,23 @@ SProcXF86VidModeSetViewPort(ClientPtr client) swapl(&stuff->x); swapl(&stuff->y); return ProcXF86VidModeSetViewPort(client); -} - -static int -SProcXF86VidModeGetDotClocks(ClientPtr 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) -{ +} 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) -{ +} static int + SProcXF86VidModeSetGamma(ClientPtr client) { REQUEST(xXF86VidModeSetGammaReq); swaps(&stuff->length); REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq); @@ -1925,174 +1868,149 @@ SProcXF86VidModeSetGamma(ClientPtr client) swapl(&stuff->green); swapl(&stuff->blue); return ProcXF86VidModeSetGamma(client); -} - -static int -SProcXF86VidModeGetGamma(ClientPtr 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) -{ +} 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(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) -{ +} 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) -{ +} 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) -{ +} static int + SProcXF86VidModeDispatch(ClientPtr client) { REQUEST(xReq); - switch (stuff->data) - { + 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; + 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; + XFree86VidModeExtensionInit(void) { + ExtensionEntry *extEntry; ScreenPtr pScreen; - int i; - Bool enabled = FALSE; + int i; + Bool enabled = FALSE; - DEBUG_P("XFree86VidModeExtensionInit"); + DEBUG_P("XFree86VidModeExtensionInit"); if (!dixRegisterPrivateKey(&VidModeClientPrivateKeyRec, PRIVATE_CLIENT, 0)) - return; + return; #ifdef XF86VIDMODE_EVENTS if (!dixRegisterPrivateKey(&ScreenPrivateKeyRec, PRIVATE_SCREEN, 0)) - return; + return; #endif #ifdef XF86VIDMODE_EVENTS - EventType = CreateNewResourceType(XF86VidModeFreeEvents, "VidModeEvent"); + EventType = CreateNewResourceType(XF86VidModeFreeEvents, "VidModeEvent"); #endif - for(i = 0; i < screenInfo.numScreens; i++) { + for (i = 0; i < screenInfo.numScreens; i++) { pScreen = screenInfo.screens[i]; - if (VidModeExtensionInit(pScreen)) - enabled = TRUE; + if (VidModeExtensionInit(pScreen)) + enabled = TRUE; } /* This means that the DDX doesn't want the vidmode extension enabled */ - if (!enabled) - return; + if (!enabled) + return; if ( #ifdef XF86VIDMODE_EVENTS - EventType && + EventType && #endif - (extEntry = AddExtension(XF86VIDMODENAME, - XF86VidModeNumberEvents, - XF86VidModeNumberErrors, - ProcXF86VidModeDispatch, - SProcXF86VidModeDispatch, - NULL, - StandardMinorOpcode))) { + (extEntry = AddExtension(XF86VIDMODENAME, + XF86VidModeNumberEvents, + XF86VidModeNumberErrors, + ProcXF86VidModeDispatch, + SProcXF86VidModeDispatch, + NULL, StandardMinorOpcode))) { #if 0 - XF86VidModeReqCode = (unsigned char)extEntry->base; + XF86VidModeReqCode = (unsigned char) extEntry->base; #endif - VidModeErrorBase = extEntry->errorBase; + VidModeErrorBase = extEntry->errorBase; #ifdef XF86VIDMODE_EVENTS - XF86VidModeEventBase = extEntry->eventBase; - EventSwapVector[XF86VidModeEventBase] = (EventSwapPtr)SXF86VidModeNotifyEvent; + XF86VidModeEventBase = extEntry->eventBase; + EventSwapVector[XF86VidModeEventBase] = + (EventSwapPtr) SXF86VidModeNotifyEvent; #endif } } |