/* $XdotOrg: xc/programs/Xserver/hw/xfree86/common/xf86Mode.c,v 1.4 2005/05/18 10:31:53 eich Exp $ */

/* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86Mode.c,v 1.69 2003/10/08 14:58:28 dawes Exp $ */

/*

 * Copyright (c) 1997-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).

 */

/*

 * Authors: Dirk Hohndel <[email protected]>

 *          David Dawes <[email protected]>

 *          Marc La France <[email protected]>

 *          ... and others

 *

 * This file includes helper functions for mode related things.

 */

#ifdef HAVE_XORG_CONFIG_H

#include <xorg-config.h>

#endif

#include <X11/X.h>

#include "os.h"

#include "servermd.h"

#include "mibank.h"

#include "globals.h"

#include "xf86.h"

#include "xf86Priv.h"

#include "xf86DDC.h"

static void PrintModeline(int scrnIndex,DisplayModePtr mode);

/*

 * xf86GetNearestClock --

 *	Find closest clock to given frequency (in kHz).  This assumes the

 *	number of clocks is greater than zero.

 */

int

xf86GetNearestClock(ScrnInfoPtr scrp, int freq, Bool allowDiv2,

    int DivFactor, int MulFactor, int *divider)

{

    int nearestClock = 0, nearestDiv = 1;

    int minimumGap = abs(freq - scrp->clock[0]);

    int i, j, k, gap;

    if (allowDiv2)

	k = 2;

    else

	k = 1;

    /* Must set this here in case the best match is scrp->clock[0] */

    if (divider != NULL)

	*divider = 0;

    for (i = 0;  i < scrp->numClocks;  i++) {

	for (j = 1; j <= k; j++) {

	    gap = abs((freq * j) - ((scrp->clock[i] * DivFactor) / MulFactor));

	    if ((gap < minimumGap) ||

		((gap == minimumGap) && (j < nearestDiv))) {

		minimumGap = gap;

		nearestClock = i;

		nearestDiv = j;

		if (divider != NULL)

		    *divider = (j - 1) * V_CLKDIV2;

	    }

	}

    }

    return nearestClock;

}

/*

 * xf86ModeStatusToString

 *

 * Convert a ModeStatus value to a printable message

 */

const char *

xf86ModeStatusToString(ModeStatus status)

{

    switch (status) {

    case MODE_OK:

	return "Mode OK";

    case MODE_HSYNC:

	return "hsync out of range";

    case MODE_VSYNC:

	return "vrefresh out of range";

    case MODE_H_ILLEGAL:

	return "illegal horizontal timings";

    case MODE_V_ILLEGAL:

	return "illegal vertical timings";

    case MODE_BAD_WIDTH:

	return "width requires unsupported line pitch";

    case MODE_NOMODE:

	return "no mode is found";

    case MODE_NO_INTERLACE:

	return "interlace mode not supported";

    case MODE_NO_DBLESCAN:

	return "doublescan mode not supported";

    case MODE_NO_VSCAN:

	return "multiscan mode not supported";

    case MODE_MEM:

	return "insufficient memory for mode";

    case MODE_VIRTUAL_X:

	return "width too large for virtual size";

    case MODE_VIRTUAL_Y:

	return "height too large for virtual size";

    case MODE_MEM_VIRT:

	return "insufficient memory given virtual size";

    case MODE_NOCLOCK:

	return "no clock available for mode";

    case MODE_CLOCK_HIGH:

	return "mode clock too high";

    case MODE_CLOCK_LOW:

	return "mode clock too low";

    case MODE_CLOCK_RANGE:

	return "bad mode clock/interlace/doublescan";

    case MODE_BAD_HVALUE:

	return "horizontal timing out of range";

    case MODE_BAD_VVALUE:

	return "vertical timing out of range";

    case MODE_BAD_VSCAN:

	return "VScan value out of range";

    case MODE_HSYNC_NARROW:

	return "horizontal sync too narrow";

    case MODE_HSYNC_WIDE:

	return "horizontal sync too wide";

    case MODE_HBLANK_NARROW:

	return "horizontal blanking too narrow";

    case MODE_HBLANK_WIDE:

	return "horizontal blanking too wide";

    case MODE_VSYNC_NARROW:

	return "vertical sync too narrow";

    case MODE_VSYNC_WIDE:

	return "vertical sync too wide";

    case MODE_VBLANK_NARROW:

	return "vertical blanking too narrow";

    case MODE_VBLANK_WIDE:

	return "vertical blanking too wide";

    case MODE_PANEL:

	return "exceeds panel dimensions";

    case MODE_INTERLACE_WIDTH:

	return "width too large for interlaced mode";

    case MODE_ONE_WIDTH:

        return "all modes must have the same width";

    case MODE_ONE_HEIGHT:

        return "all modes must have the same height";

    case MODE_ONE_SIZE:

        return "all modes must have the same resolution";

    case MODE_BAD:

	return "unknown reason";

    case MODE_ERROR:

	return "internal error";

    default:

	return "unknown";

    }

}

/*

 * xf86ShowClockRanges() -- Print the clock ranges allowed

 * and the clock values scaled by ClockMulFactor and ClockDivFactor

 */

void

xf86ShowClockRanges(ScrnInfoPtr scrp, ClockRangePtr clockRanges)

{

    ClockRangePtr cp;

    int MulFactor = 1;

    int DivFactor = 1;

    int i, j;

    int scaledClock;

    for (cp = clockRanges; cp != NULL; cp = cp->next) {

	DivFactor = max(1, cp->ClockDivFactor);

	MulFactor = max(1, cp->ClockMulFactor);

	if (scrp->progClock) {

	    if (cp->minClock) {

		if (cp->maxClock) {

		    xf86DrvMsg(scrp->scrnIndex, X_INFO,

			"Clock range: %6.2f to %6.2f MHz\n",

			(double)cp->minClock / 1000.0,

			(double)cp->maxClock / 1000.0);

		} else {

		    xf86DrvMsg(scrp->scrnIndex, X_INFO,

			"Minimum clock: %6.2f MHz\n",

			(double)cp->minClock / 1000.0);

		}

	    } else {

		if (cp->maxClock) {

		    xf86DrvMsg(scrp->scrnIndex, X_INFO,

			"Maximum clock: %6.2f MHz\n",

			(double)cp->maxClock / 1000.0);

		}

	    }

	} else if (DivFactor > 1 || MulFactor > 1) {

	    j = 0;

	    for (i = 0; i < scrp->numClocks; i++) {

		scaledClock = (scrp->clock[i] * DivFactor) / MulFactor;

		if (scaledClock >= cp->minClock && scaledClock <= cp->maxClock) {

		    if ((j % 8) == 0) {

			if (j > 0)

			    xf86ErrorF("\n");

			xf86DrvMsg(scrp->scrnIndex, X_INFO, "scaled clocks:");

		    }

		    xf86ErrorF(" %6.2f", (double)scaledClock / 1000.0);

		    j++;

		}

	    }

	    xf86ErrorF("\n");

	}

    }

}

/*

 * xf86FindClockRangeForMode()    [... like the name says ...]

 */

static ClockRangePtr

xf86FindClockRangeForMode(ClockRangePtr clockRanges, DisplayModePtr p)

{

    ClockRangePtr cp;

    for (cp = clockRanges; ; cp = cp->next)

	if (!cp ||

	    ((p->Clock >= cp->minClock) &&

	     (p->Clock <= cp->maxClock) &&

	     (cp->interlaceAllowed || !(p->Flags & V_INTERLACE)) &&

	     (cp->doubleScanAllowed ||

	      ((p->VScan <= 1) && !(p->Flags & V_DBLSCAN)))))

	    return cp;

}

/*

 * xf86HandleBuiltinMode() - handles built-in modes

 */

static ModeStatus

xf86HandleBuiltinMode(ScrnInfoPtr scrp,

		      DisplayModePtr p,

		      DisplayModePtr modep,

		      ClockRangePtr clockRanges,

		      Bool allowDiv2)

{

    ClockRangePtr cp;

    int extraFlags = 0;

    int MulFactor = 1;

    int DivFactor = 1;

    int clockIndex;

    /* Reject previously rejected modes */

    if (p->status != MODE_OK)

	return p->status;

    /* Reject previously considered modes */

    if ((p->prev) && (p->type == M_T_BUILTIN))

        return MODE_NOMODE;

    if ((p->type & M_T_CLOCK_C) == M_T_CLOCK_C) {

	/* Check clock is in range */

	cp = xf86FindClockRangeForMode(clockRanges, p);

	if (cp == NULL){

	    modep->type = p->type;

	    p->status = MODE_CLOCK_RANGE;

	    return MODE_CLOCK_RANGE;

	}

	DivFactor = cp->ClockDivFactor;

	MulFactor = cp->ClockMulFactor;

	if (!scrp->progClock) {

	    clockIndex = xf86GetNearestClock(scrp, p->Clock, allowDiv2,

					     cp->ClockDivFactor,

					     cp->ClockMulFactor, &extraFlags);

	    modep->Clock = (scrp->clock[clockIndex] * DivFactor)

		/ MulFactor;

	    modep->ClockIndex	= clockIndex;

	    modep->SynthClock	= scrp->clock[clockIndex];

	    if (extraFlags & V_CLKDIV2) {

		modep->Clock /= 2;

		modep->SynthClock /= 2;

	    }

	} else {

	    modep->Clock = p->Clock;

	    modep->ClockIndex = -1;

	    modep->SynthClock = (modep->Clock * MulFactor)

		/ DivFactor;

	}

	modep->PrivFlags = cp->PrivFlags;

    } else {

	if(!scrp->progClock) {

            modep->Clock = p->Clock;

	    modep->ClockIndex = p->ClockIndex;

	    modep->SynthClock = p->SynthClock;

	} else {

	    modep->Clock = p->Clock;

	    modep->ClockIndex = -1;

	    modep->SynthClock = p->SynthClock;

	}

	modep->PrivFlags = p->PrivFlags;

    }

    modep->type            = p->type;

    modep->HDisplay        = p->HDisplay;

    modep->HSyncStart      = p->HSyncStart;

    modep->HSyncEnd        = p->HSyncEnd;

    modep->HTotal          = p->HTotal;

    modep->HSkew           = p->HSkew;

    modep->VDisplay        = p->VDisplay;

    modep->VSyncStart      = p->VSyncStart;

    modep->VSyncEnd        = p->VSyncEnd;

    modep->VTotal          = p->VTotal;

    modep->VScan           = p->VScan;

    modep->Flags           = p->Flags | extraFlags;

    modep->CrtcHDisplay    = p->CrtcHDisplay;

    modep->CrtcHBlankStart = p->CrtcHBlankStart;

    modep->CrtcHSyncStart  = p->CrtcHSyncStart;

    modep->CrtcHSyncEnd    = p->CrtcHSyncEnd;

    modep->CrtcHBlankEnd   = p->CrtcHBlankEnd;

    modep->CrtcHTotal      = p->CrtcHTotal;

    modep->CrtcHSkew       = p->CrtcHSkew;

    modep->CrtcVDisplay    = p->CrtcVDisplay;

    modep->CrtcVBlankStart = p->CrtcVBlankStart;

    modep->CrtcVSyncStart  = p->CrtcVSyncStart;

    modep->CrtcVSyncEnd    = p->CrtcVSyncEnd;

    modep->CrtcVBlankEnd   = p->CrtcVBlankEnd;

    modep->CrtcVTotal      = p->CrtcVTotal;

    modep->CrtcHAdjusted   = p->CrtcHAdjusted;

    modep->CrtcVAdjusted   = p->CrtcVAdjusted;

    modep->HSync           = p->HSync;

    modep->VRefresh        = p->VRefresh;

    modep->Private         = p->Private;

    modep->PrivSize        = p->PrivSize;

    p->prev = modep;

    return MODE_OK;

}

static double

ModeHSync(DisplayModePtr mode)

{

    double hsync = 0.0;

    if (mode->HSync > 0.0)

	    hsync = mode->HSync;

    else if (mode->HTotal > 0)

	    hsync = (float)mode->Clock / (float)mode->HTotal;

    return hsync;

}

static double

ModeVRefresh(DisplayModePtr mode)

{

    double refresh = 0.0;

    if (mode->VRefresh > 0.0)

	refresh = mode->VRefresh;

    else if (mode->HTotal > 0 && mode->VTotal > 0) {

	refresh = mode->Clock * 1000.0 / mode->HTotal / mode->VTotal;

	if (mode->Flags & V_INTERLACE)

	    refresh *= 2.0;

	if (mode->Flags & V_DBLSCAN)

	    refresh /= 2.0;

	if (mode->VScan > 1)

	    refresh /= (float)(mode->VScan);

    }

    return refresh;

}

/*

 * xf86LookupMode

 *

 * This function returns a mode from the given list which matches the

 * given name.  When multiple modes with the same name are available,

 * the method of picking the matching mode is determined by the

 * strategy selected.

 *

 * This function takes the following parameters:

 *    scrp         ScrnInfoPtr

 *    modep        pointer to the returned mode, which must have the name

 *                 field filled in.

 *    clockRanges  a list of clock ranges.   This is optional when all the

 *                 modes are built-in modes.

 *    strategy     how to decide which mode to use from multiple modes with

 *                 the same name

 *

 * In addition, the following fields from the ScrnInfoRec are used:

 *    modePool     the list of monitor modes compatible with the driver

 *    clocks       a list of discrete clocks

 *    numClocks    number of discrete clocks

 *    progClock    clock is programmable

 *

 * If a mode was found, its values are filled in to the area pointed to

 * by modep,  If a mode was not found the return value indicates the

 * reason.

 */

ModeStatus

xf86LookupMode(ScrnInfoPtr scrp, DisplayModePtr modep,

	       ClockRangePtr clockRanges, LookupModeFlags strategy)

{

    DisplayModePtr p, bestMode = NULL;

    ClockRangePtr cp;

    int i, k, gap, minimumGap = CLOCK_TOLERANCE + 1;

    double refresh, bestRefresh = 0.0;

    Bool found = FALSE;

    int extraFlags = 0;

    int clockIndex = -1;

    int MulFactor = 1;

    int DivFactor = 1;

    int ModePrivFlags = 0;

    ModeStatus status = MODE_NOMODE;

    Bool allowDiv2 = (strategy & LOOKUP_CLKDIV2) != 0;

    Bool haveBuiltin, haveEdid;

    strategy &= ~(LOOKUP_CLKDIV2 | LOOKUP_OPTIONAL_TOLERANCES);

    /* Some sanity checking */

    if (scrp == NULL || scrp->modePool == NULL ||

	(!scrp->progClock && scrp->numClocks == 0)) {

	ErrorF("xf86LookupMode: called with invalid scrnInfoRec\n");

	return MODE_ERROR;

    }

    if (modep == NULL || modep->name == NULL) {

	ErrorF("xf86LookupMode: called with invalid modep\n");

	return MODE_ERROR;

    }

    for (cp = clockRanges; cp != NULL; cp = cp->next) {

	/* DivFactor and MulFactor must be > 0 */

	cp->ClockDivFactor = max(1, cp->ClockDivFactor);

	cp->ClockMulFactor = max(1, cp->ClockMulFactor);

    }

    haveBuiltin = FALSE;

    haveEdid = FALSE;

    /* Scan the mode pool for matching names */

    for (p = scrp->modePool; p != NULL; p = p->next) {

	if (strcmp(p->name, modep->name) == 0) {

	    /*

	     * Requested mode is a built-in mode. Don't let the user

	     * override it.

	     * Since built-in modes always come before user specified

	     * modes it will always be found first.  

	     */

	    if (p->type & M_T_BUILTIN) {

		haveBuiltin = TRUE;

	    }

	    if (p->type & M_T_EDID) {

		haveEdid = TRUE;

	    }

	    if ((haveBuiltin && !(p->type & M_T_BUILTIN)) || 

		(haveEdid && !(p->type & M_T_EDID) && (modep->type & M_T_EDID)))

		continue;

	    /* Skip over previously rejected modes */

	    if (p->status != MODE_OK) {

		if (!found)

		    status = p->status;

		continue;

	    }

	    /* Skip over previously considered modes */

	    if (p->prev)

		continue;

	    if (p->type & (M_T_BUILTIN) ||

	 	((p->type & M_T_EDID) && (modep->type & M_T_EDID)))

		return  xf86HandleBuiltinMode(scrp, p,modep, clockRanges,

					     allowDiv2);

	    /* Check clock is in range */

	    cp = xf86FindClockRangeForMode(clockRanges, p);

	    if (cp == NULL) {

		/*

		 * XXX Could do more here to provide a more detailed

		 * reason for not finding a mode.

		 */

		p->status = MODE_CLOCK_RANGE;

		if (!found)

		    status = MODE_CLOCK_RANGE;

		continue;

	    }

	    /*

	     * If programmable clock and strategy is not LOOKUP_BEST_REFRESH,

	     * the required mode has been found, otherwise record the refresh

	     * and continue looking.

	     */

	    if (scrp->progClock) {

		found = TRUE;

		if (strategy != LOOKUP_BEST_REFRESH) {

		    bestMode = p;

		    DivFactor = cp->ClockDivFactor;

		    MulFactor = cp->ClockMulFactor;

		    ModePrivFlags = cp->PrivFlags;

		    break;

		}

		refresh = ModeVRefresh(p);

		if (p->Flags & V_INTERLACE)

		    refresh /= INTERLACE_REFRESH_WEIGHT;

		if (refresh > bestRefresh) {

		    bestMode = p;

		    DivFactor = cp->ClockDivFactor;

		    MulFactor = cp->ClockMulFactor;

		    ModePrivFlags = cp->PrivFlags;

		    bestRefresh = refresh;

		}

		continue;