2003-11-14 17:48:57 +01:00
|
|
|
/*
|
2003-11-25 20:29:01 +01:00
|
|
|
* 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.
|
2003-11-14 17:48:57 +01:00
|
|
|
*
|
2003-11-25 20:29:01 +01:00
|
|
|
* 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).
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2003-11-14 17:48:57 +01:00
|
|
|
* Authors: Dirk Hohndel <hohndel@XFree86.Org>
|
|
|
|
* David Dawes <dawes@XFree86.Org>
|
2003-11-25 20:29:01 +01:00
|
|
|
* Marc La France <tsi@XFree86.Org>
|
|
|
|
* ... and others
|
2003-11-14 17:48:57 +01:00
|
|
|
*
|
|
|
|
* This file includes helper functions for mode related things.
|
|
|
|
*/
|
|
|
|
|
2005-07-03 09:02:09 +02:00
|
|
|
#ifdef HAVE_XORG_CONFIG_H
|
|
|
|
#include <xorg-config.h>
|
|
|
|
#endif
|
|
|
|
|
2005-04-20 14:25:48 +02:00
|
|
|
#include <X11/X.h>
|
2005-07-03 10:53:54 +02:00
|
|
|
#include "os.h"
|
2003-11-14 17:48:57 +01:00
|
|
|
#include "servermd.h"
|
|
|
|
#include "mibank.h"
|
2003-11-25 20:29:01 +01:00
|
|
|
#include "globals.h"
|
2003-11-14 17:48:57 +01:00
|
|
|
#include "xf86.h"
|
|
|
|
#include "xf86Priv.h"
|
|
|
|
#include "xf86DDC.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xf86GetNearestClock --
|
|
|
|
* Find closest clock to given frequency (in kHz). This assumes the
|
|
|
|
* number of clocks is greater than zero.
|
|
|
|
*/
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT int
|
2003-11-14 17:48:57 +01:00
|
|
|
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
|
|
|
|
*/
|
|
|
|
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT const char *
|
2003-11-14 17:48:57 +01:00
|
|
|
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 of this name";
|
|
|
|
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";
|
2005-12-28 16:22:21 +01:00
|
|
|
case MODE_NO_REDUCED:
|
|
|
|
return "monitor doesn't support reduced blanking";
|
2003-11-14 17:48:57 +01:00
|
|
|
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
|
|
|
|
*/
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT void
|
2003-11-14 17:48:57 +01:00
|
|
|
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)
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2005-05-18 12:31:53 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2003-11-25 20:29:01 +01:00
|
|
|
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)
|
2005-05-18 12:31:53 +02:00
|
|
|
refresh /= (float)(mode->VScan);
|
2003-11-25 20:29:01 +01:00
|
|
|
}
|
|
|
|
return refresh;
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT ModeStatus
|
2003-11-14 17:48:57 +01:00
|
|
|
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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
/* 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 (haveBuiltin && !(p->type & M_T_BUILTIN))
|
|
|
|
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) {
|
|
|
|
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;
|
|
|
|
}
|
2003-11-25 20:29:01 +01:00
|
|
|
refresh = ModeVRefresh(p);
|
2003-11-14 17:48:57 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clock is in range, so if it is not a programmable clock, find
|
|
|
|
* a matching clock.
|
|
|
|
*/
|
|
|
|
|
|
|
|
i = xf86GetNearestClock(scrp, p->Clock, allowDiv2,
|
|
|
|
cp->ClockDivFactor, cp->ClockMulFactor, &k);
|
|
|
|
/*
|
|
|
|
* If the clock is too far from the requested clock, this
|
|
|
|
* mode is no good.
|
|
|
|
*/
|
|
|
|
if (k & V_CLKDIV2)
|
|
|
|
gap = abs((p->Clock * 2) -
|
|
|
|
((scrp->clock[i] * cp->ClockDivFactor) / cp->ClockMulFactor));
|
|
|
|
else
|
|
|
|
gap = abs(p->Clock -
|
|
|
|
((scrp->clock[i] * cp->ClockDivFactor) / cp->ClockMulFactor));
|
|
|
|
if (gap > minimumGap) {
|
|
|
|
p->status = MODE_NOCLOCK;
|
|
|
|
if (!found)
|
|
|
|
status = MODE_NOCLOCK;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
found = TRUE;
|
|
|
|
|
|
|
|
if (strategy == LOOKUP_BEST_REFRESH) {
|
2003-11-25 20:29:01 +01:00
|
|
|
refresh = ModeVRefresh(p);
|
2003-11-14 17:48:57 +01:00
|
|
|
if (p->Flags & V_INTERLACE)
|
|
|
|
refresh /= INTERLACE_REFRESH_WEIGHT;
|
|
|
|
if (refresh > bestRefresh) {
|
|
|
|
bestMode = p;
|
|
|
|
DivFactor = cp->ClockDivFactor;
|
|
|
|
MulFactor = cp->ClockMulFactor;
|
|
|
|
ModePrivFlags = cp->PrivFlags;
|
|
|
|
extraFlags = k;
|
|
|
|
clockIndex = i;
|
|
|
|
bestRefresh = refresh;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (strategy == LOOKUP_CLOSEST_CLOCK) {
|
|
|
|
if (gap < minimumGap) {
|
|
|
|
bestMode = p;
|
|
|
|
DivFactor = cp->ClockDivFactor;
|
|
|
|
MulFactor = cp->ClockMulFactor;
|
|
|
|
ModePrivFlags = cp->PrivFlags;
|
|
|
|
extraFlags = k;
|
|
|
|
clockIndex = i;
|
|
|
|
minimumGap = gap;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If strategy is neither LOOKUP_BEST_REFRESH or
|
|
|
|
* LOOKUP_CLOSEST_CLOCK the required mode has been found.
|
|
|
|
*/
|
|
|
|
bestMode = p;
|
|
|
|
DivFactor = cp->ClockDivFactor;
|
|
|
|
MulFactor = cp->ClockMulFactor;
|
|
|
|
ModePrivFlags = cp->PrivFlags;
|
|
|
|
extraFlags = k;
|
|
|
|
clockIndex = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found || bestMode == NULL)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
/* Fill in the mode parameters */
|
|
|
|
if (scrp->progClock) {
|
|
|
|
modep->Clock = bestMode->Clock;
|
|
|
|
modep->ClockIndex = -1;
|
|
|
|
modep->SynthClock = (modep->Clock * MulFactor) / DivFactor;
|
|
|
|
} else {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
modep->type = bestMode->type;
|
|
|
|
modep->PrivFlags = ModePrivFlags;
|
|
|
|
modep->HDisplay = bestMode->HDisplay;
|
|
|
|
modep->HSyncStart = bestMode->HSyncStart;
|
|
|
|
modep->HSyncEnd = bestMode->HSyncEnd;
|
|
|
|
modep->HTotal = bestMode->HTotal;
|
|
|
|
modep->HSkew = bestMode->HSkew;
|
|
|
|
modep->VDisplay = bestMode->VDisplay;
|
|
|
|
modep->VSyncStart = bestMode->VSyncStart;
|
|
|
|
modep->VSyncEnd = bestMode->VSyncEnd;
|
|
|
|
modep->VTotal = bestMode->VTotal;
|
|
|
|
modep->VScan = bestMode->VScan;
|
|
|
|
modep->Flags = bestMode->Flags | extraFlags;
|
|
|
|
modep->CrtcHDisplay = bestMode->CrtcHDisplay;
|
|
|
|
modep->CrtcHBlankStart = bestMode->CrtcHBlankStart;
|
|
|
|
modep->CrtcHSyncStart = bestMode->CrtcHSyncStart;
|
|
|
|
modep->CrtcHSyncEnd = bestMode->CrtcHSyncEnd;
|
|
|
|
modep->CrtcHBlankEnd = bestMode->CrtcHBlankEnd;
|
|
|
|
modep->CrtcHTotal = bestMode->CrtcHTotal;
|
|
|
|
modep->CrtcHSkew = bestMode->CrtcHSkew;
|
|
|
|
modep->CrtcVDisplay = bestMode->CrtcVDisplay;
|
|
|
|
modep->CrtcVBlankStart = bestMode->CrtcVBlankStart;
|
|
|
|
modep->CrtcVSyncStart = bestMode->CrtcVSyncStart;
|
|
|
|
modep->CrtcVSyncEnd = bestMode->CrtcVSyncEnd;
|
|
|
|
modep->CrtcVBlankEnd = bestMode->CrtcVBlankEnd;
|
|
|
|
modep->CrtcVTotal = bestMode->CrtcVTotal;
|
|
|
|
modep->CrtcHAdjusted = bestMode->CrtcHAdjusted;
|
|
|
|
modep->CrtcVAdjusted = bestMode->CrtcVAdjusted;
|
|
|
|
modep->HSync = bestMode->HSync;
|
|
|
|
modep->VRefresh = bestMode->VRefresh;
|
|
|
|
modep->Private = bestMode->Private;
|
|
|
|
modep->PrivSize = bestMode->PrivSize;
|
|
|
|
|
|
|
|
bestMode->prev = modep;
|
|
|
|
|
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xf86SetModeCrtc
|
|
|
|
*
|
|
|
|
* Initialises the Crtc parameters for a mode. The initialisation includes
|
|
|
|
* adjustments for interlaced and double scan modes.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
xf86SetModeCrtc(DisplayModePtr p, int adjustFlags)
|
|
|
|
{
|
|
|
|
if ((p == NULL) || ((p->type & M_T_CRTC_C) == M_T_BUILTIN))
|
|
|
|
return;
|
|
|
|
|
|
|
|
p->CrtcHDisplay = p->HDisplay;
|
|
|
|
p->CrtcHSyncStart = p->HSyncStart;
|
|
|
|
p->CrtcHSyncEnd = p->HSyncEnd;
|
|
|
|
p->CrtcHTotal = p->HTotal;
|
|
|
|
p->CrtcHSkew = p->HSkew;
|
|
|
|
p->CrtcVDisplay = p->VDisplay;
|
|
|
|
p->CrtcVSyncStart = p->VSyncStart;
|
|
|
|
p->CrtcVSyncEnd = p->VSyncEnd;
|
|
|
|
p->CrtcVTotal = p->VTotal;
|
2005-05-18 12:31:53 +02:00
|
|
|
if (p->Flags & V_INTERLACE) {
|
|
|
|
if (adjustFlags & INTERLACE_HALVE_V) {
|
|
|
|
p->CrtcVDisplay /= 2;
|
|
|
|
p->CrtcVSyncStart /= 2;
|
|
|
|
p->CrtcVSyncEnd /= 2;
|
|
|
|
p->CrtcVTotal /= 2;
|
|
|
|
}
|
|
|
|
/* Force interlaced modes to have an odd VTotal */
|
|
|
|
/* maybe we should only do this when INTERLACE_HALVE_V is set? */
|
|
|
|
p->CrtcVTotal |= 1;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
2005-05-18 12:31:53 +02:00
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
if (p->Flags & V_DBLSCAN) {
|
|
|
|
p->CrtcVDisplay *= 2;
|
|
|
|
p->CrtcVSyncStart *= 2;
|
|
|
|
p->CrtcVSyncEnd *= 2;
|
|
|
|
p->CrtcVTotal *= 2;
|
|
|
|
}
|
|
|
|
if (p->VScan > 1) {
|
|
|
|
p->CrtcVDisplay *= p->VScan;
|
|
|
|
p->CrtcVSyncStart *= p->VScan;
|
|
|
|
p->CrtcVSyncEnd *= p->VScan;
|
|
|
|
p->CrtcVTotal *= p->VScan;
|
|
|
|
}
|
|
|
|
p->CrtcHAdjusted = FALSE;
|
|
|
|
p->CrtcVAdjusted = FALSE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX
|
|
|
|
*
|
|
|
|
* The following is taken from VGA, but applies to other cores as well.
|
|
|
|
*/
|
|
|
|
p->CrtcVBlankStart = min(p->CrtcVSyncStart, p->CrtcVDisplay);
|
|
|
|
p->CrtcVBlankEnd = max(p->CrtcVSyncEnd, p->CrtcVTotal);
|
|
|
|
if ((p->CrtcVBlankEnd - p->CrtcVBlankStart) >= 127) {
|
|
|
|
/*
|
|
|
|
* V Blanking size must be < 127.
|
|
|
|
* Moving blank start forward is safer than moving blank end
|
|
|
|
* back, since monitors clamp just AFTER the sync pulse (or in
|
|
|
|
* the sync pulse), but never before.
|
|
|
|
*/
|
|
|
|
p->CrtcVBlankStart = p->CrtcVBlankEnd - 127;
|
2005-05-18 12:31:53 +02:00
|
|
|
/*
|
|
|
|
* If VBlankStart is now > VSyncStart move VBlankStart
|
|
|
|
* to VSyncStart using the maximum width that fits into
|
|
|
|
* VTotal.
|
|
|
|
*/
|
|
|
|
if (p->CrtcVBlankStart > p->CrtcVSyncStart) {
|
|
|
|
p->CrtcVBlankStart = p->CrtcVSyncStart;
|
|
|
|
p->CrtcVBlankEnd = min(p->CrtcHBlankStart + 127, p->CrtcVTotal);
|
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
p->CrtcHBlankStart = min(p->CrtcHSyncStart, p->CrtcHDisplay);
|
|
|
|
p->CrtcHBlankEnd = max(p->CrtcHSyncEnd, p->CrtcHTotal);
|
2005-05-18 12:31:53 +02:00
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
if ((p->CrtcHBlankEnd - p->CrtcHBlankStart) >= 63 * 8) {
|
|
|
|
/*
|
|
|
|
* H Blanking size must be < 63*8. Same remark as above.
|
|
|
|
*/
|
|
|
|
p->CrtcHBlankStart = p->CrtcHBlankEnd - 63 * 8;
|
2005-05-18 12:31:53 +02:00
|
|
|
if (p->CrtcHBlankStart > p->CrtcHSyncStart) {
|
|
|
|
p->CrtcHBlankStart = p->CrtcHSyncStart;
|
|
|
|
p->CrtcHBlankEnd = min(p->CrtcHBlankStart + 63 * 8, p->CrtcHTotal);
|
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xf86CheckModeForMonitor
|
|
|
|
*
|
|
|
|
* This function takes a mode and monitor description, and determines
|
|
|
|
* if the mode is valid for the monitor.
|
|
|
|
*/
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT ModeStatus
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86CheckModeForMonitor(DisplayModePtr mode, MonPtr monitor)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Sanity checks */
|
|
|
|
if (mode == NULL || monitor == NULL) {
|
|
|
|
ErrorF("xf86CheckModeForMonitor: called with invalid parameters\n");
|
|
|
|
return MODE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
ErrorF("xf86CheckModeForMonitor(%p %s, %p %s)\n",
|
|
|
|
mode, mode->name, monitor, monitor->id);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (monitor->DDC) {
|
|
|
|
xf86MonPtr DDC = (xf86MonPtr)(monitor->DDC);
|
|
|
|
struct detailed_monitor_section* detMon;
|
|
|
|
struct monitor_ranges *mon_range;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mon_range = NULL;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
detMon = &DDC->det_mon[i];
|
|
|
|
if(detMon->type == DS_RANGES) {
|
|
|
|
mon_range = &detMon->section.ranges;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (mon_range) {
|
|
|
|
/* mode->Clock in kHz, DDC in MHz */
|
|
|
|
if (mon_range->max_clock < 2550 &&
|
|
|
|
mode->Clock / 1000.0 > mon_range->max_clock) {
|
|
|
|
xf86Msg(X_WARNING,
|
|
|
|
"(%s,%s) mode clock %gMHz exceeds DDC maximum %dMHz\n",
|
|
|
|
mode->name, monitor->id,
|
|
|
|
mode->Clock/1000.0, mon_range->max_clock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Some basic mode validity checks */
|
|
|
|
if (0 >= mode->HDisplay || mode->HDisplay > mode->HSyncStart ||
|
|
|
|
mode->HSyncStart >= mode->HSyncEnd || mode->HSyncEnd >= mode->HTotal)
|
|
|
|
return MODE_H_ILLEGAL;
|
|
|
|
|
|
|
|
if (0 >= mode->VDisplay || mode->VDisplay > mode->VSyncStart ||
|
|
|
|
mode->VSyncStart >= mode->VSyncEnd || mode->VSyncEnd >= mode->VTotal)
|
|
|
|
return MODE_V_ILLEGAL;
|
|
|
|
|
|
|
|
if (monitor->nHsync > 0) {
|
|
|
|
/* Check hsync against the allowed ranges */
|
2005-05-18 12:31:53 +02:00
|
|
|
float hsync = ModeHSync(mode);
|
|
|
|
for (i = 0; i < monitor->nHsync; i++)
|
2003-11-14 17:48:57 +01:00
|
|
|
if ((hsync > monitor->hsync[i].lo * (1.0 - SYNC_TOLERANCE)) &&
|
|
|
|
(hsync < monitor->hsync[i].hi * (1.0 + SYNC_TOLERANCE)))
|
|
|
|
break;
|
2005-05-18 12:31:53 +02:00
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
/* Now see whether we ran out of sync ranges without finding a match */
|
2005-05-18 12:31:53 +02:00
|
|
|
if (i == monitor->nHsync)
|
2003-11-14 17:48:57 +01:00
|
|
|
return MODE_HSYNC;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (monitor->nVrefresh > 0) {
|
|
|
|
/* Check vrefresh against the allowed ranges */
|
2005-05-18 12:31:53 +02:00
|
|
|
float vrefrsh = ModeVRefresh(mode);
|
2003-11-14 17:48:57 +01:00
|
|
|
for (i = 0; i < monitor->nVrefresh; i++)
|
2005-05-18 12:31:53 +02:00
|
|
|
if ((vrefrsh > monitor->vrefresh[i].lo * (1.0 - SYNC_TOLERANCE)) &&
|
|
|
|
(vrefrsh < monitor->vrefresh[i].hi * (1.0 + SYNC_TOLERANCE)))
|
2003-11-14 17:48:57 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* Now see whether we ran out of refresh ranges without finding a match */
|
|
|
|
if (i == monitor->nVrefresh)
|
|
|
|
return MODE_VSYNC;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Force interlaced modes to have an odd VTotal */
|
|
|
|
if (mode->Flags & V_INTERLACE)
|
|
|
|
mode->CrtcVTotal = mode->VTotal |= 1;
|
|
|
|
|
2006-01-31 14:04:02 +01:00
|
|
|
/*
|
2006-03-07 17:00:57 +01:00
|
|
|
* This code stops cvt -r modes, and only cvt -r modes, from hitting 15y+
|
|
|
|
* old CRTs which might, when there is a lot of solar flare activity and
|
|
|
|
* when the celestial bodies are unfavourably aligned, implode trying to
|
|
|
|
* sync to it. It's called "Protecting the user from doing anything stupid".
|
|
|
|
* -- libv
|
2006-01-31 14:04:02 +01:00
|
|
|
*/
|
2006-03-07 17:00:57 +01:00
|
|
|
|
|
|
|
/* Is the horizontal blanking a bit lowish? */
|
|
|
|
if (((mode->HDisplay * 5 / 4) & ~0x07) > mode->HTotal) {
|
|
|
|
/* is this a cvt -r mode, and only a cvt -r mode? */
|
|
|
|
if (((mode->HTotal - mode->HDisplay) == 160) &&
|
|
|
|
((mode->HSyncEnd - mode->HDisplay) == 80) &&
|
|
|
|
((mode->HSyncEnd - mode->HSyncStart) == 32) &&
|
|
|
|
((mode->VSyncStart - mode->VDisplay) == 3)) {
|
|
|
|
if (!monitor->reducedblanking)
|
|
|
|
return MODE_NO_REDUCED;
|
|
|
|
}
|
|
|
|
}
|
2005-12-28 16:22:21 +01:00
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xf86CheckModeSize
|
|
|
|
*
|
|
|
|
* An internal routine to check if a mode fits in video memory. This tries to
|
|
|
|
* avoid overflows that would otherwise occur when video memory size is greater
|
|
|
|
* than 256MB.
|
|
|
|
*/
|
|
|
|
static Bool
|
|
|
|
xf86CheckModeSize(ScrnInfoPtr scrp, int w, int x, int y)
|
|
|
|
{
|
|
|
|
int bpp = scrp->fbFormat.bitsPerPixel,
|
|
|
|
pad = scrp->fbFormat.scanlinePad;
|
|
|
|
int lineWidth, lastWidth;
|
|
|
|
|
|
|
|
if (scrp->depth == 4)
|
|
|
|
pad *= 4; /* 4 planes */
|
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if ((w < 0) || (x < 0) || (y <= 0))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
lineWidth = (((w * bpp) + pad - 1) / pad) * pad;
|
|
|
|
lastWidth = x * bpp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* At this point, we need to compare
|
|
|
|
*
|
|
|
|
* (lineWidth * (y - 1)) + lastWidth
|
|
|
|
*
|
|
|
|
* against
|
|
|
|
*
|
|
|
|
* scrp->videoRam * (1024 * 8)
|
|
|
|
*
|
|
|
|
* These are bit quantities. To avoid overflows, do the comparison in
|
|
|
|
* terms of BITMAP_SCANLINE_PAD units. This assumes BITMAP_SCANLINE_PAD
|
|
|
|
* is a power of 2. We currently use 32, which limits us to a video
|
|
|
|
* memory size of 8GB.
|
|
|
|
*/
|
|
|
|
|
|
|
|
lineWidth = (lineWidth + (BITMAP_SCANLINE_PAD - 1)) / BITMAP_SCANLINE_PAD;
|
|
|
|
lastWidth = (lastWidth + (BITMAP_SCANLINE_PAD - 1)) / BITMAP_SCANLINE_PAD;
|
|
|
|
|
|
|
|
if ((lineWidth * (y - 1) + lastWidth) >
|
|
|
|
(scrp->videoRam * ((1024 * 8) / BITMAP_SCANLINE_PAD)))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xf86InitialCheckModeForDriver
|
|
|
|
*
|
|
|
|
* This function checks if a mode satisfies a driver's initial requirements:
|
|
|
|
* - mode size fits within the available pixel area (memory)
|
|
|
|
* - width lies within the range of supported line pitches
|
|
|
|
* - mode size fits within virtual size (if fixed)
|
|
|
|
* - horizontal timings are in range
|
|
|
|
*
|
|
|
|
* This function takes the following parameters:
|
|
|
|
* scrp ScrnInfoPtr
|
|
|
|
* mode mode to check
|
|
|
|
* maxPitch (optional) maximum line pitch
|
|
|
|
* virtualX (optional) virtual width requested
|
|
|
|
* virtualY (optional) virtual height requested
|
|
|
|
*
|
|
|
|
* In addition, the following fields from the ScrnInfoRec are used:
|
|
|
|
* monitor pointer to structure for monitor section
|
|
|
|
* fbFormat pixel format for the framebuffer
|
|
|
|
* videoRam video memory size (in kB)
|
|
|
|
* maxHValue maximum horizontal timing value
|
|
|
|
* maxVValue maximum vertical timing value
|
|
|
|
*/
|
|
|
|
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT ModeStatus
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86InitialCheckModeForDriver(ScrnInfoPtr scrp, DisplayModePtr mode,
|
|
|
|
ClockRangePtr clockRanges,
|
|
|
|
LookupModeFlags strategy,
|
|
|
|
int maxPitch, int virtualX, int virtualY)
|
|
|
|
{
|
|
|
|
ClockRangePtr cp;
|
|
|
|
ModeStatus status;
|
|
|
|
Bool allowDiv2 = (strategy & LOOKUP_CLKDIV2) != 0;
|
|
|
|
int i, needDiv2;
|
2005-05-18 12:31:53 +02:00
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
/* Sanity checks */
|
2003-11-25 20:29:01 +01:00
|
|
|
if (!scrp || !mode || !clockRanges) {
|
2003-11-14 17:48:57 +01:00
|
|
|
ErrorF("xf86InitialCheckModeForDriver: "
|
|
|
|
"called with invalid parameters\n");
|
|
|
|
return MODE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
ErrorF("xf86InitialCheckModeForDriver(%p, %p %s, %p, 0x%x, %d, %d, %d)\n",
|
|
|
|
scrp, mode, mode->name , clockRanges, strategy, maxPitch, virtualX, virtualY);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Some basic mode validity checks */
|
|
|
|
if (0 >= mode->HDisplay || mode->HDisplay > mode->HSyncStart ||
|
|
|
|
mode->HSyncStart >= mode->HSyncEnd || mode->HSyncEnd >= mode->HTotal)
|
|
|
|
return MODE_H_ILLEGAL;
|
|
|
|
|
|
|
|
if (0 >= mode->VDisplay || mode->VDisplay > mode->VSyncStart ||
|
|
|
|
mode->VSyncStart >= mode->VSyncEnd || mode->VSyncEnd >= mode->VTotal)
|
|
|
|
return MODE_V_ILLEGAL;
|
|
|
|
|
|
|
|
if (!xf86CheckModeSize(scrp, mode->HDisplay, mode->HDisplay,
|
|
|
|
mode->VDisplay))
|
|
|
|
return MODE_MEM;
|
|
|
|
|
|
|
|
if (maxPitch > 0 && mode->HDisplay > maxPitch)
|
|
|
|
return MODE_BAD_WIDTH;
|
|
|
|
|
|
|
|
if (virtualX > 0 && mode->HDisplay > virtualX)
|
|
|
|
return MODE_VIRTUAL_X;
|
|
|
|
|
|
|
|
if (virtualY > 0 && mode->VDisplay > virtualY)
|
|
|
|
return MODE_VIRTUAL_Y;
|
|
|
|
|
|
|
|
if (scrp->maxHValue > 0 && mode->HTotal > scrp->maxHValue)
|
|
|
|
return MODE_BAD_HVALUE;
|
|
|
|
|
|
|
|
if (scrp->maxVValue > 0 && mode->VTotal > scrp->maxVValue)
|
|
|
|
return MODE_BAD_VVALUE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The use of the DisplayModeRec's Crtc* and SynthClock elements below is
|
|
|
|
* provisional, in that they are later reused by the driver at mode-set
|
|
|
|
* time. Here, they are temporarily enlisted to contain the mode timings
|
|
|
|
* as seen by the CRT or panel (rather than the CRTC). The driver's
|
|
|
|
* ValidMode() is allowed to modify these so it can deal with such things
|
|
|
|
* as mode stretching and/or centering. The driver should >NOT< modify the
|
|
|
|
* user-supplied values as these are reported back when mode validation is
|
|
|
|
* said and done.
|
|
|
|
*/
|
|
|
|
/*
|
2005-05-18 12:31:53 +02:00
|
|
|
* NOTE: We (ab)use the mode->Crtc* values here to store timing
|
|
|
|
* information for the calculation of Hsync and Vrefresh. Before
|
|
|
|
* these values are calculated the driver is given the opportunity
|
|
|
|
* to either set these HSync and VRefresh itself or modify the timing
|
|
|
|
* values.
|
|
|
|
* The difference to the final calculation is small but imortand:
|
|
|
|
* here we pass the flag INTERLACE_HALVE_V regardless if the driver
|
|
|
|
* sets it or not. This way our calculation of VRefresh has the same
|
|
|
|
* effect as if we do if (flags & V_INTERLACE) refresh *= 2.0
|
|
|
|
* This dual use of the mode->Crtc* values will certainly create
|
|
|
|
* confusion and is bad software design. However since it's part of
|
|
|
|
* the driver API it's hard to change.
|
2003-11-14 17:48:57 +01:00
|
|
|
*/
|
2005-05-18 12:31:53 +02:00
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
if (scrp->ValidMode) {
|
2005-05-18 12:31:53 +02:00
|
|
|
|
|
|
|
xf86SetModeCrtc(mode, INTERLACE_HALVE_V);
|
|
|
|
|
|
|
|
cp = xf86FindClockRangeForMode(clockRanges, mode);
|
|
|
|
if (!cp)
|
|
|
|
return MODE_CLOCK_RANGE;
|
|
|
|
|
|
|
|
if (cp->ClockMulFactor < 1)
|
|
|
|
cp->ClockMulFactor = 1;
|
|
|
|
if (cp->ClockDivFactor < 1)
|
|
|
|
cp->ClockDivFactor = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX The effect of clock dividers and multipliers on the monitor's
|
|
|
|
* pixel clock needs to be verified.
|
|
|
|
*/
|
|
|
|
if (scrp->progClock) {
|
|
|
|
mode->SynthClock = mode->Clock;
|
|
|
|
} else {
|
|
|
|
i = xf86GetNearestClock(scrp, mode->Clock, allowDiv2,
|
|
|
|
cp->ClockDivFactor, cp->ClockMulFactor,
|
|
|
|
&needDiv2);
|
|
|
|
mode->SynthClock = (scrp->clock[i] * cp->ClockDivFactor) /
|
|
|
|
cp->ClockMulFactor;
|
|
|
|
if (needDiv2 & V_CLKDIV2)
|
|
|
|
mode->SynthClock /= 2;
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
status = (*scrp->ValidMode)(scrp->scrnIndex, mode, FALSE,
|
|
|
|
MODECHECK_INITIAL);
|
|
|
|
if (status != MODE_OK)
|
|
|
|
return status;
|
|
|
|
|
2005-05-18 12:31:53 +02:00
|
|
|
if (mode->HSync <= 0.0)
|
|
|
|
mode->HSync = (float)mode->SynthClock / (float)mode->CrtcHTotal;
|
|
|
|
if (mode->VRefresh <= 0.0)
|
|
|
|
mode->VRefresh = (mode->SynthClock * 1000.0)
|
|
|
|
/ (mode->CrtcHTotal * mode->CrtcVTotal);
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
2005-05-18 12:31:53 +02:00
|
|
|
|
|
|
|
mode->HSync = ModeHSync(mode);
|
|
|
|
mode->VRefresh = ModeVRefresh(mode);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
/* Assume it is OK */
|
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xf86CheckModeForDriver
|
|
|
|
*
|
|
|
|
* This function is for checking modes while the server is running (for
|
|
|
|
* use mainly by the VidMode extension).
|
|
|
|
*
|
|
|
|
* This function checks if a mode satisfies a driver's requirements:
|
|
|
|
* - width lies within the line pitch
|
|
|
|
* - mode size fits within virtual size
|
|
|
|
* - horizontal/vertical timings are in range
|
|
|
|
*
|
|
|
|
* This function takes the following parameters:
|
|
|
|
* scrp ScrnInfoPtr
|
|
|
|
* mode mode to check
|
|
|
|
* flags not (currently) used
|
|
|
|
*
|
|
|
|
* In addition, the following fields from the ScrnInfoRec are used:
|
|
|
|
* maxHValue maximum horizontal timing value
|
|
|
|
* maxVValue maximum vertical timing value
|
|
|
|
* virtualX virtual width
|
|
|
|
* virtualY virtual height
|
|
|
|
* clockRanges allowable clock ranges
|
|
|
|
*/
|
|
|
|
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT ModeStatus
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86CheckModeForDriver(ScrnInfoPtr scrp, DisplayModePtr mode, int flags)
|
|
|
|
{
|
|
|
|
ClockRangesPtr cp;
|
|
|
|
int i, k, gap, minimumGap = CLOCK_TOLERANCE + 1;
|
|
|
|
int extraFlags = 0;
|
|
|
|
int clockIndex = -1;
|
|
|
|
int MulFactor = 1;
|
|
|
|
int DivFactor = 1;
|
|
|
|
int ModePrivFlags = 0;
|
|
|
|
Bool allowDiv2;
|
|
|
|
ModeStatus status = MODE_NOMODE;
|
|
|
|
|
|
|
|
/* Some sanity checking */
|
|
|
|
if (scrp == NULL || (!scrp->progClock && scrp->numClocks == 0)) {
|
|
|
|
ErrorF("xf86CheckModeForDriver: called with invalid scrnInfoRec\n");
|
|
|
|
return MODE_ERROR;
|
|
|
|
}
|
|
|
|
if (mode == NULL) {
|
|
|
|
ErrorF("xf86CheckModeForDriver: called with invalid modep\n");
|
|
|
|
return MODE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check the mode size */
|
|
|
|
if (mode->HDisplay > scrp->virtualX)
|
|
|
|
return MODE_VIRTUAL_X;
|
|
|
|
|
|
|
|
if (mode->VDisplay > scrp->virtualY)
|
|
|
|
return MODE_VIRTUAL_Y;
|
|
|
|
|
|
|
|
if (scrp->maxHValue > 0 && mode->HTotal > scrp->maxHValue)
|
|
|
|
return MODE_BAD_HVALUE;
|
|
|
|
|
|
|
|
if (scrp->maxVValue > 0 && mode->VTotal > scrp->maxVValue)
|
|
|
|
return MODE_BAD_VVALUE;
|
|
|
|
|
|
|
|
for (cp = scrp->clockRanges; cp != NULL; cp = cp->next) {
|
|
|
|
/* DivFactor and MulFactor must be > 0 */
|
|
|
|
cp->ClockDivFactor = max(1, cp->ClockDivFactor);
|
|
|
|
cp->ClockMulFactor = max(1, cp->ClockMulFactor);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (scrp->progClock) {
|
|
|
|
/* Check clock is in range */
|
|
|
|
for (cp = scrp->clockRanges; cp != NULL; cp = cp->next) {
|
|
|
|
if ((cp->minClock <= mode->Clock) &&
|
|
|
|
(cp->maxClock >= mode->Clock) &&
|
|
|
|
(cp->interlaceAllowed || !(mode->Flags & V_INTERLACE)) &&
|
|
|
|
(cp->doubleScanAllowed ||
|
|
|
|
((!(mode->Flags & V_DBLSCAN)) && (mode->VScan <= 1))))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (cp == NULL) {
|
|
|
|
return MODE_CLOCK_RANGE;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If programmable clock the required mode has been found
|
|
|
|
*/
|
|
|
|
DivFactor = cp->ClockDivFactor;
|
|
|
|
MulFactor = cp->ClockMulFactor;
|
|
|
|
ModePrivFlags = cp->PrivFlags;
|
|
|
|
} else {
|
|
|
|
status = MODE_CLOCK_RANGE;
|
|
|
|
/* Check clock is in range */
|
|
|
|
for (cp = scrp->clockRanges; cp != NULL; cp = cp->next) {
|
|
|
|
if ((cp->minClock <= mode->Clock) &&
|
|
|
|
(cp->maxClock >= mode->Clock) &&
|
|
|
|
(cp->interlaceAllowed || !(mode->Flags & V_INTERLACE)) &&
|
|
|
|
(cp->doubleScanAllowed ||
|
|
|
|
((!(mode->Flags & V_DBLSCAN)) && (mode->VScan <= 1)))) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clock is in range, so if it is not a programmable clock,
|
|
|
|
* find a matching clock.
|
|
|
|
*/
|
|
|
|
|
|
|
|
allowDiv2 = (cp->strategy & LOOKUP_CLKDIV2) != 0;
|
|
|
|
i = xf86GetNearestClock(scrp, mode->Clock, allowDiv2,
|
|
|
|
cp->ClockDivFactor, cp->ClockMulFactor, &k);
|
|
|
|
/*
|
|
|
|
* If the clock is too far from the requested clock, this
|
|
|
|
* mode is no good.
|
|
|
|
*/
|
|
|
|
if (k & V_CLKDIV2)
|
|
|
|
gap = abs((mode->Clock * 2) -
|
|
|
|
((scrp->clock[i] * cp->ClockDivFactor) /
|
|
|
|
cp->ClockMulFactor));
|
|
|
|
else
|
|
|
|
gap = abs(mode->Clock -
|
|
|
|
((scrp->clock[i] * cp->ClockDivFactor) /
|
|
|
|
cp->ClockMulFactor));
|
|
|
|
if (gap > minimumGap) {
|
|
|
|
status = MODE_NOCLOCK;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
DivFactor = cp->ClockDivFactor;
|
|
|
|
MulFactor = cp->ClockMulFactor;
|
|
|
|
ModePrivFlags = cp->PrivFlags;
|
|
|
|
extraFlags = k;
|
|
|
|
clockIndex = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (cp == NULL)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill in the mode parameters */
|
|
|
|
if (scrp->progClock) {
|
|
|
|
mode->ClockIndex = -1;
|
|
|
|
mode->SynthClock = (mode->Clock * MulFactor) / DivFactor;
|
|
|
|
} else {
|
|
|
|
mode->Clock = (scrp->clock[clockIndex] * DivFactor) / MulFactor;
|
|
|
|
mode->ClockIndex = clockIndex;
|
|
|
|
mode->SynthClock = scrp->clock[clockIndex];
|
|
|
|
if (extraFlags & V_CLKDIV2) {
|
|
|
|
mode->Clock /= 2;
|
|
|
|
mode->SynthClock /= 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mode->PrivFlags = ModePrivFlags;
|
|
|
|
|
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xf86ValidateModes
|
|
|
|
*
|
|
|
|
* This function takes a set of mode names, modes and limiting conditions,
|
|
|
|
* and selects a set of modes and parameters based on those conditions.
|
|
|
|
*
|
|
|
|
* This function takes the following parameters:
|
|
|
|
* scrp ScrnInfoPtr
|
|
|
|
* availModes the list of modes available for the monitor
|
|
|
|
* modeNames (optional) list of mode names that the screen is requesting
|
|
|
|
* clockRanges a list of clock ranges
|
|
|
|
* linePitches (optional) a list of line pitches
|
|
|
|
* minPitch (optional) minimum line pitch (in pixels)
|
|
|
|
* maxPitch (optional) maximum line pitch (in pixels)
|
|
|
|
* pitchInc (mandatory) pitch increment (in bits)
|
|
|
|
* minHeight (optional) minimum virtual height (in pixels)
|
|
|
|
* maxHeight (optional) maximum virtual height (in pixels)
|
|
|
|
* virtualX (optional) virtual width requested (in pixels)
|
|
|
|
* virtualY (optional) virtual height requested (in pixels)
|
|
|
|
* apertureSize size of video aperture (in bytes)
|
|
|
|
* 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:
|
|
|
|
* clocks a list of discrete clocks
|
|
|
|
* numClocks number of discrete clocks
|
|
|
|
* progClock clock is programmable
|
|
|
|
* monitor pointer to structure for monitor section
|
|
|
|
* fbFormat format of the framebuffer
|
|
|
|
* videoRam video memory size
|
|
|
|
* maxHValue maximum horizontal timing value
|
|
|
|
* maxVValue maximum vertical timing value
|
|
|
|
* xInc horizontal timing increment (defaults to 8 pixels)
|
|
|
|
*
|
|
|
|
* The function fills in the following ScrnInfoRec fields:
|
|
|
|
* modePool A subset of the modes available to the monitor which
|
|
|
|
* are compatible with the driver.
|
|
|
|
* modes one mode entry for each of the requested modes, with the
|
|
|
|
* status field filled in to indicate if the mode has been
|
|
|
|
* accepted or not.
|
|
|
|
* virtualX the resulting virtual width
|
|
|
|
* virtualY the resulting virtual height
|
|
|
|
* displayWidth the resulting line pitch
|
|
|
|
*
|
|
|
|
* The function's return value is the number of matching modes found, or -1
|
|
|
|
* if an unrecoverable error was encountered.
|
|
|
|
*/
|
|
|
|
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT int
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
|
|
|
|
char **modeNames, ClockRangePtr clockRanges,
|
|
|
|
int *linePitches, int minPitch, int maxPitch, int pitchInc,
|
|
|
|
int minHeight, int maxHeight, int virtualX, int virtualY,
|
|
|
|
int apertureSize, LookupModeFlags strategy)
|
|
|
|
{
|
|
|
|
DisplayModePtr p, q, r, new, last, *endp;
|
|
|
|
int i, numModes = 0;
|
|
|
|
ModeStatus status;
|
|
|
|
int linePitch = -1, virtX = 0, virtY = 0;
|
|
|
|
int newLinePitch, newVirtX, newVirtY;
|
|
|
|
int modeSize; /* in pixels */
|
2003-11-25 20:29:01 +01:00
|
|
|
Bool validateAllDefaultModes = FALSE;
|
2003-11-14 17:48:57 +01:00
|
|
|
Bool userModes = FALSE;
|
|
|
|
int saveType;
|
|
|
|
PixmapFormatRec *BankFormat;
|
|
|
|
ClockRangePtr cp;
|
|
|
|
ClockRangesPtr storeClockRanges;
|
|
|
|
struct monitor_ranges *mon_range = NULL;
|
2003-11-25 20:29:01 +01:00
|
|
|
double targetRefresh = 0.0;
|
|
|
|
int numTimings = 0;
|
|
|
|
range hsync[MAX_HSYNC];
|
|
|
|
range vrefresh[MAX_VREFRESH];
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
ErrorF("xf86ValidateModes(%p, %p, %p, %p,\n\t\t %p, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x)\n",
|
|
|
|
scrp, availModes, modeNames, clockRanges,
|
|
|
|
linePitches, minPitch, maxPitch, pitchInc,
|
|
|
|
minHeight, maxHeight, virtualX, virtualY,
|
|
|
|
apertureSize, strategy
|
|
|
|
);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Some sanity checking */
|
|
|
|
if (scrp == NULL || scrp->name == NULL || !scrp->monitor ||
|
|
|
|
(!scrp->progClock && scrp->numClocks == 0)) {
|
|
|
|
ErrorF("xf86ValidateModes: called with invalid scrnInfoRec\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (linePitches != NULL && linePitches[0] <= 0) {
|
|
|
|
ErrorF("xf86ValidateModes: called with invalid linePitches\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (pitchInc <= 0) {
|
|
|
|
ErrorF("xf86ValidateModes: called with invalid pitchInc\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if ((virtualX > 0) != (virtualY > 0)) {
|
|
|
|
ErrorF("xf86ValidateModes: called with invalid virtual resolution\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2003-11-25 20:29:01 +01:00
|
|
|
/*
|
|
|
|
* Probe monitor so that we can enforce/warn about its limits.
|
|
|
|
* If one or more DS_RANGES descriptions are present, use the parameters
|
|
|
|
* that they provide. Otherwise, deduce limits based on the modes that
|
|
|
|
* are shown as supported via standard and detailed timings.
|
|
|
|
*
|
|
|
|
* XXX The full potential of the DDC/EDID data still isn't being tapped.
|
|
|
|
*/
|
2003-11-14 17:48:57 +01:00
|
|
|
if (scrp->monitor->DDC) {
|
|
|
|
MonPtr monitor = scrp->monitor;
|
|
|
|
xf86MonPtr DDC = (xf86MonPtr)(scrp->monitor->DDC);
|
2003-11-25 20:29:01 +01:00
|
|
|
int i, j;
|
|
|
|
float hmin = 1e6, hmax = 0.0, vmin = 1e6, vmax = 0.0;
|
|
|
|
float h;
|
|
|
|
struct std_timings *t;
|
|
|
|
struct detailed_timings *dt;
|
|
|
|
|
|
|
|
numTimings = 0;
|
|
|
|
for (i = 0; i < DET_TIMINGS; i++) {
|
|
|
|
switch (DDC->det_mon[i].type) {
|
|
|
|
case DS_RANGES:
|
|
|
|
mon_range = &DDC->det_mon[i].section.ranges;
|
|
|
|
hsync[numTimings].lo = mon_range->min_h;
|
|
|
|
hsync[numTimings].hi = mon_range->max_h;
|
|
|
|
vrefresh[numTimings].lo = mon_range->min_v;
|
|
|
|
vrefresh[numTimings].hi = mon_range->max_v;
|
|
|
|
numTimings++;
|
|
|
|
break;
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2003-11-25 20:29:01 +01:00
|
|
|
case DS_STD_TIMINGS:
|
|
|
|
t = DDC->det_mon[i].section.std_t;
|
|
|
|
for (j = 0; j < 5; j++) {
|
|
|
|
if (t[j].hsize > 256) { /* sanity check */
|
|
|
|
if (t[j].refresh < vmin)
|
|
|
|
vmin = t[i].refresh;
|
|
|
|
if (t[j].refresh > vmax)
|
|
|
|
vmax = t[i].refresh;
|
|
|
|
/*
|
|
|
|
* For typical modes this is a reasonable estimate
|
|
|
|
* of the horizontal sync rate.
|
|
|
|
*/
|
|
|
|
h = t[j].refresh * 1.07 * t[j].vsize / 1000.0;
|
|
|
|
if (h < hmin)
|
|
|
|
hmin = h;
|
|
|
|
if (h > hmax)
|
|
|
|
hmax = h;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DT:
|
|
|
|
dt = &DDC->det_mon[i].section.d_timings;
|
|
|
|
if (dt->clock > 15000000) { /* sanity check */
|
|
|
|
float v;
|
|
|
|
h = (float)dt->clock / (dt->h_active + dt->h_blanking);
|
|
|
|
v = h / (dt->v_active + dt->v_blanking);
|
|
|
|
h /= 1000.0;
|
|
|
|
if (dt->interlaced)
|
|
|
|
v /= 2.0;
|
|
|
|
|
|
|
|
if (v < vmin)
|
|
|
|
vmin = v;
|
|
|
|
if (v > vmax)
|
|
|
|
vmax = v;
|
|
|
|
if (h < hmin)
|
|
|
|
hmin = h;
|
|
|
|
if (h > hmax)
|
|
|
|
hmax = h;
|
|
|
|
}
|
|
|
|
break;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
2003-11-25 20:29:01 +01:00
|
|
|
|
|
|
|
if (numTimings > MAX_HSYNC)
|
|
|
|
break;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
2003-11-25 20:29:01 +01:00
|
|
|
|
|
|
|
if (numTimings == 0) {
|
|
|
|
t = DDC->timings2;
|
|
|
|
for (i = 0; i < STD_TIMINGS; i++) {
|
|
|
|
if (t[i].hsize > 256) { /* sanity check */
|
|
|
|
if (t[i].refresh < vmin)
|
|
|
|
vmin = t[i].refresh;
|
|
|
|
if (t[i].refresh > vmax)
|
|
|
|
vmax = t[i].refresh;
|
|
|
|
/*
|
|
|
|
* For typical modes this is a reasonable estimate
|
|
|
|
* of the horizontal sync rate.
|
|
|
|
*/
|
|
|
|
h = t[i].refresh * 1.07 * t[i].vsize / 1000.0;
|
|
|
|
if (h < hmin)
|
|
|
|
hmin = h;
|
|
|
|
if (h > hmax)
|
|
|
|
hmax = h;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hmax > 0.0) {
|
|
|
|
hsync[numTimings].lo = hmin;
|
|
|
|
hsync[numTimings].hi = hmax;
|
|
|
|
vrefresh[numTimings].lo = vmin;
|
|
|
|
vrefresh[numTimings].hi = vmax;
|
|
|
|
numTimings++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (numTimings > 0) {
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
2003-11-25 20:29:01 +01:00
|
|
|
for (i = 0; i < numTimings; i++) {
|
|
|
|
ErrorF("DDC - Hsync %.1f-%.1f kHz - Vrefresh %.1f-%.1f Hz\n",
|
|
|
|
hsync[i].lo, hsync[i].hi,
|
|
|
|
vrefresh[i].lo, vrefresh[i].hi);
|
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#define DDC_SYNC_TOLERANCE SYNC_TOLERANCE
|
|
|
|
if (monitor->nHsync > 0) {
|
|
|
|
for (i = 0; i < monitor->nHsync; i++) {
|
2003-11-25 20:29:01 +01:00
|
|
|
Bool good = FALSE;
|
|
|
|
for (j = 0; j < numTimings; j++) {
|
|
|
|
if ((1.0 - DDC_SYNC_TOLERANCE) * hsync[j].lo <=
|
|
|
|
monitor->hsync[i].lo &&
|
|
|
|
(1.0 + DDC_SYNC_TOLERANCE) * hsync[j].hi >=
|
2003-11-14 17:48:57 +01:00
|
|
|
monitor->hsync[i].hi) {
|
2003-11-25 20:29:01 +01:00
|
|
|
good = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!good) {
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_WARNING,
|
|
|
|
"config file hsync range %g-%gkHz not within DDC "
|
2003-11-25 20:29:01 +01:00
|
|
|
"hsync ranges.\n",
|
|
|
|
monitor->hsync[i].lo, monitor->hsync[i].hi);
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (monitor->nVrefresh > 0) {
|
2003-11-25 20:29:01 +01:00
|
|
|
for (i = 0; i < monitor->nVrefresh; i++) {
|
|
|
|
Bool good = FALSE;
|
|
|
|
for (j = 0; j < numTimings; j++) {
|
|
|
|
if ((1.0 - DDC_SYNC_TOLERANCE) * vrefresh[j].lo <=
|
|
|
|
monitor->vrefresh[0].lo &&
|
|
|
|
(1.0 + DDC_SYNC_TOLERANCE) * vrefresh[j].hi >=
|
2003-11-14 17:48:57 +01:00
|
|
|
monitor->vrefresh[0].hi) {
|
2003-11-25 20:29:01 +01:00
|
|
|
good = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!good) {
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_WARNING,
|
|
|
|
"config file vrefresh range %g-%gHz not within DDC "
|
2003-11-25 20:29:01 +01:00
|
|
|
"vrefresh ranges.\n",
|
|
|
|
monitor->vrefresh[i].lo, monitor->vrefresh[i].hi);
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2003-11-25 20:29:01 +01:00
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If requested by the driver, allow missing hsync and/or vrefresh ranges
|
|
|
|
* in the monitor section.
|
|
|
|
*/
|
|
|
|
if (strategy & LOOKUP_OPTIONAL_TOLERANCES) {
|
|
|
|
strategy &= ~LOOKUP_OPTIONAL_TOLERANCES;
|
|
|
|
} else {
|
2003-11-25 20:29:01 +01:00
|
|
|
const char *type = "";
|
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
if (scrp->monitor->nHsync <= 0) {
|
2003-11-25 20:29:01 +01:00
|
|
|
if (numTimings > 0) {
|
|
|
|
scrp->monitor->nHsync = numTimings;
|
|
|
|
for (i = 0; i < numTimings; i++) {
|
|
|
|
scrp->monitor->hsync[i].lo = hsync[i].lo;
|
|
|
|
scrp->monitor->hsync[i].hi = hsync[i].hi;
|
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
} else {
|
|
|
|
scrp->monitor->hsync[0].lo = 28;
|
|
|
|
scrp->monitor->hsync[0].hi = 33;
|
2003-11-25 20:29:01 +01:00
|
|
|
scrp->monitor->nHsync = 1;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
2003-11-25 20:29:01 +01:00
|
|
|
type = "default ";
|
|
|
|
}
|
|
|
|
for (i = 0; i < scrp->monitor->nHsync; i++) {
|
2003-11-14 17:48:57 +01:00
|
|
|
if (scrp->monitor->hsync[i].lo == scrp->monitor->hsync[i].hi)
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
2003-11-25 20:29:01 +01:00
|
|
|
"%s: Using %shsync value of %.2f kHz\n",
|
|
|
|
scrp->monitor->id, type,
|
2003-11-14 17:48:57 +01:00
|
|
|
scrp->monitor->hsync[i].lo);
|
|
|
|
else
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
2003-11-25 20:29:01 +01:00
|
|
|
"%s: Using %shsync range of %.2f-%.2f kHz\n",
|
|
|
|
scrp->monitor->id, type,
|
2003-11-14 17:48:57 +01:00
|
|
|
scrp->monitor->hsync[i].lo,
|
|
|
|
scrp->monitor->hsync[i].hi);
|
|
|
|
}
|
2003-11-25 20:29:01 +01:00
|
|
|
|
|
|
|
type = "";
|
2003-11-14 17:48:57 +01:00
|
|
|
if (scrp->monitor->nVrefresh <= 0) {
|
2003-11-25 20:29:01 +01:00
|
|
|
if (numTimings > 0) {
|
|
|
|
scrp->monitor->nVrefresh = numTimings;
|
|
|
|
for (i = 0; i < numTimings; i++) {
|
|
|
|
scrp->monitor->vrefresh[i].lo = vrefresh[i].lo;
|
|
|
|
scrp->monitor->vrefresh[i].hi = vrefresh[i].hi;
|
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
} else {
|
|
|
|
scrp->monitor->vrefresh[0].lo = 43;
|
|
|
|
scrp->monitor->vrefresh[0].hi = 72;
|
2003-11-25 20:29:01 +01:00
|
|
|
scrp->monitor->nVrefresh = 1;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
2003-11-25 20:29:01 +01:00
|
|
|
type = "default ";
|
|
|
|
}
|
|
|
|
for (i = 0; i < scrp->monitor->nVrefresh; i++) {
|
2003-11-14 17:48:57 +01:00
|
|
|
if (scrp->monitor->vrefresh[i].lo == scrp->monitor->vrefresh[i].hi)
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
2003-11-25 20:29:01 +01:00
|
|
|
"%s: Using %svrefresh value of %.2f Hz\n",
|
|
|
|
scrp->monitor->id, type,
|
2003-11-14 17:48:57 +01:00
|
|
|
scrp->monitor->vrefresh[i].lo);
|
|
|
|
else
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
2003-11-25 20:29:01 +01:00
|
|
|
"%s: Using %svrefresh range of %.2f-%.2f Hz\n",
|
|
|
|
scrp->monitor->id, type,
|
2003-11-14 17:48:57 +01:00
|
|
|
scrp->monitor->vrefresh[i].lo,
|
|
|
|
scrp->monitor->vrefresh[i].hi);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Store the clockRanges for later use by the VidMode extension. Must
|
|
|
|
* also store the strategy, since ClockDiv2 flag is stored there.
|
|
|
|
*/
|
|
|
|
storeClockRanges = scrp->clockRanges;
|
|
|
|
while (storeClockRanges != NULL) {
|
|
|
|
storeClockRanges = storeClockRanges->next;
|
|
|
|
}
|
|
|
|
for (cp = clockRanges; cp != NULL; cp = cp->next,
|
|
|
|
storeClockRanges = storeClockRanges->next) {
|
|
|
|
storeClockRanges = xnfalloc(sizeof(ClockRanges));
|
|
|
|
if (scrp->clockRanges == NULL)
|
|
|
|
scrp->clockRanges = storeClockRanges;
|
|
|
|
memcpy(storeClockRanges, cp, sizeof(ClockRange));
|
|
|
|
storeClockRanges->strategy = strategy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Determine which pixmap format to pass to miScanLineWidth() */
|
|
|
|
if (scrp->depth > 4)
|
|
|
|
BankFormat = &scrp->fbFormat;
|
|
|
|
else
|
|
|
|
BankFormat = xf86GetPixFormat(scrp, 1); /* >not< scrp->depth! */
|
|
|
|
|
|
|
|
if (scrp->xInc <= 0)
|
|
|
|
scrp->xInc = 8; /* Suitable for VGA and others */
|
|
|
|
|
|
|
|
#define _VIRTUALX(x) ((((x) + scrp->xInc - 1) / scrp->xInc) * scrp->xInc)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine maxPitch if it wasn't given explicitly. Note linePitches
|
|
|
|
* always takes precedence if is non-NULL. In that case the minPitch and
|
|
|
|
* maxPitch values passed are ignored.
|
|
|
|
*/
|
|
|
|
if (linePitches) {
|
|
|
|
minPitch = maxPitch = linePitches[0];
|
|
|
|
for (i = 1; linePitches[i] > 0; i++) {
|
|
|
|
if (linePitches[i] > maxPitch)
|
|
|
|
maxPitch = linePitches[i];
|
|
|
|
if (linePitches[i] < minPitch)
|
|
|
|
minPitch = linePitches[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initial check of virtual size against other constraints */
|
|
|
|
scrp->virtualFrom = X_PROBED;
|
|
|
|
/*
|
|
|
|
* Initialise virtX and virtY if the values are fixed.
|
|
|
|
*/
|
|
|
|
if (virtualY > 0) {
|
|
|
|
if (maxHeight > 0 && virtualY > maxHeight) {
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
|
|
|
|
"Virtual height (%d) is too large for the hardware "
|
|
|
|
"(max %d)\n", virtualY, maxHeight);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (minHeight > 0 && virtualY < minHeight) {
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
|
|
|
|
"Virtual height (%d) is too small for the hardware "
|
|
|
|
"(min %d)\n", virtualY, minHeight);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtualX = _VIRTUALX(virtualX);
|
|
|
|
if (linePitches != NULL) {
|
|
|
|
for (i = 0; linePitches[i] != 0; i++) {
|
|
|
|
if ((linePitches[i] >= virtualX) &&
|
|
|
|
(linePitches[i] ==
|
|
|
|
miScanLineWidth(virtualX, virtualY, linePitches[i],
|
|
|
|
apertureSize, BankFormat, pitchInc))) {
|
|
|
|
linePitch = linePitches[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
linePitch = miScanLineWidth(virtualX, virtualY, minPitch,
|
|
|
|
apertureSize, BankFormat, pitchInc);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((linePitch < minPitch) || (linePitch > maxPitch)) {
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
|
|
|
|
"Virtual width (%d) is too large for the hardware "
|
|
|
|
"(max %d)\n", virtualX, maxPitch);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!xf86CheckModeSize(scrp, linePitch, virtualX, virtualY)) {
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
|
|
|
|
"Virtual size (%dx%d) (pitch %d) exceeds video memory\n",
|
|
|
|
virtualX, virtualY, linePitch);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtX = virtualX;
|
|
|
|
virtY = virtualY;
|
|
|
|
scrp->virtualFrom = X_CONFIG;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print clock ranges and scaled clocks */
|
|
|
|
xf86ShowClockRanges(scrp, clockRanges);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If scrp->modePool hasn't been setup yet, set it up now. This allows the
|
|
|
|
* modes that the driver definitely can't use to be weeded out early. Note
|
|
|
|
* that a modePool mode's prev field is used to hold a pointer to the
|
|
|
|
* member of the scrp->modes list for which a match was considered.
|
|
|
|
*/
|
|
|
|
if (scrp->modePool == NULL) {
|
|
|
|
q = NULL;
|
|
|
|
for (p = availModes; p != NULL; p = p->next) {
|
|
|
|
status = xf86InitialCheckModeForDriver(scrp, p, clockRanges,
|
|
|
|
strategy, maxPitch,
|
|
|
|
virtualX, virtualY);
|
|
|
|
|
2005-05-18 12:31:53 +02:00
|
|
|
if (status == MODE_OK) {
|
2003-11-14 17:48:57 +01:00
|
|
|
status = xf86CheckModeForMonitor(p, scrp->monitor);
|
2005-05-18 12:31:53 +02:00
|
|
|
}
|
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
if (status == MODE_OK) {
|
|
|
|
new = xnfalloc(sizeof(DisplayModeRec));
|
|
|
|
*new = *p;
|
|
|
|
new->next = NULL;
|
|
|
|
if (!q) {
|
|
|
|
scrp->modePool = new;
|
|
|
|
} else {
|
|
|
|
q->next = new;
|
|
|
|
}
|
|
|
|
new->prev = NULL;
|
|
|
|
q = new;
|
|
|
|
q->name = xnfstrdup(p->name);
|
|
|
|
q->status = MODE_OK;
|
|
|
|
} else {
|
|
|
|
if (p->type & M_T_BUILTIN)
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using built-in mode \"%s\" (%s)\n",
|
|
|
|
p->name, xf86ModeStatusToString(status));
|
|
|
|
else if (p->type & M_T_DEFAULT)
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using default mode \"%s\" (%s)\n", p->name,
|
|
|
|
xf86ModeStatusToString(status));
|
|
|
|
else
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using mode \"%s\" (%s)\n", p->name,
|
|
|
|
xf86ModeStatusToString(status));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (scrp->modePool == NULL) {
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_WARNING, "Mode pool is empty\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (p = scrp->modePool; p != NULL; p = p->next) {
|
|
|
|
p->prev = NULL;
|
|
|
|
p->status = MODE_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-11-25 20:29:01 +01:00
|
|
|
/*
|
|
|
|
* Go through the mode pool and see if any modes match the target
|
|
|
|
* refresh rate, (if specified). If no modes match, abandon the target.
|
|
|
|
*/
|
|
|
|
targetRefresh = xf86SetRealOption(scrp->options,
|
|
|
|
"TargetRefresh", 0.0);
|
|
|
|
if (targetRefresh > 0.0) {
|
|
|
|
for (p = scrp->modePool; p != NULL; p = p->next) {
|
|
|
|
if (ModeVRefresh(p) > targetRefresh * (1.0 - SYNC_TOLERANCE))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!p)
|
|
|
|
targetRefresh = 0.0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (targetRefresh > 0.0) {
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_CONFIG,
|
|
|
|
"Target refresh rate is %.1f Hz\n", targetRefresh);
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
/*
|
|
|
|
* Allocate one entry in scrp->modes for each named mode.
|
|
|
|
*/
|
|
|
|
while (scrp->modes)
|
|
|
|
xf86DeleteMode(&scrp->modes, scrp->modes);
|
|
|
|
endp = &scrp->modes;
|
|
|
|
last = NULL;
|
|
|
|
if (modeNames != NULL) {
|
|
|
|
for (i = 0; modeNames[i] != NULL; i++) {
|
|
|
|
userModes = TRUE;
|
|
|
|
new = xnfcalloc(1, sizeof(DisplayModeRec));
|
|
|
|
new->prev = last;
|
|
|
|
new->type = M_T_USERDEF;
|
|
|
|
new->name = xnfalloc(strlen(modeNames[i]) + 1);
|
|
|
|
strcpy(new->name, modeNames[i]);
|
|
|
|
if (new->prev)
|
|
|
|
new->prev->next = new;
|
|
|
|
*endp = last = new;
|
|
|
|
endp = &new->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Lookup each mode */
|
2003-11-25 20:29:01 +01:00
|
|
|
#ifdef RANDR
|
|
|
|
if (!xf86Info.disableRandR
|
|
|
|
#ifdef PANORAMIX
|
|
|
|
&& noPanoramiXExtension
|
|
|
|
#endif
|
|
|
|
)
|
|
|
|
validateAllDefaultModes = TRUE;
|
|
|
|
#endif
|
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
for (p = scrp->modes; ; p = p->next) {
|
|
|
|
Bool repeat;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the supplied mode names don't produce a valid mode, scan through
|
|
|
|
* unconsidered modePool members until one survives validation. This
|
|
|
|
* is done in decreasing order by mode pixel area.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (p == NULL) {
|
|
|
|
if ((numModes > 0) && !validateAllDefaultModes)
|
|
|
|
break;
|
|
|
|
|
|
|
|
validateAllDefaultModes = TRUE;
|
|
|
|
r = NULL;
|
|
|
|
modeSize = 0;
|
|
|
|
for (q = scrp->modePool; q != NULL; q = q->next) {
|
|
|
|
if ((q->prev == NULL) && (q->status == MODE_OK)) {
|
|
|
|
/*
|
|
|
|
* Deal with the case where this mode wasn't considered
|
|
|
|
* because of a builtin mode of the same name.
|
|
|
|
*/
|
|
|
|
for (p = scrp->modes; p != NULL; p = p->next) {
|
|
|
|
if ((p->status != MODE_OK) &&
|
|
|
|
!strcmp(p->name, q->name))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p != NULL)
|
|
|
|
q->prev = p;
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* A quick check to not allow default modes with
|
|
|
|
* horizontal timing parameters that CRTs may have
|
|
|
|
* problems with.
|
|
|
|
*/
|
|
|
|
if ((q->type & M_T_DEFAULT) &&
|
|
|
|
((double)q->HTotal / (double)q->HDisplay) < 1.15)
|
|
|
|
continue;
|
|
|
|
|
2003-11-25 20:29:01 +01:00
|
|
|
/*
|
|
|
|
* If there is a target refresh rate, skip modes that
|
|
|
|
* don't match up.
|
|
|
|
*/
|
|
|
|
if (ModeVRefresh(q) <
|
|
|
|
(1.0 - SYNC_TOLERANCE) * targetRefresh)
|
|
|
|
continue;
|
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
if (modeSize < (q->HDisplay * q->VDisplay)) {
|
|
|
|
r = q;
|
|
|
|
modeSize = q->HDisplay * q->VDisplay;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r == NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
p = xnfcalloc(1, sizeof(DisplayModeRec));
|
|
|
|
p->prev = last;
|
|
|
|
p->name = xnfalloc(strlen(r->name) + 1);
|
|
|
|
if (!userModes)
|
|
|
|
p->type = M_T_USERDEF;
|
|
|
|
strcpy(p->name, r->name);
|
|
|
|
if (p->prev)
|
|
|
|
p->prev->next = p;
|
|
|
|
*endp = last = p;
|
|
|
|
endp = &p->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
repeat = FALSE;
|
|
|
|
lookupNext:
|
|
|
|
if (repeat && ((status = p->status) != MODE_OK)) {
|
|
|
|
if (p->type & M_T_BUILTIN)
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using built-in mode \"%s\" (%s)\n",
|
|
|
|
p->name, xf86ModeStatusToString(status));
|
|
|
|
else if (p->type & M_T_DEFAULT)
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using default mode \"%s\" (%s)\n", p->name,
|
|
|
|
xf86ModeStatusToString(status));
|
|
|
|
else
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using mode \"%s\" (%s)\n", p->name,
|
|
|
|
xf86ModeStatusToString(status));
|
|
|
|
}
|
|
|
|
saveType = p->type;
|
|
|
|
status = xf86LookupMode(scrp, p, clockRanges, strategy);
|
|
|
|
if (repeat && status == MODE_NOMODE) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (status != MODE_OK) {
|
|
|
|
if (p->type & M_T_BUILTIN)
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using built-in mode \"%s\" (%s)\n",
|
|
|
|
p->name, xf86ModeStatusToString(status));
|
|
|
|
else if (p->type & M_T_DEFAULT)
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using default mode \"%s\" (%s)\n", p->name,
|
|
|
|
xf86ModeStatusToString(status));
|
|
|
|
else
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using mode \"%s\" (%s)\n", p->name,
|
|
|
|
xf86ModeStatusToString(status));
|
|
|
|
}
|
|
|
|
if (status == MODE_ERROR) {
|
|
|
|
ErrorF("xf86ValidateModes: "
|
|
|
|
"unexpected result from xf86LookupMode()\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (status != MODE_OK) {
|
|
|
|
if (p->status == MODE_OK)
|
|
|
|
p->status = status;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
p->type |= saveType;
|
|
|
|
repeat = TRUE;
|
|
|
|
|
|
|
|
newLinePitch = linePitch;
|
|
|
|
newVirtX = virtX;
|
|
|
|
newVirtY = virtY;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't let non-user defined modes increase the virtual size
|
|
|
|
*/
|
|
|
|
if (!(p->type & M_T_USERDEF) && (numModes > 0)) {
|
|
|
|
if (p->HDisplay > virtX) {
|
|
|
|
p->status = MODE_VIRTUAL_X;
|
|
|
|
goto lookupNext;
|
|
|
|
}
|
|
|
|
if (p->VDisplay > virtY) {
|
|
|
|
p->status = MODE_VIRTUAL_Y;
|
|
|
|
goto lookupNext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Adjust virtual width and height if the mode is too large for the
|
|
|
|
* current values and if they are not fixed.
|
|
|
|
*/
|
|
|
|
if (virtualX <= 0 && p->HDisplay > newVirtX)
|
|
|
|
newVirtX = _VIRTUALX(p->HDisplay);
|
|
|
|
if (virtualY <= 0 && p->VDisplay > newVirtY) {
|
|
|
|
if (maxHeight > 0 && p->VDisplay > maxHeight) {
|
|
|
|
p->status = MODE_VIRTUAL_Y; /* ? */
|
|
|
|
goto lookupNext;
|
|
|
|
}
|
|
|
|
newVirtY = p->VDisplay;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If virtual resolution is to be increased, revalidate it.
|
|
|
|
*/
|
|
|
|
if ((virtX != newVirtX) || (virtY != newVirtY)) {
|
|
|
|
if (linePitches != NULL) {
|
|
|
|
newLinePitch = -1;
|
|
|
|
for (i = 0; linePitches[i] != 0; i++) {
|
|
|
|
if ((linePitches[i] >= newVirtX) &&
|
|
|
|
(linePitches[i] >= linePitch) &&
|
|
|
|
(linePitches[i] ==
|
|
|
|
miScanLineWidth(newVirtX, newVirtY, linePitches[i],
|
|
|
|
apertureSize, BankFormat, pitchInc))) {
|
|
|
|
newLinePitch = linePitches[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (linePitch < minPitch)
|
|
|
|
linePitch = minPitch;
|
|
|
|
newLinePitch = miScanLineWidth(newVirtX, newVirtY, linePitch,
|
|
|
|
apertureSize, BankFormat,
|
|
|
|
pitchInc);
|
|
|
|
}
|
|
|
|
if ((newLinePitch < minPitch) || (newLinePitch > maxPitch)) {
|
|
|
|
p->status = MODE_BAD_WIDTH;
|
|
|
|
goto lookupNext;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check that the pixel area required by the new virtual height
|
|
|
|
* and line pitch isn't too large.
|
|
|
|
*/
|
|
|
|
if (!xf86CheckModeSize(scrp, newLinePitch, newVirtX, newVirtY)) {
|
|
|
|
p->status = MODE_MEM_VIRT;
|
|
|
|
goto lookupNext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (scrp->ValidMode) {
|
|
|
|
/*
|
|
|
|
* Give the driver a final say, passing it the proposed virtual
|
|
|
|
* geometry.
|
|
|
|
*/
|
|
|
|
scrp->virtualX = newVirtX;
|
|
|
|
scrp->virtualY = newVirtY;
|
|
|
|
scrp->displayWidth = newLinePitch;
|
|
|
|
p->status = (scrp->ValidMode)(scrp->scrnIndex, p, FALSE,
|
|
|
|
MODECHECK_FINAL);
|
|
|
|
|
|
|
|
if (p->status != MODE_OK) {
|
|
|
|
goto lookupNext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mode has passed all the tests */
|
|
|
|
virtX = newVirtX;
|
|
|
|
virtY = newVirtY;
|
|
|
|
linePitch = newLinePitch;
|
|
|
|
p->status = MODE_OK;
|
|
|
|
numModes++;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef _VIRTUALX
|
|
|
|
|
|
|
|
/* Update the ScrnInfoRec parameters */
|
|
|
|
|
|
|
|
scrp->virtualX = virtX;
|
|
|
|
scrp->virtualY = virtY;
|
|
|
|
scrp->displayWidth = linePitch;
|
|
|
|
|
|
|
|
if (numModes <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Make the mode list into a circular list by joining up the ends */
|
|
|
|
p = scrp->modes;
|
|
|
|
while (p->next != NULL)
|
|
|
|
p = p->next;
|
|
|
|
/* p is now the last mode on the list */
|
|
|
|
p->next = scrp->modes;
|
|
|
|
scrp->modes->prev = p;
|
|
|
|
|
|
|
|
if (minHeight > 0 && virtY < minHeight) {
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
|
|
|
|
"Virtual height (%d) is too small for the hardware "
|
|
|
|
"(min %d)\n", virtY, minHeight);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return numModes;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xf86DeleteMode
|
|
|
|
*
|
|
|
|
* This function removes a mode from a list of modes.
|
|
|
|
*
|
|
|
|
* There are different types of mode lists:
|
|
|
|
*
|
|
|
|
* - singly linked linear lists, ending in NULL
|
|
|
|
* - doubly linked linear lists, starting and ending in NULL
|
|
|
|
* - doubly linked circular lists
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT void
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86DeleteMode(DisplayModePtr *modeList, DisplayModePtr mode)
|
|
|
|
{
|
|
|
|
/* Catch the easy/insane cases */
|
|
|
|
if (modeList == NULL || *modeList == NULL || mode == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* If the mode is at the start of the list, move the start of the list */
|
|
|
|
if (*modeList == mode)
|
|
|
|
*modeList = mode->next;
|
|
|
|
|
|
|
|
/* If mode is the only one on the list, set the list to NULL */
|
|
|
|
if ((mode == mode->prev) && (mode == mode->next)) {
|
|
|
|
*modeList = NULL;
|
|
|
|
} else {
|
|
|
|
if ((mode->prev != NULL) && (mode->prev->next == mode))
|
|
|
|
mode->prev->next = mode->next;
|
|
|
|
if ((mode->next != NULL) && (mode->next->prev == mode))
|
|
|
|
mode->next->prev = mode->prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
xfree(mode->name);
|
|
|
|
xfree(mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xf86PruneDriverModes
|
|
|
|
*
|
|
|
|
* Remove modes from the driver's mode list which have been marked as
|
|
|
|
* invalid.
|
|
|
|
*/
|
|
|
|
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT void
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86PruneDriverModes(ScrnInfoPtr scrp)
|
|
|
|
{
|
|
|
|
DisplayModePtr first, p, n;
|
|
|
|
|
|
|
|
p = scrp->modes;
|
|
|
|
if (p == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (!(first = scrp->modes))
|
|
|
|
return;
|
|
|
|
n = p->next;
|
|
|
|
if (p->status != MODE_OK) {
|
|
|
|
#if 0
|
|
|
|
if (p->type & M_T_BUILTIN)
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using built-in mode \"%s\" (%s)\n", p->name,
|
|
|
|
xf86ModeStatusToString(p->status));
|
|
|
|
else if (p->type & M_T_DEFAULT)
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using default mode \"%s\" (%s)\n", p->name,
|
|
|
|
xf86ModeStatusToString(p->status));
|
|
|
|
else
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
|
|
|
"Not using mode \"%s\" (%s)\n", p->name,
|
|
|
|
xf86ModeStatusToString(p->status));
|
|
|
|
#endif
|
|
|
|
xf86DeleteMode(&(scrp->modes), p);
|
|
|
|
}
|
|
|
|
p = n;
|
|
|
|
} while (p != NULL && p != first);
|
|
|
|
|
|
|
|
/* modePool is no longer needed, turf it */
|
2003-11-25 20:29:01 +01:00
|
|
|
while (scrp->modePool) {
|
|
|
|
/*
|
|
|
|
* A modePool mode's prev field is used to hold a pointer to the
|
|
|
|
* member of the scrp->modes list for which a match was considered.
|
|
|
|
* Clear that pointer first, otherwise xf86DeleteMode might get
|
|
|
|
* confused
|
|
|
|
*/
|
|
|
|
scrp->modePool->prev = NULL;
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86DeleteMode(&scrp->modePool, scrp->modePool);
|
2003-11-25 20:29:01 +01:00
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xf86SetCrtcForModes
|
|
|
|
*
|
|
|
|
* Goes through the screen's mode list, and initialises the Crtc
|
|
|
|
* parameters for each mode. The initialisation includes adjustments
|
|
|
|
* for interlaced and double scan modes.
|
|
|
|
*/
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT void
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86SetCrtcForModes(ScrnInfoPtr scrp, int adjustFlags)
|
|
|
|
{
|
|
|
|
DisplayModePtr p;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Store adjustFlags for use with the VidMode extension. There is an
|
|
|
|
* implicit assumption here that SetCrtcForModes is called once.
|
|
|
|
*/
|
|
|
|
scrp->adjustFlags = adjustFlags;
|
|
|
|
|
|
|
|
p = scrp->modes;
|
|
|
|
if (p == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
do {
|
|
|
|
xf86SetModeCrtc(p, adjustFlags);
|
|
|
|
#ifdef DEBUG
|
|
|
|
ErrorF("%sMode %s: %d (%d) %d %d (%d) %d %d (%d) %d %d (%d) %d\n",
|
|
|
|
(p->type & M_T_DEFAULT) ? "Default " : "",
|
|
|
|
p->name, p->CrtcHDisplay, p->CrtcHBlankStart,
|
|
|
|
p->CrtcHSyncStart, p->CrtcHSyncEnd, p->CrtcHBlankEnd,
|
|
|
|
p->CrtcHTotal, p->CrtcVDisplay, p->CrtcVBlankStart,
|
|
|
|
p->CrtcVSyncStart, p->CrtcVSyncEnd, p->CrtcVBlankEnd,
|
|
|
|
p->CrtcVTotal);
|
|
|
|
#endif
|
|
|
|
p = p->next;
|
|
|
|
} while (p != NULL && p != scrp->modes);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
add(char **p, char *new)
|
|
|
|
{
|
|
|
|
*p = xnfrealloc(*p, strlen(*p) + strlen(new) + 2);
|
|
|
|
strcat(*p, " ");
|
|
|
|
strcat(*p, new);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
PrintModeline(int scrnIndex,DisplayModePtr mode)
|
|
|
|
{
|
|
|
|
char tmp[256];
|
|
|
|
char *flags = xnfcalloc(1, 1);
|
|
|
|
|
|
|
|
if (mode->HSkew) {
|
|
|
|
snprintf(tmp, 256, "hskew %i", mode->HSkew);
|
|
|
|
add(&flags, tmp);
|
|
|
|
}
|
|
|
|
if (mode->VScan) {
|
|
|
|
snprintf(tmp, 256, "vscan %i", mode->VScan);
|
|
|
|
add(&flags, tmp);
|
|
|
|
}
|
|
|
|
if (mode->Flags & V_INTERLACE) add(&flags, "interlace");
|
|
|
|
if (mode->Flags & V_CSYNC) add(&flags, "composite");
|
|
|
|
if (mode->Flags & V_DBLSCAN) add(&flags, "doublescan");
|
|
|
|
if (mode->Flags & V_BCAST) add(&flags, "bcast");
|
|
|
|
if (mode->Flags & V_PHSYNC) add(&flags, "+hsync");
|
|
|
|
if (mode->Flags & V_NHSYNC) add(&flags, "-hsync");
|
|
|
|
if (mode->Flags & V_PVSYNC) add(&flags, "+vsync");
|
|
|
|
if (mode->Flags & V_NVSYNC) add(&flags, "-vsync");
|
|
|
|
if (mode->Flags & V_PCSYNC) add(&flags, "+csync");
|
|
|
|
if (mode->Flags & V_NCSYNC) add(&flags, "-csync");
|
|
|
|
#if 0
|
|
|
|
if (mode->Flags & V_CLKDIV2) add(&flags, "vclk/2");
|
|
|
|
#endif
|
|
|
|
xf86DrvMsgVerb(scrnIndex, X_INFO, 3,
|
|
|
|
"Modeline \"%s\" %6.2f %i %i %i %i %i %i %i %i%s\n",
|
|
|
|
mode->name, mode->Clock/1000., mode->HDisplay,
|
|
|
|
mode->HSyncStart, mode->HSyncEnd, mode->HTotal,
|
|
|
|
mode->VDisplay, mode->VSyncStart, mode->VSyncEnd,
|
|
|
|
mode->VTotal, flags);
|
|
|
|
xfree(flags);
|
|
|
|
}
|
|
|
|
|
2006-03-25 20:52:05 +01:00
|
|
|
_X_EXPORT void
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86PrintModes(ScrnInfoPtr scrp)
|
|
|
|
{
|
|
|
|
DisplayModePtr p;
|
|
|
|
float hsync, refresh = 0;
|
|
|
|
char *desc, *desc2, *prefix, *uprefix;
|
|
|
|
|
|
|
|
if (scrp == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, scrp->virtualFrom, "Virtual size is %dx%d "
|
|
|
|
"(pitch %d)\n", scrp->virtualX, scrp->virtualY,
|
|
|
|
scrp->displayWidth);
|
|
|
|
|
|
|
|
p = scrp->modes;
|
|
|
|
if (p == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
do {
|
|
|
|
desc = desc2 = "";
|
2005-05-18 12:31:53 +02:00
|
|
|
hsync = ModeHSync(p);
|
2003-11-25 20:29:01 +01:00
|
|
|
refresh = ModeVRefresh(p);
|
2003-11-14 17:48:57 +01:00
|
|
|
if (p->Flags & V_INTERLACE) {
|
|
|
|
desc = " (I)";
|
|
|
|
}
|
|
|
|
if (p->Flags & V_DBLSCAN) {
|
|
|
|
desc = " (D)";
|
|
|
|
}
|
|
|
|
if (p->VScan > 1) {
|
|
|
|
desc2 = " (VScan)";
|
|
|
|
}
|
|
|
|
if (p->type & M_T_BUILTIN)
|
|
|
|
prefix = "Built-in mode";
|
|
|
|
else if (p->type & M_T_DEFAULT)
|
|
|
|
prefix = "Default mode";
|
|
|
|
else
|
|
|
|
prefix = "Mode";
|
|
|
|
if (p->type & M_T_USERDEF)
|
|
|
|
uprefix = "*";
|
|
|
|
else
|
|
|
|
uprefix = " ";
|
|
|
|
if (hsync == 0 || refresh == 0) {
|
|
|
|
if (p->name)
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_CONFIG,
|
|
|
|
"%s%s \"%s\"\n", uprefix, prefix, p->name);
|
|
|
|
else
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_PROBED,
|
|
|
|
"%s%s %dx%d (unnamed)\n",
|
|
|
|
uprefix, prefix, p->HDisplay, p->VDisplay);
|
|
|
|
} else if (p->Clock == p->SynthClock) {
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_CONFIG,
|
|
|
|
"%s%s \"%s\": %.1f MHz, %.1f kHz, %.1f Hz%s%s\n",
|
|
|
|
uprefix, prefix, p->name, p->Clock / 1000.0,
|
|
|
|
hsync, refresh, desc, desc2);
|
|
|
|
} else {
|
|
|
|
xf86DrvMsg(scrp->scrnIndex, X_CONFIG,
|
|
|
|
"%s%s \"%s\": %.1f MHz (scaled from %.1f MHz), "
|
|
|
|
"%.1f kHz, %.1f Hz%s%s\n",
|
|
|
|
uprefix, prefix, p->name, p->Clock / 1000.0,
|
|
|
|
p->SynthClock / 1000.0, hsync, refresh, desc, desc2);
|
|
|
|
}
|
|
|
|
if (hsync != 0 && refresh != 0)
|
|
|
|
PrintModeline(scrp->scrnIndex,p);
|
|
|
|
p = p->next;
|
|
|
|
} while (p != NULL && p != scrp->modes);
|
|
|
|
}
|