frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
xserver/hw/xfree86/common/xf86Mode.c

2106 lines
71 KiB
C
Raw Blame History

/*
* 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).
*/
/*
* LCM() and scanLineWidth() are:
*
* Copyright 1997 through 2004 by Marc Aurele La France (TSI @ UQV), tsi@xfree86.org
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that copyright
* notice and this permission notice appear in supporting documentation, and
* that the name of Marc Aurele La France not be used in advertising or
* publicity pertaining to distribution of the software without specific,
* written prior permission. Marc Aurele La France makes no representations
* about the suitability of this software for any purpose. It is provided
* "as-is" without express or implied warranty.
*
* MARC AURELE LA FRANCE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
* EVENT SHALL MARC AURELE LA FRANCE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*
* Copyright 1990,91,92,93 by Thomas Roell, Germany.
* Copyright 1991,92,93 by SGCS (Snitily Graphics Consulting Services), USA.
*
* Permission to use, copy, modify, distribute, and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation, and that the name of Thomas Roell nor
* SGCS be used in advertising or publicity pertaining to distribution
* of the software without specific, written prior permission.
* Thomas Roell nor SGCS makes no representations about the suitability
* of this software for any purpose. It is provided "as is" without
* express or implied warranty.
*
* THOMAS ROELL AND SGCS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL THOMAS ROELL OR SGCS BE LIABLE FOR ANY
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Authors: Dirk Hohndel <hohndel@XFree86.Org>
* David Dawes <dawes@XFree86.Org>
* Marc La France <tsi@XFree86.Org>
* ... 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 "xf86Modes.h"
#include "xf86Crtc.h"
#include "os.h"
#include "servermd.h"
#include "globals.h"
#include "xf86.h"
#include "xf86Priv.h"
#include "edid.h"
static void
printModeRejectMessage(int index, DisplayModePtr p, int status)
{
const char *type;
if (p->type & M_T_BUILTIN)
type = "built-in ";
else if (p->type & M_T_DEFAULT)
type = "default ";
else if (p->type & M_T_DRIVER)
type = "driver ";
else
type = "";
xf86DrvMsg(index, X_INFO, "Not using %smode \"%s\" (%s)\n", type, p->name,
xf86ModeStatusToString(status));
}
/*
* Find closest clock to given frequency (in kHz). This assumes the
* number of clocks is greater than zero.
*/
static 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 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";
case MODE_NO_REDUCED:
return "monitor doesn't support reduced blanking";
case MODE_BANDWIDTH:
return "mode requires too much memory bandwidth";
case MODE_DUPLICATE:
return "the same mode has been added";
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");
}
}
}
static Bool
modeInClockRange(ClockRangePtr cp, DisplayModePtr p)
{
return ((p->Clock >= cp->minClock) &&
(p->Clock <= cp->maxClock) &&
(cp->interlaceAllowed || !(p->Flags & V_INTERLACE)) &&
(cp->doubleScanAllowed ||
((p->VScan <= 1) && !(p->Flags & V_DBLSCAN))));
}
/*
* xf86FindClockRangeForMode() [... like the name says ...]
*/
static ClockRangePtr
xf86FindClockRangeForMode(ClockRangePtr clockRanges, DisplayModePtr p)
{
ClockRangePtr cp;
for (cp = clockRanges;; cp = cp->next)
if (!cp || modeInClockRange(cp, p))
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;
}
/*
* 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.
*/
static 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;
int n;
const int types[] = {
M_T_BUILTIN | M_T_PREFERRED,
M_T_BUILTIN,
M_T_USERDEF | M_T_PREFERRED,
M_T_USERDEF,
M_T_DRIVER | M_T_PREFERRED,
M_T_DRIVER,
0
};
const int ntypes = ARRAY_SIZE(types);
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);
}
/* Scan the mode pool for matching names */
for (n = 0; n < ntypes; n++) {
int type = types[n];
for (p = scrp->modePool; p != NULL; p = p->next) {
/* scan through the modes in the sort order above */
if ((p->type & type) != type)
continue;
if (p->name == NULL)
continue;
if (strcmp(p->name, modep->name) == 0) {
/* 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;
}
refresh = xf86ModeVRefresh(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;
}
/*
* 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) {
refresh = xf86ModeVRefresh(p);
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)
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;
}
/*
* xf86CheckModeForMonitor
*
* This function takes a mode and monitor description, and determines
* if the mode is valid for the monitor.
*/
ModeStatus
xf86CheckModeForMonitor(DisplayModePtr mode, MonPtr monitor)
{
int i;
/* Sanity checks */
if (mode == NULL || monitor == NULL) {
ErrorF("xf86CheckModeForMonitor: called with invalid parameters\n");
return MODE_ERROR;
}
DebugF("xf86CheckModeForMonitor(%p %s, %p %s)\n",
mode, mode->name, monitor, monitor->id);
/* 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 */
float hsync = xf86ModeHSync(mode);
for (i = 0; i < monitor->nHsync; i++)
if ((hsync > monitor->hsync[i].lo * (1.0 - SYNC_TOLERANCE)) &&
(hsync < monitor->hsync[i].hi * (1.0 + SYNC_TOLERANCE)))
break;
/* Now see whether we ran out of sync ranges without finding a match */
if (i == monitor->nHsync)
return MODE_HSYNC;
}
if (monitor->nVrefresh > 0) {
/* Check vrefresh against the allowed ranges */
float vrefrsh = xf86ModeVRefresh(mode);
for (i = 0; i < monitor->nVrefresh; i++)
if ((vrefrsh > monitor->vrefresh[i].lo * (1.0 - SYNC_TOLERANCE)) &&
(vrefrsh < monitor->vrefresh[i].hi * (1.0 + SYNC_TOLERANCE)))
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;
/*
* 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
*/
if (xf86ModeIsReduced(mode)) {
if (!monitor->reducedblanking && !(mode->type & M_T_DRIVER))
return MODE_NO_REDUCED;
}
if ((monitor->maxPixClock) && (mode->Clock > monitor->maxPixClock))
return MODE_CLOCK_HIGH;
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)
*/
static ModeStatus
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;
/* Sanity checks */
if (!scrp || !mode || !clockRanges) {
ErrorF("xf86InitialCheckModeForDriver: "
"called with invalid parameters\n");
return MODE_ERROR;
}
DebugF("xf86InitialCheckModeForDriver(%p, %p %s, %p, 0x%x, %d, %d, %d)\n",
scrp, mode, mode->name, clockRanges, strategy, maxPitch, virtualX,
virtualY);
/* 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;
/*
* 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.
*/
/*
* 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.
*/
if (scrp->ValidMode) {
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;
}
status = (*scrp->ValidMode) (scrp, mode, FALSE,
MODECHECK_INITIAL);
if (status != MODE_OK)
return status;
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);
}
mode->HSync = xf86ModeHSync(mode);
mode->VRefresh = xf86ModeVRefresh(mode);
/* 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:
* virtualX virtual width
* virtualY virtual height
* clockRanges allowable clock ranges
*/
ModeStatus
xf86CheckModeForDriver(ScrnInfoPtr scrp, DisplayModePtr mode, int flags)
{
ClockRangePtr cp;
int i, k, gap, minimumGap = CLOCK_TOLERANCE + 1;
int extraFlags = 0;
int clockIndex = -1;
int MulFactor = 1;
int DivFactor = 1;
int ModePrivFlags = 0;
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;
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 (modeInClockRange(cp, mode))
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 (modeInClockRange(cp, mode)) {
/*
* Clock is in range, so if it is not a programmable clock,
* find a matching clock.
*/
i = xf86GetNearestClock(scrp, mode->Clock, 0,
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;
}
static int
inferVirtualSize(ScrnInfoPtr scrp, DisplayModePtr modes, int *vx, int *vy)
{
float aspect = 0.0;
MonPtr mon = scrp->monitor;
xf86MonPtr DDC;
int x = 0, y = 0;
DisplayModePtr mode;
if (!mon)
return 0;
DDC = mon->DDC;
if (DDC && DDC->ver.revision >= 4) {
/* For 1.4, we might actually get native pixel format. How novel. */
if (PREFERRED_TIMING_MODE(DDC->features.msc)) {
for (mode = modes; mode; mode = mode->next) {
if (mode->type & (M_T_DRIVER | M_T_PREFERRED)) {
x = mode->HDisplay;
y = mode->VDisplay;
goto found;
}
}
}
/*
* Even if we don't, we might get aspect ratio from extra CVT info
* or from the monitor size fields. TODO.
*/
}
/*
* Technically this triggers if either is zero. That wasn't legal
* before EDID 1.4, but right now we'll get that wrong. TODO.
*/
if (!aspect) {
if (!mon->widthmm || !mon->heightmm)
aspect = 4.0 / 3.0;
else
aspect = (float) mon->widthmm / (float) mon->heightmm;
}
/* find the largest M_T_DRIVER mode with that aspect ratio */
for (mode = modes; mode; mode = mode->next) {
float mode_aspect, metaspect;
if (!(mode->type & (M_T_DRIVER | M_T_USERDEF)))
continue;
mode_aspect = (float) mode->HDisplay / (float) mode->VDisplay;
metaspect = aspect / mode_aspect;
/* 5% slop or so, since we only get size in centimeters */
if (fabs(1.0 - metaspect) < 0.05) {
if ((mode->HDisplay > x) && (mode->VDisplay > y)) {
x = mode->HDisplay;
y = mode->VDisplay;
}
}
}
if (!x || !y) {
xf86DrvMsg(scrp->scrnIndex, X_WARNING,
"Unable to estimate virtual size\n");
return 0;
}
found:
*vx = x;
*vy = y;
xf86DrvMsg(scrp->scrnIndex, X_INFO,
"Estimated virtual size for aspect ratio %.4f is %dx%d\n",
aspect, *vx, *vy);
return 1;
}
/* Least common multiple */
static unsigned int
LCM(unsigned int x, unsigned int y)
{
unsigned int m = x, n = y, o;
while ((o = m % n)) {
m = n;
n = o;
}
return (x / n) * y;
}
/*
* Given various screen attributes, determine the minimum scanline width such
* that each scanline is server and DDX padded and any pixels with embedded
* bank boundaries are off-screen. This function returns -1 if such a width
* cannot exist.
*/
static int
scanLineWidth(unsigned int xsize, /* pixels */
unsigned int ysize, /* pixels */
unsigned int width, /* pixels */
unsigned long BankSize, /* char's */
PixmapFormatRec * pBankFormat, unsigned int nWidthUnit /* bits */
)
{
unsigned long nBitsPerBank, nBitsPerScanline, nBitsPerScanlinePadUnit;
unsigned long minBitsPerScanline, maxBitsPerScanline;
/* Sanity checks */
if (!nWidthUnit || !pBankFormat)
return -1;
nBitsPerBank = BankSize * 8;
if (nBitsPerBank % pBankFormat->scanlinePad)
return -1;
if (xsize > width)
width = xsize;
nBitsPerScanlinePadUnit = LCM(pBankFormat->scanlinePad, nWidthUnit);
nBitsPerScanline =
(((width * pBankFormat->bitsPerPixel) + nBitsPerScanlinePadUnit - 1) /
nBitsPerScanlinePadUnit) * nBitsPerScanlinePadUnit;
width = nBitsPerScanline / pBankFormat->bitsPerPixel;
if (!xsize || !(nBitsPerBank % pBankFormat->bitsPerPixel))
return (int) width;
/*
* Scanlines will be server-pad aligned at this point. They will also be
* a multiple of nWidthUnit bits long. Ensure that pixels with embedded
* bank boundaries are off-screen.
*
* It seems reasonable to limit total frame buffer size to 1/16 of the
* theoretical maximum address space size. On a machine with 32-bit
* addresses (to 8-bit quantities) this turns out to be 256MB. Not only
* does this provide a simple limiting condition for the loops below, but
* it also prevents unsigned long wraparounds.
*/
if (!ysize)
return -1;
minBitsPerScanline = xsize * pBankFormat->bitsPerPixel;
if (minBitsPerScanline > nBitsPerBank)
return -1;
if (ysize == 1)
return (int) width;
maxBitsPerScanline =
(((unsigned long) (-1) >> 1) - minBitsPerScanline) / (ysize - 1);
while (nBitsPerScanline <= maxBitsPerScanline) {
unsigned long BankBase, BankUnit;
BankUnit = ((nBitsPerBank + nBitsPerScanline - 1) / nBitsPerBank) *
nBitsPerBank;
if (!(BankUnit % nBitsPerScanline))
return (int) width;
for (BankBase = BankUnit;; BankBase += nBitsPerBank) {
unsigned long x, y;
y = BankBase / nBitsPerScanline;
if (y >= ysize)
return (int) width;
x = BankBase % nBitsPerScanline;
if (!(x % pBankFormat->bitsPerPixel))
continue;
if (x < minBitsPerScanline) {
/*
* Skip ahead certain widths by dividing the excess scanline
* amongst the y's.
*/
y *= nBitsPerScanlinePadUnit;
nBitsPerScanline += ((x + y - 1) / y) * nBitsPerScanlinePadUnit;
width = nBitsPerScanline / pBankFormat->bitsPerPixel;
break;
}
if (BankBase != BankUnit)
continue;
if (!(nBitsPerScanline % x))
return (int) width;
BankBase = ((nBitsPerScanline - minBitsPerScanline) /
(nBitsPerScanline - x)) * BankUnit;
}
}
return -1;
}
/*
* 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
* 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.
*/
int
xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
const 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 */
Bool validateAllDefaultModes = FALSE;
Bool userModes = FALSE;
int saveType;
PixmapFormatRec *BankFormat;
ClockRangePtr cp;
Bool inferred_virtual = FALSE;
DebugF
("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);
/* 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;
}
/*
* 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 {
const char *type = "";
Bool specified = FALSE;
if (scrp->monitor->nHsync <= 0) {
scrp->monitor->hsync[0].lo = 31.5;
scrp->monitor->hsync[0].hi = 48.0;
scrp->monitor->nHsync = 1;
type = "default ";
}
else {
specified = TRUE;
}
for (i = 0; i < scrp->monitor->nHsync; i++) {
if (scrp->monitor->hsync[i].lo == scrp->monitor->hsync[i].hi)
xf86DrvMsg(scrp->scrnIndex, X_INFO,
"%s: Using %shsync value of %.2f kHz\n",
scrp->monitor->id, type, scrp->monitor->hsync[i].lo);
else
xf86DrvMsg(scrp->scrnIndex, X_INFO,
"%s: Using %shsync range of %.2f-%.2f kHz\n",
scrp->monitor->id, type,
scrp->monitor->hsync[i].lo,
scrp->monitor->hsync[i].hi);
}
type = "";
if (scrp->monitor->nVrefresh <= 0) {
scrp->monitor->vrefresh[0].lo = 50;
scrp->monitor->vrefresh[0].hi = 70;
scrp->monitor->nVrefresh = 1;
type = "default ";
}
else {
specified = TRUE;
}
for (i = 0; i < scrp->monitor->nVrefresh; i++) {
if (scrp->monitor->vrefresh[i].lo == scrp->monitor->vrefresh[i].hi)
xf86DrvMsg(scrp->scrnIndex, X_INFO,
"%s: Using %svrefresh value of %.2f Hz\n",
scrp->monitor->id, type,
scrp->monitor->vrefresh[i].lo);
else
xf86DrvMsg(scrp->scrnIndex, X_INFO,
"%s: Using %svrefresh range of %.2f-%.2f Hz\n",
scrp->monitor->id, type,
scrp->monitor->vrefresh[i].lo,
scrp->monitor->vrefresh[i].hi);
}
type = "";
if (!scrp->monitor->maxPixClock && !specified) {
type = "default ";
scrp->monitor->maxPixClock = 65000.0;
}
if (scrp->monitor->maxPixClock) {
xf86DrvMsg(scrp->scrnIndex, X_INFO,
"%s: Using %smaximum pixel clock of %.2f MHz\n",
scrp->monitor->id, type,
(float) scrp->monitor->maxPixClock / 1000.0);
}
}
/*
* Store the clockRanges for later use by the VidMode extension.
*/
nt_list_for_each_entry(cp, clockRanges, next) {
ClockRangePtr newCR = XNFalloc(sizeof(ClockRange));
memcpy(newCR, cp, sizeof(ClockRange));
newCR->next = NULL;
if (scrp->clockRanges == NULL)
scrp->clockRanges = newCR;
else
nt_list_append(newCR, scrp->clockRanges, ClockRange, next);
}
/* Determine which pixmap format to pass to scanLineWidth() */
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];
}
}
/*
* 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] ==
scanLineWidth(virtualX, virtualY, linePitches[i],
apertureSize, BankFormat, pitchInc))) {
linePitch = linePitches[i];
break;
}
}
}
else {
linePitch = scanLineWidth(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;
}
else if (!modeNames || !*modeNames) {
/* No virtual size given in the config, try to infer */
/* XXX this doesn't take m{in,ax}Pitch into account; oh well */
inferred_virtual = inferVirtualSize(scrp, availModes, &virtX, &virtY);
if (inferred_virtual)
linePitch = scanLineWidth(virtX, virtY, minPitch, apertureSize,
BankFormat, pitchInc);
}
/* 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,
virtX, virtY);
if (status == MODE_OK) {
status = xf86CheckModeForMonitor(p, scrp->monitor);
}
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 {
printModeRejectMessage(scrp->scrnIndex, p, 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;
}
}
/*
* 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 = XNFcallocarray(1, sizeof(DisplayModeRec));
new->prev = last;
new->type = M_T_USERDEF;
new->name = XNFstrdup(modeNames[i]);
if (new->prev)
new->prev->next = new;
*endp = last = new;
endp = &new->next;
}
}
/* Lookup each mode */
#ifdef XINERAMA
if (noPanoramiXExtension)
validateAllDefaultModes = TRUE;
#endif /* XINERAMA */
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 (!scrp->monitor->reducedblanking &&
(q->type & M_T_DEFAULT) &&
((double) q->HTotal / (double) q->HDisplay) < 1.15)
continue;
if (modeSize < (q->HDisplay * q->VDisplay)) {
r = q;
modeSize = q->HDisplay * q->VDisplay;
}
}
}
}
if (r == NULL)
break;
p = XNFcallocarray(1, sizeof(DisplayModeRec));
p->prev = last;
p->name = XNFstrdup(r->name);
if (!userModes)
p->type = M_T_USERDEF;
if (p->prev)
p->prev->next = p;
*endp = last = p;
endp = &p->next;
}
repeat = FALSE;
lookupNext:
if (repeat && ((status = p->status) != MODE_OK))
printModeRejectMessage(scrp->scrnIndex, p, status);
saveType = p->type;
status = xf86LookupMode(scrp, p, clockRanges, strategy);
if (repeat && status == MODE_NOMODE)
continue;
if (status != MODE_OK)
printModeRejectMessage(scrp->scrnIndex, p, 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] ==
scanLineWidth(newVirtX, newVirtY, linePitches[i],
apertureSize, BankFormat, pitchInc))) {
newLinePitch = linePitches[i];
break;
}
}
}
else {
if (linePitch < minPitch)
linePitch = minPitch;
newLinePitch = scanLineWidth(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, 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++;
}
/*
* If we estimated the virtual size above, we may have filtered away all
* the modes that maximally match that size; scan again to find out and
* fix up if so.
*/
if (inferred_virtual) {
int vx = 0, vy = 0;
for (p = scrp->modes; p; p = p->next) {
if (p->HDisplay > vx && p->VDisplay > vy) {
vx = p->HDisplay;
vy = p->VDisplay;
}
}
if (vx < virtX || vy < virtY) {
const int types[] = {
M_T_BUILTIN | M_T_PREFERRED,
M_T_BUILTIN,
M_T_DRIVER | M_T_PREFERRED,
M_T_DRIVER,
0
};
const int ntypes = ARRAY_SIZE(types);
int n;
/*
* We did not find the estimated virtual size. So now we want to
* find the largest mode available, but we want to search in the
* modes in the order of "types" listed above.
*/
for (n = 0; n < ntypes; n++) {
int type = types[n];
vx = 0;
vy = 0;
for (p = scrp->modes; p; p = p->next) {
/* scan through the modes in the sort order above */
if ((p->type & type) != type)
continue;
if (p->HDisplay > vx && p->VDisplay > vy) {
vx = p->HDisplay;
vy = p->VDisplay;
}
}
if (vx && vy)
/* Found one */
break;
}
xf86DrvMsg(scrp->scrnIndex, X_WARNING,
"Shrinking virtual size estimate from %dx%d to %dx%d\n",
virtX, virtY, vx, vy);
virtX = _VIRTUALX(vx);
virtY = vy;
for (p = scrp->modes; p; p = p->next) {
if (numModes > 0) {
if (p->HDisplay > virtX)
p->status = MODE_VIRTUAL_X;
if (p->VDisplay > virtY)
p->status = MODE_VIRTUAL_Y;
if (p->status != MODE_OK) {
numModes--;
printModeRejectMessage(scrp->scrnIndex, p, p->status);
}
}
}
if (linePitches != NULL) {
for (i = 0; linePitches[i] != 0; i++) {
if ((linePitches[i] >= virtX) &&
(linePitches[i] ==
scanLineWidth(virtX, virtY, linePitches[i],
apertureSize, BankFormat, pitchInc))) {
linePitch = linePitches[i];
break;
}
}
}
else {
linePitch = scanLineWidth(virtX, virtY, minPitch,
apertureSize, BankFormat, pitchInc);
}
}
}
/* 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
*
*/
void
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;
}
free((void *) mode->name);
free(mode);
}
/*
* xf86PruneDriverModes
*
* Remove modes from the driver's mode list which have been marked as
* invalid.
*/
void
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) {
xf86DeleteMode(&(scrp->modes), p);
}
p = n;
} while (p != NULL && p != first);
/* modePool is no longer needed, turf it */
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;
xf86DeleteMode(&scrp->modePool, scrp->modePool);
}
}
/*
* 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.
*/
void
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);
DebugF("%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);
p = p->next;
} while (p != NULL && p != scrp->modes);
}
void
xf86PrintModes(ScrnInfoPtr scrp)
{
DisplayModePtr p;
float hsync, refresh = 0;
const char *desc, *desc2, *prefix, *uprefix;
if (scrp == NULL)
return;
xf86DrvMsg(scrp->scrnIndex, X_INFO, "Virtual size is %dx%d (pitch %d)\n",
scrp->virtualX, scrp->virtualY, scrp->displayWidth);
p = scrp->modes;
if (p == NULL)
return;
do {
desc = desc2 = "";
hsync = xf86ModeHSync(p);
refresh = xf86ModeVRefresh(p);
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 if (p->type & M_T_DRIVER)
prefix = "Driver 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)
xf86PrintModeline(scrp->scrnIndex, p);
p = p->next;
} while (p != NULL && p != scrp->modes);
}
Reference in New Issue View Git Blame Copy Permalink