[deb_xorg-server.git] / hw / xfree86 / common / xf86VidMode.c

/*
 * Copyright (c) 1999-2003 by The XFree86 Project, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Except as contained in this notice, the name of the copyright holder(s)
 * and author(s) shall not be used in advertising or otherwise to promote
 * the sale, use or other dealings in this Software without prior written
 * authorization from the copyright holder(s) and author(s).
 */

/*
 * This file contains the VidMode functions required by the extension.
 * These have been added to avoid the need for the higher level extension
 * code to access the private XFree86 data structures directly. Wherever
 * possible this code uses the functions in xf86Mode.c to do the work,
 * so that two version of code that do similar things don't have to be
 * maintained.
 */

#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif

#include <X11/X.h>
#include "os.h"
#include "xf86.h"
#include "xf86Priv.h"

#ifdef XF86VIDMODE
#include "vidmodeproc.h"
#include "xf86cmap.h"

static DevPrivateKeyRec VidModeKeyRec;
static DevPrivateKey VidModeKey;
static int VidModeCount = 0;
static Bool VidModeClose(ScreenPtr pScreen);

#define VMPTR(p) ((VidModePtr)dixLookupPrivate(&(p)->devPrivates, VidModeKey))

#endif

Bool
VidModeExtensionInit(ScreenPtr pScreen)
{
#ifdef XF86VIDMODE
    VidModePtr pVidMode;

    if (!xf86GetVidModeEnabled()) {
        DebugF("!xf86GetVidModeEnabled()\n");
        return FALSE;
    }

    VidModeKey = &VidModeKeyRec;

    if (!dixRegisterPrivateKey(&VidModeKeyRec, PRIVATE_SCREEN, 0))
        return FALSE;

    pVidMode = calloc(sizeof(VidModeRec), 1);
    if (!pVidMode)
        return FALSE;

    dixSetPrivate(&pScreen->devPrivates, VidModeKey, pVidMode);

    pVidMode->Flags = 0;
    pVidMode->Next = NULL;
    pVidMode->CloseScreen = pScreen->CloseScreen;
    pScreen->CloseScreen = VidModeClose;
    VidModeCount++;
    return TRUE;
#else
    DebugF("no vidmode extension\n");
    return FALSE;
#endif
}

#ifdef XF86VIDMODE

static Bool
VidModeClose(ScreenPtr pScreen)
{
    VidModePtr pVidMode = VMPTR(pScreen);

    /* This shouldn't happen */
    if (!pVidMode)
        return FALSE;

    pScreen->CloseScreen = pVidMode->CloseScreen;

    if (--VidModeCount == 0) {
        free(dixLookupPrivate(&pScreen->devPrivates, VidModeKey));
        dixSetPrivate(&pScreen->devPrivates, VidModeKey, NULL);
        VidModeKey = NULL;
    }
    return pScreen->CloseScreen(pScreen);
}

Bool
VidModeAvailable(int scrnIndex)
{
    ScrnInfoPtr pScrn;
    VidModePtr pVidMode;

    if (VidModeKey == NULL) {
        DebugF("VidModeKey == NULL\n");
        return FALSE;
    }

    pScrn = xf86Screens[scrnIndex];
    if (pScrn == NULL) {
        DebugF("pScrn == NULL\n");
        return FALSE;
    }

    pVidMode = VMPTR(pScrn->pScreen);
    if (pVidMode)
        return TRUE;
    else {
        DebugF("pVidMode == NULL\n");
        return FALSE;
    }
}

Bool
VidModeGetCurrentModeline(int scrnIndex, pointer *mode, int *dotClock)
{
    ScrnInfoPtr pScrn;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];

    if (pScrn->currentMode) {
        *mode = (pointer) (pScrn->currentMode);
        *dotClock = pScrn->currentMode->Clock;

        return TRUE;
    }
    return FALSE;
}

int
VidModeGetDotClock(int scrnIndex, int Clock)
{
    ScrnInfoPtr pScrn;

    if (!VidModeAvailable(scrnIndex))
        return 0;

    pScrn = xf86Screens[scrnIndex];
    if ((pScrn->progClock) || (Clock >= MAXCLOCKS))
        return Clock;
    else
        return pScrn->clock[Clock];
}

int
VidModeGetNumOfClocks(int scrnIndex, Bool *progClock)
{
    ScrnInfoPtr pScrn;

    if (!VidModeAvailable(scrnIndex))
        return 0;

    pScrn = xf86Screens[scrnIndex];
    if (pScrn->progClock) {
        *progClock = TRUE;
        return 0;
    }
    else {
        *progClock = FALSE;
        return pScrn->numClocks;
    }
}

Bool
VidModeGetClocks(int scrnIndex, int *Clocks)
{
    ScrnInfoPtr pScrn;
    int i;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];

    if (pScrn->progClock)
        return FALSE;

    for (i = 0; i < pScrn->numClocks; i++)
        *Clocks++ = pScrn->clock[i];

    return TRUE;
}

Bool
VidModeGetFirstModeline(int scrnIndex, pointer *mode, int *dotClock)
{
    ScrnInfoPtr pScrn;
    VidModePtr pVidMode;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    if (pScrn->modes == NULL)
        return FALSE;

    pVidMode = VMPTR(pScrn->pScreen);
    pVidMode->First = pScrn->modes;
    pVidMode->Next = pVidMode->First->next;

    if (pVidMode->First->status == MODE_OK) {
        *mode = (pointer) (pVidMode->First);
        *dotClock = VidModeGetDotClock(scrnIndex, pVidMode->First->Clock);
        return TRUE;
    }

    return VidModeGetNextModeline(scrnIndex, mode, dotClock);
}

Bool
VidModeGetNextModeline(int scrnIndex, pointer *mode, int *dotClock)
{
    ScrnInfoPtr pScrn;
    VidModePtr pVidMode;
    DisplayModePtr p;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    pVidMode = VMPTR(pScrn->pScreen);

    for (p = pVidMode->Next; p != NULL && p != pVidMode->First; p = p->next) {
        if (p->status == MODE_OK) {
            pVidMode->Next = p->next;
            *mode = (pointer) p;
            *dotClock = VidModeGetDotClock(scrnIndex, p->Clock);
            return TRUE;
        }
    }

    return FALSE;
}

Bool
VidModeDeleteModeline(int scrnIndex, pointer mode)
{
    ScrnInfoPtr pScrn;

    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    xf86DeleteMode(&(pScrn->modes), (DisplayModePtr) mode);
    return TRUE;
}

Bool
VidModeZoomViewport(int scrnIndex, int zoom)
{
    ScrnInfoPtr pScrn;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    xf86ZoomViewport(pScrn->pScreen, zoom);
    return TRUE;
}

Bool
VidModeSetViewPort(int scrnIndex, int x, int y)
{
    ScrnInfoPtr pScrn;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    pScrn->frameX0 = min(max(x, 0),
                         pScrn->virtualX - pScrn->currentMode->HDisplay);
    pScrn->frameX1 = pScrn->frameX0 + pScrn->currentMode->HDisplay - 1;
    pScrn->frameY0 = min(max(y, 0),
                         pScrn->virtualY - pScrn->currentMode->VDisplay);
    pScrn->frameY1 = pScrn->frameY0 + pScrn->currentMode->VDisplay - 1;
    if (pScrn->AdjustFrame != NULL)
        (pScrn->AdjustFrame) (pScrn, pScrn->frameX0, pScrn->frameY0);

    return TRUE;
}

Bool
VidModeGetViewPort(int scrnIndex, int *x, int *y)
{
    ScrnInfoPtr pScrn;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    *x = pScrn->frameX0;
    *y = pScrn->frameY0;
    return TRUE;
}

Bool
VidModeSwitchMode(int scrnIndex, pointer mode)
{
    ScrnInfoPtr pScrn;
    DisplayModePtr pTmpMode;
    Bool retval;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    /* save in case we fail */
    pTmpMode = pScrn->currentMode;
    /* Force a mode switch */
    pScrn->currentMode = NULL;
    retval = xf86SwitchMode(pScrn->pScreen, mode);
    /* we failed: restore it */
    if (retval == FALSE)
        pScrn->currentMode = pTmpMode;
    return retval;
}

Bool
VidModeLockZoom(int scrnIndex, Bool lock)
{
    ScrnInfoPtr pScrn;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];

    if (xf86Info.dontZoom)
        return FALSE;

    xf86LockZoom(pScrn->pScreen, lock);
    return TRUE;
}

Bool
VidModeGetMonitor(int scrnIndex, pointer *monitor)
{
    ScrnInfoPtr pScrn;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    *monitor = (pointer) (pScrn->monitor);

    return TRUE;
}

ModeStatus
VidModeCheckModeForMonitor(int scrnIndex, pointer mode)
{
    ScrnInfoPtr pScrn;

    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
        return MODE_ERROR;

    pScrn = xf86Screens[scrnIndex];

    return xf86CheckModeForMonitor((DisplayModePtr) mode, pScrn->monitor);
}

ModeStatus
VidModeCheckModeForDriver(int scrnIndex, pointer mode)
{
    ScrnInfoPtr pScrn;

    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
        return MODE_ERROR;

    pScrn = xf86Screens[scrnIndex];

    return xf86CheckModeForDriver(pScrn, (DisplayModePtr) mode, 0);
}

void
VidModeSetCrtcForMode(int scrnIndex, pointer mode)
{
    ScrnInfoPtr pScrn;
    DisplayModePtr ScreenModes;

    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
        return;

    /* Ugly hack so that the xf86Mode.c function can be used without change */
    pScrn = xf86Screens[scrnIndex];
    ScreenModes = pScrn->modes;
    pScrn->modes = (DisplayModePtr) mode;

    xf86SetCrtcForModes(pScrn, pScrn->adjustFlags);
    pScrn->modes = ScreenModes;
    return;
}

Bool
VidModeAddModeline(int scrnIndex, pointer mode)
{
    ScrnInfoPtr pScrn;

    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];

    ((DisplayModePtr) mode)->name = strdup(""); /* freed by deletemode */
    ((DisplayModePtr) mode)->status = MODE_OK;
    ((DisplayModePtr) mode)->next = pScrn->modes->next;
    ((DisplayModePtr) mode)->prev = pScrn->modes;
    pScrn->modes->next = (DisplayModePtr) mode;
    if (((DisplayModePtr) mode)->next != NULL)
        ((DisplayModePtr) mode)->next->prev = (DisplayModePtr) mode;

    return TRUE;
}

int
VidModeGetNumOfModes(int scrnIndex)
{
    pointer mode = NULL;
    int dotClock = 0, nummodes = 0;

    if (!VidModeGetFirstModeline(scrnIndex, &mode, &dotClock))
        return nummodes;

    do {
        nummodes++;
        if (!VidModeGetNextModeline(scrnIndex, &mode, &dotClock))
            return nummodes;
    } while (TRUE);
}

Bool
VidModeSetGamma(int scrnIndex, float red, float green, float blue)
{
    ScrnInfoPtr pScrn;
    Gamma gamma;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    gamma.red = red;
    gamma.green = green;
    gamma.blue = blue;
    if (xf86ChangeGamma(pScrn->pScreen, gamma) != Success)
        return FALSE;
    else
        return TRUE;
}

Bool
VidModeGetGamma(int scrnIndex, float *red, float *green, float *blue)
{
    ScrnInfoPtr pScrn;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    *red = pScrn->gamma.red;
    *green = pScrn->gamma.green;
    *blue = pScrn->gamma.blue;
    return TRUE;
}

Bool
VidModeSetGammaRamp(int scrnIndex, int size, CARD16 *r, CARD16 *g, CARD16 *b)
{
    ScrnInfoPtr pScrn;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    xf86ChangeGammaRamp(pScrn->pScreen, size, r, g, b);
    return TRUE;
}

Bool
VidModeGetGammaRamp(int scrnIndex, int size, CARD16 *r, CARD16 *g, CARD16 *b)
{
    ScrnInfoPtr pScrn;

    if (!VidModeAvailable(scrnIndex))
        return FALSE;

    pScrn = xf86Screens[scrnIndex];
    xf86GetGammaRamp(pScrn->pScreen, size, r, g, b);
    return TRUE;
}

int
VidModeGetGammaRampSize(int scrnIndex)
{
    if (!VidModeAvailable(scrnIndex))
        return 0;

    return xf86GetGammaRampSize(xf86Screens[scrnIndex]->pScreen);
}

pointer
VidModeCreateMode(void)
{
    DisplayModePtr mode;

    mode = malloc(sizeof(DisplayModeRec));
    if (mode != NULL) {
        mode->name = "";
        mode->VScan = 1;        /* divides refresh rate. default = 1 */
        mode->Private = NULL;
        mode->next = mode;
        mode->prev = mode;
    }
    return mode;
}

void
VidModeCopyMode(pointer modefrom, pointer modeto)
{
    memcpy(modeto, modefrom, sizeof(DisplayModeRec));
}

int
VidModeGetModeValue(pointer mode, int valtyp)
{
    int ret = 0;

    switch (valtyp) {
    case VIDMODE_H_DISPLAY:
        ret = ((DisplayModePtr) mode)->HDisplay;
        break;
    case VIDMODE_H_SYNCSTART:
        ret = ((DisplayModePtr) mode)->HSyncStart;
        break;
    case VIDMODE_H_SYNCEND:
        ret = ((DisplayModePtr) mode)->HSyncEnd;
        break;
    case VIDMODE_H_TOTAL:
        ret = ((DisplayModePtr) mode)->HTotal;
        break;
    case VIDMODE_H_SKEW:
        ret = ((DisplayModePtr) mode)->HSkew;
        break;
    case VIDMODE_V_DISPLAY:
        ret = ((DisplayModePtr) mode)->VDisplay;
        break;
    case VIDMODE_V_SYNCSTART:
        ret = ((DisplayModePtr) mode)->VSyncStart;
        break;
    case VIDMODE_V_SYNCEND:
        ret = ((DisplayModePtr) mode)->VSyncEnd;
        break;
    case VIDMODE_V_TOTAL:
        ret = ((DisplayModePtr) mode)->VTotal;
        break;
    case VIDMODE_FLAGS:
        ret = ((DisplayModePtr) mode)->Flags;
        break;
    case VIDMODE_CLOCK:
        ret = ((DisplayModePtr) mode)->Clock;
        break;
    }
    return ret;
}

void
VidModeSetModeValue(pointer mode, int valtyp, int val)
{
    switch (valtyp) {
    case VIDMODE_H_DISPLAY:
        ((DisplayModePtr) mode)->HDisplay = val;
        break;
    case VIDMODE_H_SYNCSTART:
        ((DisplayModePtr) mode)->HSyncStart = val;
        break;
    case VIDMODE_H_SYNCEND:
        ((DisplayModePtr) mode)->HSyncEnd = val;
        break;
    case VIDMODE_H_TOTAL:
        ((DisplayModePtr) mode)->HTotal = val;
        break;
    case VIDMODE_H_SKEW:
        ((DisplayModePtr) mode)->HSkew = val;
        break;
    case VIDMODE_V_DISPLAY:
        ((DisplayModePtr) mode)->VDisplay = val;
        break;
    case VIDMODE_V_SYNCSTART:
        ((DisplayModePtr) mode)->VSyncStart = val;
        break;
    case VIDMODE_V_SYNCEND:
        ((DisplayModePtr) mode)->VSyncEnd = val;
        break;
    case VIDMODE_V_TOTAL:
        ((DisplayModePtr) mode)->VTotal = val;
        break;
    case VIDMODE_FLAGS:
        ((DisplayModePtr) mode)->Flags = val;
        break;
    case VIDMODE_CLOCK:
        ((DisplayModePtr) mode)->Clock = val;
        break;
    }
    return;
}

vidMonitorValue
VidModeGetMonitorValue(pointer monitor, int valtyp, int indx)
{
    vidMonitorValue ret = { NULL, };

    switch (valtyp) {
    case VIDMODE_MON_VENDOR:
        ret.ptr = (((MonPtr) monitor)->vendor);
        break;
    case VIDMODE_MON_MODEL:
        ret.ptr = (((MonPtr) monitor)->model);
        break;
    case VIDMODE_MON_NHSYNC:
        ret.i = ((MonPtr) monitor)->nHsync;
        break;
    case VIDMODE_MON_NVREFRESH:
        ret.i = ((MonPtr) monitor)->nVrefresh;
        break;
    case VIDMODE_MON_HSYNC_LO:
        ret.f = (100.0 * ((MonPtr) monitor)->hsync[indx].lo);
        break;
    case VIDMODE_MON_HSYNC_HI:
        ret.f = (100.0 * ((MonPtr) monitor)->hsync[indx].hi);
        break;
    case VIDMODE_MON_VREFRESH_LO:
        ret.f = (100.0 * ((MonPtr) monitor)->vrefresh[indx].lo);
        break;
    case VIDMODE_MON_VREFRESH_HI:
        ret.f = (100.0 * ((MonPtr) monitor)->vrefresh[indx].hi);
        break;
    }
    return ret;
}

#endif                          /* XF86VIDMODE */
Commit	Line	Data
a09e091a JB	1	/*
	2	* Copyright (c) 1999-2003 by The XFree86 Project, Inc.
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a
	5	* copy of this software and associated documentation files (the "Software"),
	6	* to deal in the Software without restriction, including without limitation
	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	8	* and/or sell copies of the Software, and to permit persons to whom the
	9	* Software is furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*
	14	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	15	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	17	* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
	18	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	19	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	20	* OTHER DEALINGS IN THE SOFTWARE.
	21	*
	22	* Except as contained in this notice, the name of the copyright holder(s)
	23	* and author(s) shall not be used in advertising or otherwise to promote
	24	* the sale, use or other dealings in this Software without prior written
	25	* authorization from the copyright holder(s) and author(s).
	26	*/
	27
	28	/*
	29	* This file contains the VidMode functions required by the extension.
	30	* These have been added to avoid the need for the higher level extension
	31	* code to access the private XFree86 data structures directly. Wherever
	32	* possible this code uses the functions in xf86Mode.c to do the work,
	33	* so that two version of code that do similar things don't have to be
	34	* maintained.
	35	*/
	36
	37	#ifdef HAVE_XORG_CONFIG_H
	38	#include <xorg-config.h>
	39	#endif
	40
	41	#include <X11/X.h>
	42	#include "os.h"
	43	#include "xf86.h"
	44	#include "xf86Priv.h"
	45
	46	#ifdef XF86VIDMODE
	47	#include "vidmodeproc.h"
	48	#include "xf86cmap.h"
	49
	50	static DevPrivateKeyRec VidModeKeyRec;
	51	static DevPrivateKey VidModeKey;
	52	static int VidModeCount = 0;
	53	static Bool VidModeClose(ScreenPtr pScreen);
	54
	55	#define VMPTR(p) ((VidModePtr)dixLookupPrivate(&(p)->devPrivates, VidModeKey))
	56
	57	#endif
	58
	59	Bool
	60	VidModeExtensionInit(ScreenPtr pScreen)
	61	{
	62	#ifdef XF86VIDMODE
	63	VidModePtr pVidMode;
	64
65	if (!xf86GetVidModeEnabled()) {
66	DebugF("!xf86GetVidModeEnabled()\n");
67	return FALSE;
68	}
69
70	VidModeKey = &VidModeKeyRec;
71
72	if (!dixRegisterPrivateKey(&VidModeKeyRec, PRIVATE_SCREEN, 0))
73	return FALSE;
74
75	pVidMode = calloc(sizeof(VidModeRec), 1);
76	if (!pVidMode)
77	return FALSE;
78
79	dixSetPrivate(&pScreen->devPrivates, VidModeKey, pVidMode);
80
81	pVidMode->Flags = 0;
82	pVidMode->Next = NULL;
83	pVidMode->CloseScreen = pScreen->CloseScreen;
84	pScreen->CloseScreen = VidModeClose;
85	VidModeCount++;
86	return TRUE;
87	#else
88	DebugF("no vidmode extension\n");
89	return FALSE;
90	#endif
91	}
92
93	#ifdef XF86VIDMODE
94
95	static Bool
96	VidModeClose(ScreenPtr pScreen)
97	{
98	VidModePtr pVidMode = VMPTR(pScreen);
99
100	/* This shouldn't happen */
101	if (!pVidMode)
102	return FALSE;
103
104	pScreen->CloseScreen = pVidMode->CloseScreen;
105
106	if (--VidModeCount == 0) {
107	free(dixLookupPrivate(&pScreen->devPrivates, VidModeKey));
108	dixSetPrivate(&pScreen->devPrivates, VidModeKey, NULL);
109	VidModeKey = NULL;
110	}
111	return pScreen->CloseScreen(pScreen);
112	}
113
114	Bool
115	VidModeAvailable(int scrnIndex)
116	{
117	ScrnInfoPtr pScrn;
118	VidModePtr pVidMode;
119
120	if (VidModeKey == NULL) {
121	DebugF("VidModeKey == NULL\n");
122	return FALSE;
123	}
124
125	pScrn = xf86Screens[scrnIndex];
126	if (pScrn == NULL) {
127	DebugF("pScrn == NULL\n");
128	return FALSE;
129	}
130
131	pVidMode = VMPTR(pScrn->pScreen);
132	if (pVidMode)
133	return TRUE;
134	else {
135	DebugF("pVidMode == NULL\n");
136	return FALSE;
137	}
138	}
139
140	Bool
141	VidModeGetCurrentModeline(int scrnIndex, pointer mode, int dotClock)
142	{
143	ScrnInfoPtr pScrn;
144
145	if (!VidModeAvailable(scrnIndex))
146	return FALSE;
147
148	pScrn = xf86Screens[scrnIndex];
149
150	if (pScrn->currentMode) {
151	*mode = (pointer) (pScrn->currentMode);
152	*dotClock = pScrn->currentMode->Clock;
153
154	return TRUE;
155	}
156	return FALSE;
157	}
158
159	int
160	VidModeGetDotClock(int scrnIndex, int Clock)
161	{
162	ScrnInfoPtr pScrn;
163
164	if (!VidModeAvailable(scrnIndex))
165	return 0;
166
167	pScrn = xf86Screens[scrnIndex];
168	if ((pScrn->progClock) \|\| (Clock >= MAXCLOCKS))
169	return Clock;
170	else
171	return pScrn->clock[Clock];
172	}
173
174	int
175	VidModeGetNumOfClocks(int scrnIndex, Bool *progClock)
176	{
177	ScrnInfoPtr pScrn;
178
179	if (!VidModeAvailable(scrnIndex))
180	return 0;
181
182	pScrn = xf86Screens[scrnIndex];
183	if (pScrn->progClock) {
184	*progClock = TRUE;
185	return 0;
186	}
187	else {
188	*progClock = FALSE;
189	return pScrn->numClocks;
190	}
191	}
192
193	Bool
194	VidModeGetClocks(int scrnIndex, int *Clocks)
195	{
196	ScrnInfoPtr pScrn;
197	int i;
198
199	if (!VidModeAvailable(scrnIndex))
200	return FALSE;
201
202	pScrn = xf86Screens[scrnIndex];
203
204	if (pScrn->progClock)
205	return FALSE;
206
207	for (i = 0; i < pScrn->numClocks; i++)
208	*Clocks++ = pScrn->clock[i];
209
210	return TRUE;
211	}
212
213	Bool
214	VidModeGetFirstModeline(int scrnIndex, pointer mode, int dotClock)
215	{
216	ScrnInfoPtr pScrn;
217	VidModePtr pVidMode;
218
219	if (!VidModeAvailable(scrnIndex))
220	return FALSE;
221
222	pScrn = xf86Screens[scrnIndex];
223	if (pScrn->modes == NULL)
224	return FALSE;
225
226	pVidMode = VMPTR(pScrn->pScreen);
227	pVidMode->First = pScrn->modes;
228	pVidMode->Next = pVidMode->First->next;
229
230	if (pVidMode->First->status == MODE_OK) {
231	*mode = (pointer) (pVidMode->First);
232	*dotClock = VidModeGetDotClock(scrnIndex, pVidMode->First->Clock);
233	return TRUE;
234	}
235
236	return VidModeGetNextModeline(scrnIndex, mode, dotClock);
237	}
238
239	Bool
240	VidModeGetNextModeline(int scrnIndex, pointer mode, int dotClock)
241	{
242	ScrnInfoPtr pScrn;
243	VidModePtr pVidMode;
244	DisplayModePtr p;
245
246	if (!VidModeAvailable(scrnIndex))
247	return FALSE;
248
249	pScrn = xf86Screens[scrnIndex];
250	pVidMode = VMPTR(pScrn->pScreen);
251
252	for (p = pVidMode->Next; p != NULL && p != pVidMode->First; p = p->next) {
253	if (p->status == MODE_OK) {
254	pVidMode->Next = p->next;
255	*mode = (pointer) p;
256	*dotClock = VidModeGetDotClock(scrnIndex, p->Clock);
257	return TRUE;
258	}
259	}
260
261	return FALSE;
262	}
263
264	Bool
265	VidModeDeleteModeline(int scrnIndex, pointer mode)
266	{
267	ScrnInfoPtr pScrn;
268
269	if ((mode == NULL) \|\| (!VidModeAvailable(scrnIndex)))
270	return FALSE;
271
272	pScrn = xf86Screens[scrnIndex];
273	xf86DeleteMode(&(pScrn->modes), (DisplayModePtr) mode);
274	return TRUE;
275	}
276
277	Bool
278	VidModeZoomViewport(int scrnIndex, int zoom)
279	{
280	ScrnInfoPtr pScrn;
281
282	if (!VidModeAvailable(scrnIndex))
283	return FALSE;
284
285	pScrn = xf86Screens[scrnIndex];
286	xf86ZoomViewport(pScrn->pScreen, zoom);
287	return TRUE;
288	}
289
290	Bool
291	VidModeSetViewPort(int scrnIndex, int x, int y)
292	{
293	ScrnInfoPtr pScrn;
294
295	if (!VidModeAvailable(scrnIndex))
296	return FALSE;
297
298	pScrn = xf86Screens[scrnIndex];
299	pScrn->frameX0 = min(max(x, 0),
300	pScrn->virtualX - pScrn->currentMode->HDisplay);
301	pScrn->frameX1 = pScrn->frameX0 + pScrn->currentMode->HDisplay - 1;
302	pScrn->frameY0 = min(max(y, 0),
303	pScrn->virtualY - pScrn->currentMode->VDisplay);
304	pScrn->frameY1 = pScrn->frameY0 + pScrn->currentMode->VDisplay - 1;
305	if (pScrn->AdjustFrame != NULL)
306	(pScrn->AdjustFrame) (pScrn, pScrn->frameX0, pScrn->frameY0);
307
308	return TRUE;
309	}
310
311	Bool
312	VidModeGetViewPort(int scrnIndex, int x, int y)
313	{
314	ScrnInfoPtr pScrn;
315
316	if (!VidModeAvailable(scrnIndex))
317	return FALSE;
318
319	pScrn = xf86Screens[scrnIndex];
320	*x = pScrn->frameX0;
321	*y = pScrn->frameY0;
322	return TRUE;
323	}
324
325	Bool
326	VidModeSwitchMode(int scrnIndex, pointer mode)
327	{
328	ScrnInfoPtr pScrn;
329	DisplayModePtr pTmpMode;
330	Bool retval;
331
332	if (!VidModeAvailable(scrnIndex))
333	return FALSE;
334
335	pScrn = xf86Screens[scrnIndex];
336	/* save in case we fail */
337	pTmpMode = pScrn->currentMode;
338	/* Force a mode switch */
339	pScrn->currentMode = NULL;
340	retval = xf86SwitchMode(pScrn->pScreen, mode);
341	/* we failed: restore it */
342	if (retval == FALSE)
343	pScrn->currentMode = pTmpMode;
344	return retval;
345	}
346
347	Bool
348	VidModeLockZoom(int scrnIndex, Bool lock)
349	{
350	ScrnInfoPtr pScrn;
351
352	if (!VidModeAvailable(scrnIndex))
353	return FALSE;
354
355	pScrn = xf86Screens[scrnIndex];
356
357	if (xf86Info.dontZoom)
358	return FALSE;
359
360	xf86LockZoom(pScrn->pScreen, lock);
361	return TRUE;
362	}
363
364	Bool
365	VidModeGetMonitor(int scrnIndex, pointer *monitor)
366	{
367	ScrnInfoPtr pScrn;
368
369	if (!VidModeAvailable(scrnIndex))
370	return FALSE;
371
372	pScrn = xf86Screens[scrnIndex];
373	*monitor = (pointer) (pScrn->monitor);
374
375	return TRUE;
376	}
377
378	ModeStatus
379	VidModeCheckModeForMonitor(int scrnIndex, pointer mode)
380	{
381	ScrnInfoPtr pScrn;
382
383	if ((mode == NULL) \|\| (!VidModeAvailable(scrnIndex)))
384	return MODE_ERROR;
385
386	pScrn = xf86Screens[scrnIndex];
387
388	return xf86CheckModeForMonitor((DisplayModePtr) mode, pScrn->monitor);
389	}
390
391	ModeStatus
392	VidModeCheckModeForDriver(int scrnIndex, pointer mode)
393	{
394	ScrnInfoPtr pScrn;
395
396	if ((mode == NULL) \|\| (!VidModeAvailable(scrnIndex)))
397	return MODE_ERROR;
398
399	pScrn = xf86Screens[scrnIndex];
400
401	return xf86CheckModeForDriver(pScrn, (DisplayModePtr) mode, 0);
402	}
403
404	void
405	VidModeSetCrtcForMode(int scrnIndex, pointer mode)
406	{
407	ScrnInfoPtr pScrn;
408	DisplayModePtr ScreenModes;
409
410	if ((mode == NULL) \|\| (!VidModeAvailable(scrnIndex)))
411	return;
412
413	/* Ugly hack so that the xf86Mode.c function can be used without change */
414	pScrn = xf86Screens[scrnIndex];
415	ScreenModes = pScrn->modes;
416	pScrn->modes = (DisplayModePtr) mode;
417
418	xf86SetCrtcForModes(pScrn, pScrn->adjustFlags);
419	pScrn->modes = ScreenModes;
420	return;
421	}
422
423	Bool
424	VidModeAddModeline(int scrnIndex, pointer mode)
425	{
426	ScrnInfoPtr pScrn;
427
428	if ((mode == NULL) \|\| (!VidModeAvailable(scrnIndex)))
429	return FALSE;
430
431	pScrn = xf86Screens[scrnIndex];
432
433	((DisplayModePtr) mode)->name = strdup(""); /* freed by deletemode */
434	((DisplayModePtr) mode)->status = MODE_OK;
435	((DisplayModePtr) mode)->next = pScrn->modes->next;
436	((DisplayModePtr) mode)->prev = pScrn->modes;
437	pScrn->modes->next = (DisplayModePtr) mode;
438	if (((DisplayModePtr) mode)->next != NULL)
439	((DisplayModePtr) mode)->next->prev = (DisplayModePtr) mode;
440
441	return TRUE;
442	}
443
444	int
445	VidModeGetNumOfModes(int scrnIndex)
446	{
447	pointer mode = NULL;
448	int dotClock = 0, nummodes = 0;
449
450	if (!VidModeGetFirstModeline(scrnIndex, &mode, &dotClock))
451	return nummodes;
452
453	do {
454	nummodes++;
455	if (!VidModeGetNextModeline(scrnIndex, &mode, &dotClock))
456	return nummodes;
457	} while (TRUE);
458	}
459
460	Bool
461	VidModeSetGamma(int scrnIndex, float red, float green, float blue)
462	{
463	ScrnInfoPtr pScrn;
464	Gamma gamma;
465
466	if (!VidModeAvailable(scrnIndex))
467	return FALSE;
468
469	pScrn = xf86Screens[scrnIndex];
470	gamma.red = red;
471	gamma.green = green;
472	gamma.blue = blue;
473	if (xf86ChangeGamma(pScrn->pScreen, gamma) != Success)
474	return FALSE;
475	else
476	return TRUE;
477	}
478
479	Bool
480	VidModeGetGamma(int scrnIndex, float red, float green, float *blue)
481	{
482	ScrnInfoPtr pScrn;
483
484	if (!VidModeAvailable(scrnIndex))
485	return FALSE;
486
487	pScrn = xf86Screens[scrnIndex];
488	*red = pScrn->gamma.red;
489	*green = pScrn->gamma.green;
490	*blue = pScrn->gamma.blue;
491	return TRUE;
492	}
493
494	Bool
495	VidModeSetGammaRamp(int scrnIndex, int size, CARD16 r, CARD16 g, CARD16 *b)
496	{
497	ScrnInfoPtr pScrn;
498
499	if (!VidModeAvailable(scrnIndex))
500	return FALSE;
501
502	pScrn = xf86Screens[scrnIndex];
503	xf86ChangeGammaRamp(pScrn->pScreen, size, r, g, b);
504	return TRUE;
505	}
506
507	Bool
508	VidModeGetGammaRamp(int scrnIndex, int size, CARD16 r, CARD16 g, CARD16 *b)
509	{
510	ScrnInfoPtr pScrn;
511
512	if (!VidModeAvailable(scrnIndex))
513	return FALSE;
514
515	pScrn = xf86Screens[scrnIndex];
516	xf86GetGammaRamp(pScrn->pScreen, size, r, g, b);
517	return TRUE;
518	}
519
520	int
521	VidModeGetGammaRampSize(int scrnIndex)
522	{
523	if (!VidModeAvailable(scrnIndex))
524	return 0;
525
526	return xf86GetGammaRampSize(xf86Screens[scrnIndex]->pScreen);
527	}
528
529	pointer
530	VidModeCreateMode(void)
531	{
532	DisplayModePtr mode;
533
534	mode = malloc(sizeof(DisplayModeRec));
535	if (mode != NULL) {
536	mode->name = "";
537	mode->VScan = 1; /* divides refresh rate. default = 1 */
538	mode->Private = NULL;
539	mode->next = mode;
540	mode->prev = mode;
541	}
542	return mode;
543	}
544
545	void
546	VidModeCopyMode(pointer modefrom, pointer modeto)
547	{
548	memcpy(modeto, modefrom, sizeof(DisplayModeRec));
549	}
550
551	int
552	VidModeGetModeValue(pointer mode, int valtyp)
553	{
554	int ret = 0;
555
556	switch (valtyp) {
557	case VIDMODE_H_DISPLAY:
558	ret = ((DisplayModePtr) mode)->HDisplay;
559	break;
560	case VIDMODE_H_SYNCSTART:
561	ret = ((DisplayModePtr) mode)->HSyncStart;
562	break;
563	case VIDMODE_H_SYNCEND:
564	ret = ((DisplayModePtr) mode)->HSyncEnd;
565	break;
566	case VIDMODE_H_TOTAL:
567	ret = ((DisplayModePtr) mode)->HTotal;
568	break;
569	case VIDMODE_H_SKEW:
570	ret = ((DisplayModePtr) mode)->HSkew;
571	break;
572	case VIDMODE_V_DISPLAY:
573	ret = ((DisplayModePtr) mode)->VDisplay;
574	break;
575	case VIDMODE_V_SYNCSTART:
576	ret = ((DisplayModePtr) mode)->VSyncStart;
577	break;
578	case VIDMODE_V_SYNCEND:
579	ret = ((DisplayModePtr) mode)->VSyncEnd;
580	break;
581	case VIDMODE_V_TOTAL:
582	ret = ((DisplayModePtr) mode)->VTotal;
583	break;
584	case VIDMODE_FLAGS:
585	ret = ((DisplayModePtr) mode)->Flags;
586	break;
587	case VIDMODE_CLOCK:
588	ret = ((DisplayModePtr) mode)->Clock;
589	break;
590	}
591	return ret;
592	}
593
594	void
595	VidModeSetModeValue(pointer mode, int valtyp, int val)
596	{
597	switch (valtyp) {
598	case VIDMODE_H_DISPLAY:
599	((DisplayModePtr) mode)->HDisplay = val;
600	break;
601	case VIDMODE_H_SYNCSTART:
602	((DisplayModePtr) mode)->HSyncStart = val;
603	break;
604	case VIDMODE_H_SYNCEND:
605	((DisplayModePtr) mode)->HSyncEnd = val;
606	break;
607	case VIDMODE_H_TOTAL:
608	((DisplayModePtr) mode)->HTotal = val;
609	break;
610	case VIDMODE_H_SKEW:
611	((DisplayModePtr) mode)->HSkew = val;
612	break;
613	case VIDMODE_V_DISPLAY:
614	((DisplayModePtr) mode)->VDisplay = val;
615	break;
616	case VIDMODE_V_SYNCSTART:
617	((DisplayModePtr) mode)->VSyncStart = val;
618	break;
619	case VIDMODE_V_SYNCEND:
620	((DisplayModePtr) mode)->VSyncEnd = val;
621	break;
622	case VIDMODE_V_TOTAL:
623	((DisplayModePtr) mode)->VTotal = val;
624	break;
625	case VIDMODE_FLAGS:
626	((DisplayModePtr) mode)->Flags = val;
627	break;
628	case VIDMODE_CLOCK:
629	((DisplayModePtr) mode)->Clock = val;
630	break;
631	}
632	return;
633	}
634
635	vidMonitorValue
636	VidModeGetMonitorValue(pointer monitor, int valtyp, int indx)
637	{
638	vidMonitorValue ret = { NULL, };
639
640	switch (valtyp) {
641	case VIDMODE_MON_VENDOR:
642	ret.ptr = (((MonPtr) monitor)->vendor);
643	break;
644	case VIDMODE_MON_MODEL:
645	ret.ptr = (((MonPtr) monitor)->model);
646	break;
647	case VIDMODE_MON_NHSYNC:
648	ret.i = ((MonPtr) monitor)->nHsync;
649	break;
650	case VIDMODE_MON_NVREFRESH:
651	ret.i = ((MonPtr) monitor)->nVrefresh;
652	break;
653	case VIDMODE_MON_HSYNC_LO:
654	ret.f = (100.0 * ((MonPtr) monitor)->hsync[indx].lo);
655	break;
656	case VIDMODE_MON_HSYNC_HI:
657	ret.f = (100.0 * ((MonPtr) monitor)->hsync[indx].hi);
658	break;
659	case VIDMODE_MON_VREFRESH_LO:
660	ret.f = (100.0 * ((MonPtr) monitor)->vrefresh[indx].lo);
661	break;
662	case VIDMODE_MON_VREFRESH_HI:
663	ret.f = (100.0 * ((MonPtr) monitor)->vrefresh[indx].hi);
664	break;
665	}
666	return ret;
667	}
668
669	#endif /* XF86VIDMODE */