1 /* $XFree86: xc/programs/Xserver/Xext/xf86vmode.c,v 3.30.2.3 1997/06/11 12:08:44 dawes Exp $ */
5 Copyright (c) 1995 Kaleb S. KEITHLEY
7 Permission is hereby granted, free of charge, to any person obtaining
8 a copy of this software and associated documentation files (the
9 "Software"), to deal in the Software without restriction, including
10 without limitation the rights to use, copy, modify, merge, publish,
11 distribute, sublicense, and/or sell copies of the Software, and to
12 permit persons to whom the Software is furnished to do so, subject to
13 the following conditions:
15 The above copyright notice and this permission notice shall be
16 included in all copies or substantial portions of the Software.
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES
22 OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24 OTHER DEALINGS IN THE SOFTWARE.
26 Except as contained in this notice, the name of Kaleb S. KEITHLEY
27 shall not be used in advertising or otherwise to promote the sale, use
28 or other dealings in this Software without prior written authorization
29 from Kaleb S. KEITHLEY
32 /* $XConsortium: xf86vmode.c /main/24 1996/10/26 21:56:29 kaleb $ */
33 /* THIS IS NOT AN X CONSORTIUM STANDARD */
40 #include "dixstruct.h"
41 #include "extnsionst.h"
42 #include "scrnintstr.h"
44 #define _XF86VIDMODE_SERVER_
45 #include "xf86vmstr.h"
46 #include "Xfuncproto.h"
47 #include "../hw/xfree86/common/xf86.h"
48 #include "../hw/xfree86/common/xf86Priv.h"
50 #include <X11/Xtrans.h>
51 #include "../os/osdep.h"
52 #include <X11/Xauth.h>
55 #include <sys/socket.h>
60 #include <lan/socket.h>
65 extern int xf86ScreenIndex;
66 extern Bool xf86VidModeEnabled;
67 extern Bool xf86VidModeAllowNonLocal;
69 static int vidmodeErrorBase;
71 static void XF86VidModeResetProc(
72 #if NeedFunctionPrototypes
73 ExtensionEntry* /* extEntry */
77 static DISPATCH_PROC(ProcXF86VidModeDispatch);
78 static DISPATCH_PROC(ProcXF86VidModeGetAllModeLines);
79 static DISPATCH_PROC(ProcXF86VidModeGetModeLine);
80 static DISPATCH_PROC(ProcXF86VidModeGetMonitor);
81 static DISPATCH_PROC(ProcXF86VidModeLockModeSwitch);
82 static DISPATCH_PROC(ProcXF86VidModeAddModeLine);
83 static DISPATCH_PROC(ProcXF86VidModeDeleteModeLine);
84 static DISPATCH_PROC(ProcXF86VidModeModModeLine);
85 static DISPATCH_PROC(ProcXF86VidModeValidateModeLine);
86 static DISPATCH_PROC(ProcXF86VidModeQueryVersion);
87 static DISPATCH_PROC(ProcXF86VidModeSwitchMode);
88 static DISPATCH_PROC(ProcXF86VidModeSwitchToMode);
89 static DISPATCH_PROC(ProcXF86VidModeGetViewPort);
90 static DISPATCH_PROC(ProcXF86VidModeSetViewPort);
91 static DISPATCH_PROC(SProcXF86VidModeDispatch);
92 static DISPATCH_PROC(SProcXF86VidModeGetAllModeLines);
93 static DISPATCH_PROC(SProcXF86VidModeGetModeLine);
94 static DISPATCH_PROC(SProcXF86VidModeGetMonitor);
95 static DISPATCH_PROC(SProcXF86VidModeLockModeSwitch);
96 static DISPATCH_PROC(SProcXF86VidModeAddModeLine);
97 static DISPATCH_PROC(SProcXF86VidModeDeleteModeLine);
98 static DISPATCH_PROC(SProcXF86VidModeModModeLine);
99 static DISPATCH_PROC(SProcXF86VidModeValidateModeLine);
100 static DISPATCH_PROC(SProcXF86VidModeQueryVersion);
101 static DISPATCH_PROC(SProcXF86VidModeSwitchMode);
102 static DISPATCH_PROC(SProcXF86VidModeSwitchToMode);
103 static DISPATCH_PROC(SProcXF86VidModeGetViewPort);
104 static DISPATCH_PROC(SProcXF86VidModeSetViewPort);
106 static unsigned char XF86VidModeReqCode = 0;
108 /* The XF86VIDMODE_EVENTS code is far from complete */
110 #ifdef XF86VIDMODE_EVENTS
111 static int XF86VidModeEventBase = 0;
113 static void SXF86VidModeNotifyEvent();
114 #if NeedFunctionPrototypes
115 xXF86VidModeNotifyEvent * /* from */,
116 xXF86VidModeNotifyEvent * /* to */
120 extern WindowPtr *WindowTable;
122 static RESTYPE EventType; /* resource type for event masks */
124 typedef struct _XF86VidModeEvent *XF86VidModeEventPtr;
126 typedef struct _XF86VidModeEvent {
127 XF86VidModeEventPtr next;
132 } XF86VidModeEventRec;
134 static int XF86VidModeFreeEvents();
136 typedef struct _XF86VidModeScreenPrivate {
137 XF86VidModeEventPtr events;
139 } XF86VidModeScreenPrivateRec, *XF86VidModeScreenPrivatePtr;
141 static int ScreenPrivateIndex;
143 #define GetScreenPrivate(s) ((ScreenSaverScreenPrivatePtr)(s)->devPrivates[ScreenPrivateIndex].ptr)
144 #define SetScreenPrivate(s,v) ((s)->devPrivates[ScreenPrivateIndex].ptr = (pointer) v);
145 #define SetupScreen(s) ScreenSaverScreenPrivatePtr pPriv = GetScreenPrivate(s)
147 #define New(t) ((t *) xalloc (sizeof (t)))
151 XFree86VidModeExtensionInit()
153 ExtensionEntry* extEntry;
154 #ifdef XF86VIDMODE_EVENTS
158 EventType = CreateNewResourceType(XF86VidModeFreeEvents);
159 ScreenPrivateIndex = AllocateScreenPrivateIndex ();
160 for (i = 0; i < screenInfo.numScreens; i++)
162 pScreen = screenInfo.screens[i];
163 SetScreenPrivate (pScreen, NULL);
168 #ifdef XF86VIDMODE_EVENTS
169 EventType && ScreenPrivateIndex != -1 &&
171 (extEntry = AddExtension(XF86VIDMODENAME,
172 XF86VidModeNumberEvents,
173 XF86VidModeNumberErrors,
174 ProcXF86VidModeDispatch,
175 SProcXF86VidModeDispatch,
176 XF86VidModeResetProc,
177 StandardMinorOpcode))) {
178 XF86VidModeReqCode = (unsigned char)extEntry->base;
179 vidmodeErrorBase = extEntry->errorBase;
180 #ifdef XF86VIDMODE_EVENTS
181 XF86VidModeEventBase = extEntry->eventBase;
182 EventSwapVector[XF86VidModeEventBase] = SXF86VidModeNotifyEvent;
189 XF86VidModeResetProc (extEntry)
190 ExtensionEntry* extEntry;
194 #ifdef XF86VIDMODE_EVENTS
196 CheckScreenPrivate (pScreen)
199 SetupScreen (pScreen);
203 if (!pPriv->events && !pPriv->hasWindow) {
205 SetScreenPrivate (pScreen, NULL);
209 static XF86VidModeScreenPrivatePtr
210 MakeScreenPrivate (pScreen)
213 SetupScreen (pScreen);
217 pPriv = New (XF86VidModeScreenPrivateRec);
221 pPriv->hasWindow = FALSE;
222 SetScreenPrivate (pScreen, pPriv);
227 getEventMask (pScreen, client)
231 SetupScreen(pScreen);
232 XF86VidModeEventPtr pEv;
236 for (pEv = pPriv->events; pEv; pEv = pEv->next)
237 if (pEv->client == client)
243 setEventMask (pScreen, client, mask)
248 SetupScreen(pScreen);
249 XF86VidModeEventPtr pEv, *pPrev;
251 if (getEventMask (pScreen, client) == mask)
254 pPriv = MakeScreenPrivate (pScreen);
258 for (pPrev = &pPriv->events; pEv = *pPrev; pPrev = &pEv->next)
259 if (pEv->client == client)
264 CheckScreenPrivate (pScreen);
267 pEv = New (ScreenSaverEventRec);
269 CheckScreenPrivate (pScreen);
274 pEv->client = client;
275 pEv->screen = pScreen;
276 pEv->resource = FakeClientID (client->index);
284 XF86VidModeFreeEvents (value, id)
288 XF86VidModeEventPtr pOld = (XF86VidModeEventPtr)value;
289 ScreenPtr pScreen = pOld->screen;
290 SetupScreen (pScreen);
291 XF86VidModeEventPtr pEv, *pPrev;
295 for (pPrev = &pPriv->events; pEv = *pPrev; pPrev = &pEv->next)
302 CheckScreenPrivate (pScreen);
307 SendXF86VidModeNotify (pScreen, state, forced)
312 XF86VidModeScreenPrivatePtr pPriv;
313 XF86VidModeEventPtr pEv;
315 xXF86VidModeNotifyEvent ev;
319 UpdateCurrentTimeIf ();
320 mask = XF86VidModeNotifyMask;
321 pScreen = screenInfo.screens[pScreen->myNum];
322 pPriv = GetScreenPrivate(pScreen);
325 kind = XF86VidModeModeChange;
326 for (pEv = pPriv->events; pEv; pEv = pEv->next)
328 client = pEv->client;
329 if (client->clientGone)
331 if (!(pEv->mask & mask))
333 ev.type = XF86VidModeNotify + XF86VidModeEventBase;
335 ev.sequenceNumber = client->sequence;
336 ev.timestamp = currentTime.milliseconds;
337 ev.root = WindowTable[pScreen->myNum]->drawable.id;
340 WriteEventsToClient (client, 1, (xEvent *) &ev);
345 SXF86VidModeNotifyEvent (from, to)
346 xXF86VidModeNotifyEvent *from, *to;
348 to->type = from->type;
349 to->state = from->state;
350 cpswaps (from->sequenceNumber, to->sequenceNumber);
351 cpswapl (from->timestamp, to->timestamp);
352 cpswapl (from->root, to->root);
353 to->kind = from->kind;
354 to->forced = from->forced;
359 ProcXF86VidModeQueryVersion(client)
360 register ClientPtr client;
362 xXF86VidModeQueryVersionReply rep;
365 REQUEST_SIZE_MATCH(xXF86VidModeQueryVersionReq);
368 rep.sequenceNumber = client->sequence;
369 rep.majorVersion = XF86VIDMODE_MAJOR_VERSION;
370 rep.minorVersion = XF86VIDMODE_MINOR_VERSION;
371 if (client->swapped) {
372 swaps(&rep.sequenceNumber, n);
373 swapl(&rep.length, n);
374 swaps(&rep.majorVersion, n);
375 swaps(&rep.minorVersion, n);
377 WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), (char *)&rep);
378 return (client->noClientException);
382 ProcXF86VidModeGetModeLine(client)
383 register ClientPtr client;
385 REQUEST(xXF86VidModeGetModeLineReq);
386 xXF86VidModeGetModeLineReply rep;
392 if (stuff->screen > screenInfo.numScreens)
395 vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
401 privsize = mptr->PrivSize;
403 REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
405 rep.length = (SIZEOF(xXF86VidModeGetModeLineReply) - SIZEOF(xGenericReply) +
406 privsize * sizeof(INT32)) >> 2;
407 rep.sequenceNumber = client->sequence;
408 rep.dotclock = vptr->clock[mptr->Clock];
409 rep.hdisplay = mptr->HDisplay;
410 rep.hsyncstart = mptr->HSyncStart;
411 rep.hsyncend = mptr->HSyncEnd;
412 rep.htotal = mptr->HTotal;
413 rep.vdisplay = mptr->VDisplay;
414 rep.vsyncstart = mptr->VSyncStart;
415 rep.vsyncend = mptr->VSyncEnd;
416 rep.vtotal = mptr->VTotal;
417 rep.flags = mptr->Flags;
418 rep.privsize = privsize;
419 if (client->swapped) {
420 swaps(&rep.sequenceNumber, n);
421 swapl(&rep.length, n);
422 swapl(&rep.dotclock, n);
423 swaps(&rep.hdisplay, n);
424 swaps(&rep.hsyncstart, n);
425 swaps(&rep.hsyncend, n);
426 swaps(&rep.htotal, n);
427 swaps(&rep.vdisplay, n);
428 swaps(&rep.vsyncstart, n);
429 swaps(&rep.vsyncend, n);
430 swaps(&rep.vtotal, n);
431 swapl(&rep.flags, n);
432 swapl(&rep.privsize, n);
434 WriteToClient(client, sizeof(xXF86VidModeGetModeLineReply), (char *)&rep);
436 client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
437 WriteSwappedDataToClient(client, privsize * sizeof(INT32),
440 return (client->noClientException);
444 ProcXF86VidModeGetAllModeLines(client)
445 register ClientPtr client;
447 REQUEST(xXF86VidModeGetAllModeLinesReq);
448 xXF86VidModeGetAllModeLinesReply rep;
449 xXF86VidModeModeInfo mdinf;
452 DisplayModePtr mptr, curmptr;
453 int privsize, modecount=1;
454 int totalPrivSize = 0;
456 if (stuff->screen > screenInfo.numScreens)
459 vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
460 curmptr = mptr = vptr->modes;
462 totalPrivSize = mptr->Private ? mptr->PrivSize : 0;
464 while (mptr->next != curmptr) {
468 totalPrivSize += mptr->PrivSize;
471 REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
473 rep.length = (SIZEOF(xXF86VidModeGetAllModeLinesReply) - SIZEOF(xGenericReply) +
474 modecount * sizeof(xXF86VidModeModeInfo) +
475 totalPrivSize * sizeof(INT32)) >> 2;
476 rep.sequenceNumber = client->sequence;
477 rep.modecount = modecount;
478 if (client->swapped) {
479 swaps(&rep.sequenceNumber, n);
480 swapl(&rep.length, n);
481 swapl(&rep.modecount, n);
483 WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply), (char *)&rep);
489 privsize = mptr->PrivSize;
491 mdinf.dotclock = vptr->clock[mptr->Clock];
492 mdinf.hdisplay = mptr->HDisplay;
493 mdinf.hsyncstart = mptr->HSyncStart;
494 mdinf.hsyncend = mptr->HSyncEnd;
495 mdinf.htotal = mptr->HTotal;
496 mdinf.vdisplay = mptr->VDisplay;
497 mdinf.vsyncstart = mptr->VSyncStart;
498 mdinf.vsyncend = mptr->VSyncEnd;
499 mdinf.vtotal = mptr->VTotal;
500 mdinf.flags = mptr->Flags;
501 mdinf.privsize = privsize;
502 if (client->swapped) {
503 swapl(&mdinf.dotclock, n);
504 swaps(&mdinf.hdisplay, n);
505 swaps(&mdinf.hsyncstart, n);
506 swaps(&mdinf.hsyncend, n);
507 swaps(&mdinf.htotal, n);
508 swaps(&mdinf.vdisplay, n);
509 swaps(&mdinf.vsyncstart, n);
510 swaps(&mdinf.vsyncend, n);
511 swaps(&mdinf.vtotal, n);
512 swapl(&mdinf.flags, n);
513 swapl(&mdinf.privsize, n);
515 WriteToClient(client, sizeof(xXF86VidModeModeInfo), (char *)&mdinf);
517 client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
518 WriteSwappedDataToClient(client, privsize * sizeof(INT32),
522 } while (mptr != curmptr);
523 return (client->noClientException);
526 #define CLOCKSPD(clk,scrp) ((clk>MAXCLOCKS)? clk: scrp->clock[clk])
527 #define MODEMATCH(mptr,stuff,scrp) \
528 (CLOCKSPD(mptr->Clock,scrp) == CLOCKSPD(stuff->dotclock,scrp) \
529 && mptr->HDisplay == stuff->hdisplay \
530 && mptr->HSyncStart== stuff->hsyncstart \
531 && mptr->HSyncEnd == stuff->hsyncend \
532 && mptr->HTotal == stuff->htotal \
533 && mptr->VDisplay == stuff->vdisplay \
534 && mptr->VSyncStart== stuff->vsyncstart \
535 && mptr->VSyncEnd == stuff->vsyncend \
536 && mptr->VTotal == stuff->vtotal \
537 && mptr->Flags == stuff->flags )
539 #include "xf86_Config.h"
542 ProcXF86VidModeAddModeLine(client)
543 register ClientPtr client;
545 REQUEST(xXF86VidModeAddModeLineReq);
547 DisplayModePtr curmptr, mptr, newmptr;
548 Bool clock_added = FALSE;
551 if (xf86Verbose > 1) {
552 ErrorF("AddModeLine - scrn: %d clock: %d\n",
553 stuff->screen, stuff->dotclock);
554 ErrorF("AddModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
555 stuff->hdisplay, stuff->hsyncstart,
556 stuff->hsyncend, stuff->htotal);
557 ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
558 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
559 stuff->vtotal, stuff->flags);
560 ErrorF(" after - scrn: %d clock: %d\n",
561 stuff->screen, stuff->after_dotclock);
562 ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
563 stuff->after_hdisplay, stuff->after_hsyncstart,
564 stuff->after_hsyncend, stuff->after_htotal);
565 ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
566 stuff->after_vdisplay, stuff->after_vsyncstart,
567 stuff->after_vsyncend, stuff->after_vtotal, stuff->after_flags);
569 if (stuff->screen > screenInfo.numScreens)
572 vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
573 curmptr = mptr = vptr->modes;
575 REQUEST_AT_LEAST_SIZE(xXF86VidModeAddModeLineReq);
576 len = client->req_len - (sizeof(xXF86VidModeAddModeLineReq) >> 2);
577 if (len != stuff->privsize)
580 if (stuff->hsyncstart < stuff->hdisplay ||
581 stuff->hsyncend < stuff->hsyncstart ||
582 stuff->htotal < stuff->hsyncend ||
583 stuff->vsyncstart < stuff->vdisplay ||
584 stuff->vsyncend < stuff->vsyncstart ||
585 stuff->vtotal < stuff->vsyncend)
588 if (stuff->after_hsyncstart < stuff->after_hdisplay ||
589 stuff->after_hsyncend < stuff->after_hsyncstart ||
590 stuff->after_htotal < stuff->after_hsyncend ||
591 stuff->after_vsyncstart < stuff->after_vdisplay ||
592 stuff->after_vsyncend < stuff->after_vsyncstart ||
593 stuff->after_vtotal < stuff->after_vsyncend)
596 if (stuff->after_htotal != 0 || stuff->after_vtotal != 0) {
599 if (MODEMATCH(mptr, stuff, vptr)) {
603 } while ((mptr = mptr->next) != curmptr);
608 newmptr = (DisplayModePtr) xalloc(sizeof(DisplayModeRec));
610 /* Clock checking code, mostly copied from the xf86LookupMode function */
611 if (stuff->dotclock < vptr->clocks) {
612 newmptr->Clock = stuff->dotclock;
614 if ((OFLG_ISSET(CLOCK_OPTION_PROGRAMABLE, &(vptr->clockOptions))) &&
615 !OFLG_ISSET(OPTION_NO_PROGRAM_CLOCKS, &(vptr->options)))
617 for (i = 0; i < vptr->clocks; i++)
618 if (stuff->dotclock == vptr->clock[i])
621 if (i >= MAXCLOCKS || vptr->clock[i]/1000 > vptr->maxClock/1000) {
623 return vidmodeErrorBase + XF86VidModeBadClock;
626 if (i == vptr->clocks) {
627 vptr->clock[i] = stuff->dotclock;
632 int flags=0, j, k, Gap, Minimum_Gap = CLOCK_TOLERANCE + 1;
633 double refresh, bestRefresh = 0.0;
635 if (OFLG_ISSET(OPTION_CLKDIV2, &(vptr->options)))
641 flags |= LOOKUP_BEST_REFRESH;
643 for (j=1 ; j<=k ; j++) {
644 i = xf86GetNearestClock(vptr, stuff->dotclock * j);
645 if (flags & LOOKUP_BEST_REFRESH) {
646 if ( ((vptr->clock[i]/j) / 1000) > (vptr->maxClock / 1000) ) {
648 return vidmodeErrorBase + XF86VidModeBadClock;
650 refresh = stuff->dotclock * 1000.0 / stuff->htotal / stuff->vtotal;
651 if (stuff->flags & V_INTERLACE) {
653 refresh /= INTERLACE_REFRESH_WEIGHT;
654 } else if (stuff->flags & V_DBLSCAN)
657 if (refresh > bestRefresh) {
659 if (j==2) stuff->flags |= V_CLKDIV2;
660 bestRefresh = refresh;
664 Gap = abs( stuff->dotclock - (vptr->clock[i]/j) );
665 if (Gap < Minimum_Gap) {
666 if ( ((vptr->clock[i]/j) / 1000) > (vptr->maxClock / 1000) ) {
668 return vidmodeErrorBase + XF86VidModeBadClock;
671 if (j==2) stuff->flags |= V_CLKDIV2;
680 newmptr->CrtcHDisplay = newmptr->HDisplay = stuff->hdisplay;
681 newmptr->CrtcHSyncStart= newmptr->HSyncStart = stuff->hsyncstart;
682 newmptr->CrtcHSyncEnd = newmptr->HSyncEnd = stuff->hsyncend;
683 newmptr->CrtcHTotal = newmptr->HTotal = stuff->htotal;
684 newmptr->CrtcVDisplay = newmptr->VDisplay = stuff->vdisplay;
685 newmptr->CrtcVSyncStart= newmptr->VSyncStart = stuff->vsyncstart;
686 newmptr->CrtcVSyncEnd = newmptr->VSyncEnd = stuff->vsyncend;
687 newmptr->CrtcVTotal = newmptr->VTotal = stuff->vtotal;
688 newmptr->Flags = stuff->flags;
690 newmptr->CrtcHSkew = newmptr->HSkew = stuff->hskew;
692 newmptr->CrtcHAdjusted = FALSE;
693 newmptr->CrtcVAdjusted = FALSE;
695 newmptr->Private = NULL;
696 if (stuff->privsize) {
698 ErrorF("AddModeLine - Request includes privates\n");
700 (INT32 *) ALLOCATE_LOCAL(stuff->privsize * sizeof(INT32));
701 memcpy(newmptr->Private, &stuff[1], stuff->privsize*sizeof(INT32));
704 /* Check that the mode is consistent with the monitor specs */
705 switch (xf86CheckMode(vptr, newmptr, vptr->monitor, FALSE)) {
709 xfree(newmptr->Private);
713 return vidmodeErrorBase + XF86VidModeBadHTimings;
715 xfree(newmptr->Private);
719 return vidmodeErrorBase + XF86VidModeBadVTimings;
723 return vidmodeErrorBase + XF86VidModeModeUnsuitable;
726 /* Check that the driver is happy with the mode */
727 if (vptr->ValidMode(newmptr, xf86Verbose, MODE_VID) != MODE_OK) {
728 xfree(newmptr->Private);
732 return vidmodeErrorBase + XF86VidModeModeUnsuitable;
735 if (newmptr->Flags & V_DBLSCAN)
737 newmptr->CrtcVDisplay *= 2;
738 newmptr->CrtcVSyncStart *= 2;
739 newmptr->CrtcVSyncEnd *= 2;
740 newmptr->CrtcVTotal *= 2;
741 newmptr->CrtcVAdjusted = TRUE;
744 newmptr->next = mptr->next;
745 newmptr->prev = mptr;
746 mptr->next = newmptr;
747 newmptr->next->prev = newmptr;
749 #if 0 /* Do we want this? */
750 (vptr->SwitchMode)(newmptr);
754 ErrorF("AddModeLine - Succeeded\n");
755 return(client->noClientException);
759 ProcXF86VidModeDeleteModeLine(client)
760 register ClientPtr client;
762 REQUEST(xXF86VidModeDeleteModeLineReq);
764 DisplayModePtr curmptr, mptr;
767 if (xf86Verbose > 1) {
768 ErrorF("DeleteModeLine - scrn: %d clock: %d\n",
769 stuff->screen, stuff->dotclock, stuff->dotclock);
770 ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
771 stuff->hdisplay, stuff->hsyncstart,
772 stuff->hsyncend, stuff->htotal);
773 ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
774 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
775 stuff->vtotal, stuff->flags);
777 if (stuff->screen > screenInfo.numScreens)
780 vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
781 curmptr = mptr = vptr->modes;
783 REQUEST_AT_LEAST_SIZE(xXF86VidModeDeleteModeLineReq);
784 len = client->req_len - (sizeof(xXF86VidModeDeleteModeLineReq) >> 2);
785 if (len != stuff->privsize) {
786 if (xf86Verbose > 1) {
787 ErrorF("req_len = %d, sizeof(Req) = %d, privsize = %d, len = %d, length = %d\n",
788 client->req_len, sizeof(xXF86VidModeDeleteModeLineReq)>>2, stuff->privsize, len, stuff->length);
792 if (xf86Verbose > 1) {
793 ErrorF("Checking against clock: %d (%d)\n",
794 mptr->Clock, CLOCKSPD(mptr->Clock, vptr));
795 ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
796 mptr->HDisplay, mptr->HSyncStart,
797 mptr->HSyncEnd, mptr->HTotal);
798 ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
799 mptr->VDisplay, mptr->VSyncStart, mptr->VSyncEnd,
800 mptr->VTotal, mptr->Flags);
802 if (MODEMATCH(mptr, stuff, vptr))
805 while ((mptr = mptr->next) != curmptr) {
806 if (xf86Verbose > 1) {
807 ErrorF("Checking against clock: %d (%d)\n",
808 mptr->Clock, CLOCKSPD(mptr->Clock, vptr));
809 ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
810 mptr->HDisplay, mptr->HSyncStart,
811 mptr->HSyncEnd, mptr->HTotal);
812 ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
813 mptr->VDisplay, mptr->VSyncStart, mptr->VSyncEnd,
814 mptr->VTotal, mptr->Flags);
816 if (MODEMATCH(mptr, stuff, vptr)) {
817 mptr->prev->next = mptr->next;
818 mptr->next->prev = mptr->prev;
820 xfree(mptr->Private);
823 ErrorF("DeleteModeLine - Succeeded\n");
824 return(client->noClientException);
831 ProcXF86VidModeModModeLine(client)
832 register ClientPtr client;
834 REQUEST(xXF86VidModeModModeLineReq);
837 DisplayModeRec modetmp;
840 if (xf86Verbose > 1) {
841 ErrorF("ModModeLine - scrn: %d hdsp: %d hbeg: %d hend: %d httl: %d\n",
842 stuff->screen, stuff->hdisplay, stuff->hsyncstart,
843 stuff->hsyncend, stuff->htotal);
844 ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
845 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
846 stuff->vtotal, stuff->flags);
848 if (stuff->screen > screenInfo.numScreens)
851 vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
854 REQUEST_AT_LEAST_SIZE(xXF86VidModeModModeLineReq);
855 len = client->req_len - (sizeof(xXF86VidModeModModeLineReq) >> 2);
856 if (len != stuff->privsize)
859 if (stuff->hsyncstart < stuff->hdisplay ||
860 stuff->hsyncend < stuff->hsyncstart ||
861 stuff->htotal < stuff->hsyncend ||
862 stuff->vsyncstart < stuff->vdisplay ||
863 stuff->vsyncend < stuff->vsyncstart ||
864 stuff->vtotal < stuff->vsyncend)
867 memcpy(&modetmp, mptr, sizeof(DisplayModeRec));
869 modetmp.HDisplay = stuff->hdisplay;
870 modetmp.HSyncStart = stuff->hsyncstart;
871 modetmp.HSyncEnd = stuff->hsyncend;
872 modetmp.HTotal = stuff->htotal;
873 modetmp.VDisplay = stuff->vdisplay;
874 modetmp.VSyncStart = stuff->vsyncstart;
875 modetmp.VSyncEnd = stuff->vsyncend;
876 modetmp.VTotal = stuff->vtotal;
877 modetmp.Flags = stuff->flags;
878 if (mptr->PrivSize && stuff->privsize) {
879 if (mptr->PrivSize != stuff->privsize)
882 if (mptr->PrivSize && mptr->Private) {
884 (INT32 *)ALLOCATE_LOCAL(mptr->PrivSize * sizeof(INT32));
885 if (stuff->privsize) {
887 ErrorF("ModModeLine - Request includes privates\n");
888 memcpy(modetmp.Private, &stuff[1], mptr->PrivSize * sizeof(INT32));
890 memcpy(modetmp.Private, mptr->Private,
891 mptr->PrivSize * sizeof(INT32));
894 /* Check that the mode is consistent with the monitor specs */
895 switch (xf86CheckMode(vptr, &modetmp, vptr->monitor, FALSE)) {
897 DEALLOCATE_LOCAL(modetmp.Private);
898 return vidmodeErrorBase + XF86VidModeBadHTimings;
900 DEALLOCATE_LOCAL(modetmp.Private);
901 return vidmodeErrorBase + XF86VidModeBadVTimings;
904 /* Check that the driver is happy with the mode */
905 if (vptr->ValidMode(&modetmp, xf86Verbose, MODE_VID) != MODE_OK) {
906 DEALLOCATE_LOCAL(modetmp.Private);
907 return vidmodeErrorBase + XF86VidModeModeUnsuitable;
910 DEALLOCATE_LOCAL(modetmp.Private);
912 mptr->HDisplay = stuff->hdisplay;
913 mptr->HSyncStart = stuff->hsyncstart;
914 mptr->HSyncEnd = stuff->hsyncend;
915 mptr->HTotal = stuff->htotal;
916 mptr->VDisplay = stuff->vdisplay;
917 mptr->VSyncStart = stuff->vsyncstart;
918 mptr->VSyncEnd = stuff->vsyncend;
919 mptr->VTotal = stuff->vtotal;
920 mptr->Flags = stuff->flags;
921 mptr->CrtcHDisplay = stuff->hdisplay;
922 mptr->CrtcHSyncStart = stuff->hsyncstart;
923 mptr->CrtcHSyncEnd = stuff->hsyncend;
924 mptr->CrtcHTotal = stuff->htotal;
925 mptr->CrtcVDisplay = stuff->vdisplay;
926 mptr->CrtcVSyncStart = stuff->vsyncstart;
927 mptr->CrtcVSyncEnd = stuff->vsyncend;
928 mptr->CrtcVTotal = stuff->vtotal;
929 mptr->CrtcVAdjusted = FALSE;
930 mptr->CrtcHAdjusted = FALSE;
931 if (mptr->Flags & V_DBLSCAN)
933 mptr->CrtcVDisplay *= 2;
934 mptr->CrtcVSyncStart *= 2;
935 mptr->CrtcVSyncEnd *= 2;
936 mptr->CrtcVTotal *= 2;
937 mptr->CrtcVAdjusted = TRUE;
939 if (mptr->PrivSize && stuff->privsize) {
940 memcpy(mptr->Private, &stuff[1], mptr->PrivSize * sizeof(INT32));
943 (vptr->SwitchMode)(mptr);
944 (vptr->AdjustFrame)(vptr->frameX0, vptr->frameY0);
947 ErrorF("ModModeLine - Succeeded\n");
948 return(client->noClientException);
952 ProcXF86VidModeValidateModeLine(client)
953 register ClientPtr client;
955 REQUEST(xXF86VidModeValidateModeLineReq);
956 xXF86VidModeValidateModeLineReply rep;
959 DisplayModeRec modetmp;
962 if (xf86Verbose > 1) {
963 ErrorF("ValidateModeLine - scrn: %d clock: %d\n",
964 stuff->screen, stuff->dotclock);
965 ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
966 stuff->hdisplay, stuff->hsyncstart,
967 stuff->hsyncend, stuff->htotal);
968 ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
969 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
970 stuff->vtotal, stuff->flags);
972 if (stuff->screen > screenInfo.numScreens)
975 vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
978 REQUEST_AT_LEAST_SIZE(xXF86VidModeValidateModeLineReq);
979 len = client->req_len - (sizeof(xXF86VidModeValidateModeLineReq) >> 2);
980 if (len != stuff->privsize)
984 modetmp.Private = NULL;
986 if (stuff->hsyncstart < stuff->hdisplay ||
987 stuff->hsyncend < stuff->hsyncstart ||
988 stuff->htotal < stuff->hsyncend ||
989 stuff->vsyncstart < stuff->vdisplay ||
990 stuff->vsyncend < stuff->vsyncstart ||
991 stuff->vtotal < stuff->vsyncend)
997 memcpy(&modetmp, mptr, sizeof(DisplayModeRec));
999 modetmp.HDisplay = stuff->hdisplay;
1000 modetmp.HSyncStart = stuff->hsyncstart;
1001 modetmp.HSyncEnd = stuff->hsyncend;
1002 modetmp.HTotal = stuff->htotal;
1003 modetmp.VDisplay = stuff->vdisplay;
1004 modetmp.VSyncStart = stuff->vsyncstart;
1005 modetmp.VSyncEnd = stuff->vsyncend;
1006 modetmp.VTotal = stuff->vtotal;
1007 modetmp.Flags = stuff->flags;
1008 modetmp.Private = NULL;
1009 if (mptr->PrivSize && stuff->privsize) {
1010 if (mptr->PrivSize != stuff->privsize) {
1015 if (mptr->PrivSize && mptr->Private) {
1017 (INT32 *)ALLOCATE_LOCAL(mptr->PrivSize * sizeof(INT32));
1018 if (stuff->privsize) {
1020 ErrorF("ValidateModeLine - Request includes privates\n");
1021 memcpy(modetmp.Private, &stuff[1], mptr->PrivSize * sizeof(INT32));
1023 memcpy(modetmp.Private, mptr->Private,
1024 mptr->PrivSize * sizeof(INT32));
1027 /* Check that the mode is consistent with the monitor specs */
1028 if ((status = xf86CheckMode(vptr, &modetmp, vptr->monitor, FALSE)) != MODE_OK)
1031 /* Check that the driver is happy with the mode */
1032 status = vptr->ValidMode(&modetmp, xf86Verbose, MODE_VID);
1035 if (modetmp.Private)
1036 DEALLOCATE_LOCAL(modetmp.Private);
1038 rep.length = (SIZEOF(xXF86VidModeValidateModeLineReply)
1039 - SIZEOF(xGenericReply)) >> 2;
1040 rep.sequenceNumber = client->sequence;
1041 rep.status = status;
1042 if (client->swapped) {
1044 swaps(&rep.sequenceNumber, n);
1045 swapl(&rep.length, n);
1046 swapl(&rep.status, n);
1048 WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply), (char *)&rep);
1049 if (xf86Verbose > 1)
1050 ErrorF("ValidateModeLine - Succeeded\n");
1051 return(client->noClientException);
1055 ProcXF86VidModeSwitchMode(client)
1056 register ClientPtr client;
1058 REQUEST(xXF86VidModeSwitchModeReq);
1061 if (stuff->screen > screenInfo.numScreens)
1064 vptr = screenInfo.screens[stuff->screen];
1065 if (xf86Info.dontZoom)
1066 return vidmodeErrorBase + XF86VidModeZoomLocked;
1068 REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq);
1070 xf86ZoomViewport(vptr, (short)stuff->zoom);
1071 return (client->noClientException);
1075 ProcXF86VidModeSwitchToMode(client)
1076 register ClientPtr client;
1078 REQUEST(xXF86VidModeSwitchToModeReq);
1080 DisplayModePtr curmptr, mptr;
1083 if (xf86Verbose > 1) {
1084 ErrorF("SwitchToMode - scrn: %d clock: %d\n",
1085 stuff->screen, stuff->dotclock);
1086 ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
1087 stuff->hdisplay, stuff->hsyncstart,
1088 stuff->hsyncend, stuff->htotal);
1089 ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
1090 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
1091 stuff->vtotal, stuff->flags);
1093 if (stuff->screen > screenInfo.numScreens)
1096 if (xf86Info.dontZoom)
1097 return vidmodeErrorBase + XF86VidModeZoomLocked;
1099 vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
1100 curmptr = mptr = vptr->modes;
1102 REQUEST_AT_LEAST_SIZE(xXF86VidModeSwitchToModeReq);
1103 len = client->req_len - (sizeof(xXF86VidModeSwitchToModeReq) >> 2);
1104 if (len != stuff->privsize)
1108 if (MODEMATCH(mptr, stuff, vptr))
1109 return (client->noClientException);
1111 while ((mptr = mptr->next) != curmptr) {
1112 if (xf86Verbose > 1) {
1113 ErrorF("Checking against clock: %d (%d)\n",
1114 mptr->Clock, CLOCKSPD(mptr->Clock, vptr));
1115 ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
1116 mptr->HDisplay, mptr->HSyncStart,
1117 mptr->HSyncEnd, mptr->HTotal);
1118 ErrorF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
1119 mptr->VDisplay, mptr->VSyncStart, mptr->VSyncEnd,
1120 mptr->VTotal, mptr->Flags);
1122 if (MODEMATCH(mptr, stuff, vptr)) {
1123 if ((vptr->SwitchMode)(mptr)) {
1125 vptr->frameX0 = (vptr->frameX1 +vptr->frameX0 -mptr->HDisplay)/2;
1126 vptr->frameX1 = vptr->frameX0 + mptr->HDisplay -1;
1127 if (vptr->frameX0 < 0) {
1129 vptr->frameX1 = mptr->HDisplay -1;
1130 } else if (vptr->frameX1 >= vptr->virtualX) {
1131 vptr->frameX0 = vptr->virtualX - mptr->HDisplay;
1132 vptr->frameX1 = vptr->frameX0 + mptr->HDisplay -1;
1134 vptr->frameY0 = (vptr->frameY1 +vptr->frameY0 -mptr->VDisplay)/2;
1135 vptr->frameY1 = vptr->frameY0 + mptr->VDisplay -1;
1136 if (vptr->frameY0 < 0) {
1138 vptr->frameY1 = mptr->VDisplay -1;
1139 } else if (vptr->frameY1 >= vptr->virtualY) {
1140 vptr->frameY0 = vptr->virtualY - mptr->VDisplay;
1141 vptr->frameY1 = vptr->frameY0 + mptr->VDisplay -1;
1144 (vptr->AdjustFrame)(vptr->frameX0, vptr->frameY0);
1145 if (xf86Verbose > 1)
1146 ErrorF("SwitchToMode - Succeeded\n");
1147 return(client->noClientException);
1154 ProcXF86VidModeLockModeSwitch(client)
1155 register ClientPtr client;
1157 REQUEST(xXF86VidModeLockModeSwitchReq);
1160 if (stuff->screen > screenInfo.numScreens)
1163 vptr = screenInfo.screens[stuff->screen];
1164 if (xf86Info.dontZoom)
1165 return vidmodeErrorBase + XF86VidModeZoomLocked;
1167 REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
1169 xf86LockZoom(vptr, (short)stuff->lock);
1170 return (client->noClientException);
1174 ProcXF86VidModeGetMonitor(client)
1175 register ClientPtr client;
1177 REQUEST(xXF86VidModeGetMonitorReq);
1178 xXF86VidModeGetMonitorReply rep;
1182 CARD32 *hsyncdata, *vsyncdata;
1185 if (stuff->screen > screenInfo.numScreens)
1188 vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
1189 mptr = vptr->monitor;
1191 REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq);
1194 rep.vendorLength = strlen(mptr->vendor);
1196 rep.vendorLength = 0;
1198 rep.modelLength = strlen(mptr->model);
1200 rep.modelLength = 0;
1201 rep.length = (SIZEOF(xXF86VidModeGetMonitorReply) - SIZEOF(xGenericReply) +
1202 (mptr->n_hsync + mptr->n_vrefresh) * sizeof(CARD32) +
1203 ((rep.vendorLength + 3) & ~3) +
1204 ((rep.modelLength + 3) & ~3)) >> 2;
1205 rep.sequenceNumber = client->sequence;
1206 rep.nhsync = mptr->n_hsync;
1207 rep.nvsync = mptr->n_vrefresh;
1209 rep.bandwidth = (unsigned long)(mptr->bandwidth * 1e6);
1211 hsyncdata = ALLOCATE_LOCAL(mptr->n_hsync * sizeof(CARD32));
1215 vsyncdata = ALLOCATE_LOCAL(mptr->n_vrefresh * sizeof(CARD32));
1217 DEALLOCATE_LOCAL(hsyncdata);
1220 for (i = 0; i < mptr->n_hsync; i++) {
1221 hsyncdata[i] = (unsigned short)(mptr->hsync[i].lo * 100.0) |
1222 (unsigned short)(mptr->hsync[i].hi * 100.0) << 16;
1224 for (i = 0; i < mptr->n_vrefresh; i++) {
1225 vsyncdata[i] = (unsigned short)(mptr->vrefresh[i].lo * 100.0) |
1226 (unsigned short)(mptr->vrefresh[i].hi * 100.0) << 16;
1229 if (client->swapped) {
1230 swaps(&rep.sequenceNumber, n);
1231 swapl(&rep.length, n);
1233 swapl(&rep.bandwidth, n);
1236 WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply), (char *)&rep);
1237 client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
1238 WriteSwappedDataToClient(client, mptr->n_hsync * sizeof(CARD32),
1240 WriteSwappedDataToClient(client, mptr->n_vrefresh * sizeof(CARD32),
1242 if (rep.vendorLength)
1243 WriteToClient(client, rep.vendorLength, mptr->vendor);
1244 if (rep.modelLength)
1245 WriteToClient(client, rep.modelLength, mptr->model);
1246 DEALLOCATE_LOCAL(hsyncdata);
1247 DEALLOCATE_LOCAL(vsyncdata);
1248 return (client->noClientException);
1252 ProcXF86VidModeGetViewPort(client)
1253 register ClientPtr client;
1255 REQUEST(xXF86VidModeGetViewPortReq);
1256 xXF86VidModeGetViewPortReply rep;
1260 if (stuff->screen > screenInfo.numScreens)
1263 vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
1265 REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq);
1268 rep.sequenceNumber = client->sequence;
1269 rep.x = vptr->frameX0;
1270 rep.y = vptr->frameY0;
1272 if (client->swapped) {
1273 swaps(&rep.sequenceNumber, n);
1274 swapl(&rep.length, n);
1278 WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), (char *)&rep);
1279 return (client->noClientException);
1283 ProcXF86VidModeSetViewPort(client)
1284 register ClientPtr client;
1286 REQUEST(xXF86VidModeSetViewPortReq);
1290 if (stuff->screen > screenInfo.numScreens)
1293 vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
1295 REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq);
1299 else if (stuff->x + vptr->modes->HDisplay + 1 > vptr->virtualX)
1300 x = vptr->virtualX - vptr->modes->HDisplay - 1;
1306 else if (stuff->y + vptr->modes->VDisplay + 1 > vptr->virtualY)
1307 y = vptr->virtualY - vptr->modes->VDisplay - 1;
1311 if (vptr->AdjustFrame && xf86VTSema) {
1312 vptr->AdjustFrame(x, y);
1314 vptr->frameX1 = x + vptr->modes->HDisplay - 1;
1316 vptr->frameY1 = y + vptr->modes->VDisplay - 1;
1319 return (client->noClientException);
1324 ProcXF86VidModeDispatch (client)
1325 register ClientPtr client;
1328 switch (stuff->data)
1330 case X_XF86VidModeQueryVersion:
1331 return ProcXF86VidModeQueryVersion(client);
1332 case X_XF86VidModeGetModeLine:
1333 return ProcXF86VidModeGetModeLine(client);
1334 case X_XF86VidModeGetAllModeLines:
1335 return ProcXF86VidModeGetAllModeLines(client);
1336 case X_XF86VidModeGetMonitor:
1337 return ProcXF86VidModeGetMonitor(client);
1338 case X_XF86VidModeValidateModeLine:
1339 return ProcXF86VidModeValidateModeLine(client);
1340 case X_XF86VidModeGetViewPort:
1341 return ProcXF86VidModeGetViewPort(client);
1343 if (!xf86VidModeEnabled)
1344 return vidmodeErrorBase + XF86VidModeExtensionDisabled;
1345 if (xf86VidModeAllowNonLocal || LocalClient (client)) {
1346 switch (stuff->data) {
1347 case X_XF86VidModeAddModeLine:
1348 return ProcXF86VidModeAddModeLine(client);
1349 case X_XF86VidModeDeleteModeLine:
1350 return ProcXF86VidModeDeleteModeLine(client);
1351 case X_XF86VidModeModModeLine:
1352 return ProcXF86VidModeModModeLine(client);
1353 case X_XF86VidModeSwitchMode:
1354 return ProcXF86VidModeSwitchMode(client);
1355 case X_XF86VidModeSwitchToMode:
1356 return ProcXF86VidModeSwitchToMode(client);
1357 case X_XF86VidModeLockModeSwitch:
1358 return ProcXF86VidModeLockModeSwitch(client);
1359 case X_XF86VidModeSetViewPort:
1360 return ProcXF86VidModeSetViewPort(client);
1365 return vidmodeErrorBase + XF86VidModeClientNotLocal;
1370 SProcXF86VidModeQueryVersion(client)
1371 register ClientPtr client;
1374 REQUEST(xXF86VidModeQueryVersionReq);
1375 swaps(&stuff->length, n);
1376 return ProcXF86VidModeQueryVersion(client);
1380 SProcXF86VidModeGetModeLine(client)
1384 REQUEST(xXF86VidModeGetModeLineReq);
1385 swaps(&stuff->length, n);
1386 REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
1387 swaps(&stuff->screen, n);
1388 return ProcXF86VidModeGetModeLine(client);
1392 SProcXF86VidModeGetAllModeLines(client)
1396 REQUEST(xXF86VidModeGetAllModeLinesReq);
1397 swaps(&stuff->length, n);
1398 REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
1399 swaps(&stuff->screen, n);
1400 return ProcXF86VidModeGetAllModeLines(client);
1404 SProcXF86VidModeAddModeLine(client)
1408 REQUEST(xXF86VidModeAddModeLineReq);
1409 swaps(&stuff->length, n);
1410 REQUEST_AT_LEAST_SIZE(xXF86VidModeAddModeLineReq);
1411 swapl(&stuff->screen, n);
1412 swaps(&stuff->hdisplay, n);
1413 swaps(&stuff->hsyncstart, n);
1414 swaps(&stuff->hsyncend, n);
1415 swaps(&stuff->htotal, n);
1416 swaps(&stuff->vdisplay, n);
1417 swaps(&stuff->vsyncstart, n);
1418 swaps(&stuff->vsyncend, n);
1419 swaps(&stuff->vtotal, n);
1420 swapl(&stuff->flags, n);
1421 swapl(&stuff->privsize, n);
1423 return ProcXF86VidModeAddModeLine(client);
1427 SProcXF86VidModeDeleteModeLine(client)
1431 REQUEST(xXF86VidModeDeleteModeLineReq);
1432 swaps(&stuff->length, n);
1433 REQUEST_AT_LEAST_SIZE(xXF86VidModeDeleteModeLineReq);
1434 swapl(&stuff->screen, n);
1435 swaps(&stuff->hdisplay, n);
1436 swaps(&stuff->hsyncstart, n);
1437 swaps(&stuff->hsyncend, n);
1438 swaps(&stuff->htotal, n);
1439 swaps(&stuff->vdisplay, n);
1440 swaps(&stuff->vsyncstart, n);
1441 swaps(&stuff->vsyncend, n);
1442 swaps(&stuff->vtotal, n);
1443 swapl(&stuff->flags, n);
1444 swapl(&stuff->privsize, n);
1446 return ProcXF86VidModeDeleteModeLine(client);
1450 SProcXF86VidModeModModeLine(client)
1454 REQUEST(xXF86VidModeModModeLineReq);
1455 swaps(&stuff->length, n);
1456 REQUEST_AT_LEAST_SIZE(xXF86VidModeModModeLineReq);
1457 swapl(&stuff->screen, n);
1458 swaps(&stuff->hdisplay, n);
1459 swaps(&stuff->hsyncstart, n);
1460 swaps(&stuff->hsyncend, n);
1461 swaps(&stuff->htotal, n);
1462 swaps(&stuff->vdisplay, n);
1463 swaps(&stuff->vsyncstart, n);
1464 swaps(&stuff->vsyncend, n);
1465 swaps(&stuff->vtotal, n);
1466 swapl(&stuff->flags, n);
1467 swapl(&stuff->privsize, n);
1469 return ProcXF86VidModeModModeLine(client);
1473 SProcXF86VidModeValidateModeLine(client)
1477 REQUEST(xXF86VidModeValidateModeLineReq);
1478 swaps(&stuff->length, n);
1479 REQUEST_AT_LEAST_SIZE(xXF86VidModeValidateModeLineReq);
1480 swapl(&stuff->screen, n);
1481 swaps(&stuff->hdisplay, n);
1482 swaps(&stuff->hsyncstart, n);
1483 swaps(&stuff->hsyncend, n);
1484 swaps(&stuff->htotal, n);
1485 swaps(&stuff->vdisplay, n);
1486 swaps(&stuff->vsyncstart, n);
1487 swaps(&stuff->vsyncend, n);
1488 swaps(&stuff->vtotal, n);
1489 swapl(&stuff->flags, n);
1490 swapl(&stuff->privsize, n);
1492 return ProcXF86VidModeValidateModeLine(client);
1496 SProcXF86VidModeSwitchMode(client)
1500 REQUEST(xXF86VidModeSwitchModeReq);
1501 swaps(&stuff->length, n);
1502 REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq);
1503 swaps(&stuff->screen, n);
1504 swaps(&stuff->zoom, n);
1505 return ProcXF86VidModeSwitchMode(client);
1509 SProcXF86VidModeSwitchToMode(client)
1513 REQUEST(xXF86VidModeSwitchToModeReq);
1514 swaps(&stuff->length, n);
1515 REQUEST_SIZE_MATCH(xXF86VidModeSwitchToModeReq);
1516 swaps(&stuff->screen, n);
1517 return ProcXF86VidModeSwitchToMode(client);
1521 SProcXF86VidModeLockModeSwitch(client)
1525 REQUEST(xXF86VidModeLockModeSwitchReq);
1526 swaps(&stuff->length, n);
1527 REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
1528 swaps(&stuff->screen, n);
1529 swaps(&stuff->lock, n);
1530 return ProcXF86VidModeLockModeSwitch(client);
1534 SProcXF86VidModeGetMonitor(client)
1538 REQUEST(xXF86VidModeGetMonitorReq);
1539 swaps(&stuff->length, n);
1540 REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq);
1541 swaps(&stuff->screen, n);
1542 return ProcXF86VidModeGetMonitor(client);
1546 SProcXF86VidModeGetViewPort(client)
1550 REQUEST(xXF86VidModeGetViewPortReq);
1551 swaps(&stuff->length, n);
1552 REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq);
1553 swaps(&stuff->screen, n);
1554 return ProcXF86VidModeGetViewPort(client);
1558 SProcXF86VidModeSetViewPort(client)
1562 REQUEST(xXF86VidModeSetViewPortReq);
1563 swaps(&stuff->length, n);
1564 REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq);
1565 swaps(&stuff->screen, n);
1566 swapl(&stuff->x, n);
1567 swapl(&stuff->y, n);
1568 return ProcXF86VidModeSetViewPort(client);
1572 SProcXF86VidModeDispatch (client)
1573 register ClientPtr client;
1576 switch (stuff->data)
1578 case X_XF86VidModeQueryVersion:
1579 return SProcXF86VidModeQueryVersion(client);
1580 case X_XF86VidModeGetModeLine:
1581 return SProcXF86VidModeGetModeLine(client);
1582 case X_XF86VidModeGetAllModeLines:
1583 return SProcXF86VidModeGetAllModeLines(client);
1584 case X_XF86VidModeGetMonitor:
1585 return SProcXF86VidModeGetMonitor(client);
1586 case X_XF86VidModeGetViewPort:
1587 return SProcXF86VidModeGetViewPort(client);
1588 case X_XF86VidModeValidateModeLine:
1589 return SProcXF86VidModeValidateModeLine(client);
1591 if (!xf86VidModeEnabled)
1592 return vidmodeErrorBase + XF86VidModeExtensionDisabled;
1593 if (xf86VidModeAllowNonLocal || LocalClient(client)) {
1594 switch (stuff->data) {
1595 case X_XF86VidModeAddModeLine:
1596 return SProcXF86VidModeAddModeLine(client);
1597 case X_XF86VidModeDeleteModeLine:
1598 return SProcXF86VidModeDeleteModeLine(client);
1599 case X_XF86VidModeModModeLine:
1600 return SProcXF86VidModeModModeLine(client);
1601 case X_XF86VidModeSwitchMode:
1602 return SProcXF86VidModeSwitchMode(client);
1603 case X_XF86VidModeSwitchToMode:
1604 return SProcXF86VidModeSwitchToMode(client);
1605 case X_XF86VidModeLockModeSwitch:
1606 return SProcXF86VidModeLockModeSwitch(client);
1607 case X_XF86VidModeSetViewPort:
1608 return SProcXF86VidModeSetViewPort(client);
1613 return vidmodeErrorBase + XF86VidModeClientNotLocal;