#ifdef HAVE_CONFIG_H
#include <kdrive-config.h>
#endif
#include "kdrive.h"
const KdMonitorTiming kdMonitorTimings[] = {
{ 320, 240, 64, 16256,
17, 12, 32, KdSyncNegative,
1, 11, 14, KdSyncNegative,
},
{ 640, 350, 85, 31500,
32, 96, 192, KdSyncPositive,
32, 60, 95, KdSyncNegative,
},
{ 640, 400, 60, 31500,
32, 96, 192, KdSyncNegative,
1, 41, 45, KdSyncPositive,
},
{ 720, 400, 85, 35500,
36, 108, 216, KdSyncNegative,
1, 42, 46, KdSyncPositive,
},
{
720, 576, 52, 32954,
16, 80, 160, KdSyncPositive,
1, 45, 49, KdSyncPositive,
},
{ 640, 480, 85, 36000,
56, 80, 192, KdSyncNegative,
1, 25, 29, KdSyncNegative,
},
{ 640, 480, 75, 31500,
16, 120, 200, KdSyncNegative,
1, 16, 20, KdSyncNegative,
},
{ 640, 480, 72, 31500,
16, 120, 176, KdSyncNegative,
1, 20, 24, KdSyncNegative,
},
{ 640, 480, 60, 25175,
16, 48, 160, KdSyncNegative,
10, 33, 45, KdSyncNegative,
},
{ 800, 600, 85, 56250,
32, 152, 248, KdSyncPositive,
1, 27, 31, KdSyncPositive,
},
{ 800, 600, 75, 49500,
16, 160, 256, KdSyncPositive,
1, 21, 25, KdSyncPositive,
},
#define MONITOR_TIMING_DEFAULT 9
{ 800, 600, 72, 50000,
56, 64, 240, KdSyncPositive,
37, 23, 66, KdSyncPositive,
},
{ 800, 600, 60, 40000,
40, 88, 256, KdSyncPositive,
1, 23, 28, KdSyncPositive,
},
{ 800, 600, 56, 36000,
24, 128, 224, KdSyncPositive,
1, 22, 25, KdSyncPositive,
},
{ 1024, 768, 85, 94500,
48, 208, 352, KdSyncPositive,
1, 36, 40, KdSyncPositive,
},
{ 1024, 768, 75, 78750,
16, 176, 288, KdSyncPositive,
1, 28, 32, KdSyncPositive,
},
{ 1024, 768, 70, 75000,
24, 144, 304, KdSyncNegative,
3, 29, 38, KdSyncNegative,
},
{ 1024, 768, 60, 65000,
24, 160, 320, KdSyncNegative,
3, 29, 38, KdSyncNegative,
},
{ 1152, 864, 75, 108000,
64, 256, 448, KdSyncPositive,
1, 32, 36, KdSyncPositive,
},
{ 1152, 900, 85, 122500,
48, 208, 384, KdSyncPositive,
1, 32, 38, KdSyncPositive,
},
{ 1152, 900, 75, 108250,
32, 208, 384, KdSyncPositive,
1, 32, 38, KdSyncPositive,
},
{ 1152, 900, 70, 100250,
32, 208, 384, KdSyncPositive,
2, 32, 38, KdSyncPositive,
},
{ 1152, 900, 66, 95000,
32, 208, 384, KdSyncPositive,
1, 32, 38, KdSyncPositive,
},
{ 1280, 854, 103, 12500,
56, 16, 128, KdSyncPositive,
1, 216, 12, KdSyncPositive,
},
{ 1280, 960, 85, 148500,
64, 224, 448, KdSyncPositive,
1, 47, 51, KdSyncPositive,
},
{ 1280, 960, 60, 108000,
96, 312, 520, KdSyncPositive,
1, 36, 40, KdSyncPositive,
},
{ 1280, 1024, 85, 157500,
64, 224, 448, KdSyncPositive,
1, 44, 48, KdSyncPositive,
},
{ 1280, 1024, 75, 135000,
16, 248, 408, KdSyncPositive,
1, 38, 42, KdSyncPositive,
},
{ 1280, 1024, 60, 108000,
48, 248, 408, KdSyncPositive,
1, 38, 42, KdSyncPositive,
},
{ 1600, 1200, 85, 229500,
64, 304, 560, KdSyncPositive,
1, 46, 50, KdSyncPositive,
},
{ 1600, 1200, 75, 202500,
64, 304, 560, KdSyncPositive,
1, 46, 50, KdSyncPositive,
},
{ 1600, 1200, 70, 189000,
64, 304, 560, KdSyncPositive,
1, 46, 50, KdSyncPositive,
},
{ 1600, 1200, 65, 175500,
64, 304, 560, KdSyncPositive,
1, 46, 50, KdSyncPositive,
},
{ 1600, 1200, 60, 162000,
64, 304, 560, KdSyncPositive,
1, 46, 50, KdSyncPositive,
},
{ 1792, 1344, 85, 301500,
96, 352, 672, KdSyncNegative,
1, 92, 96, KdSyncPositive,
},
{ 1792, 1344, 75, 261000,
96, 352, 664, KdSyncNegative,
1, 69, 73, KdSyncPositive,
},
{ 1792, 1344, 60, 204750,
128, 328, 656, KdSyncNegative,
1, 46, 50, KdSyncPositive,
},
#if 0
{ 1800, 1012, 75 },
{ 1906, 1072, 68 },
#endif
{ 1856, 1392, 85, 330500,
160, 352, 736, KdSyncNegative,
1, 104, 108, KdSyncPositive,
},
{ 1856, 1392, 75, 288000,
128, 352, 704, KdSyncNegative,
1, 104, 108, KdSyncPositive,
},
{ 1856, 1392, 60, 218250,
96, 352, 672, KdSyncNegative,
1, 43, 47, KdSyncPositive,
},
{ 1920, 1440, 85, 341750,
160, 352, 760, KdSyncNegative,
1, 56, 60, KdSyncPositive,
},
{ 1920, 1440, 75, 297000,
144, 352, 720, KdSyncNegative,
1, 56, 60, KdSyncPositive,
},
{ 1920, 1440, 60, 234000,
128, 244, 680, KdSyncNegative,
1, 56, 60, KdSyncPositive,
},
};
#define NUM_MONITOR_TIMINGS (sizeof kdMonitorTimings/sizeof kdMonitorTimings[0])
const int kdNumMonitorTimings = NUM_MONITOR_TIMINGS;
const KdMonitorTiming *
KdFindMode (KdScreenInfo *screen,
Bool (*supported) (KdScreenInfo *,
const KdMonitorTiming *))
{
int i;
const KdMonitorTiming *t;
for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++)
{
if ((*supported) (screen, t) &&
t->horizontal == screen->width &&
t->vertical == screen->height &&
(!screen->rate || t->rate <= screen->rate))
{
return t;
}
}
ErrorF("Warning: mode not found, using default\n");
return &kdMonitorTimings[MONITOR_TIMING_DEFAULT];
}
static const KdMonitorTiming *
kdFindPrevSize (const KdMonitorTiming *old)
{
const KdMonitorTiming *new, *prev;
if (old == kdMonitorTimings)
return 0;
new = old;
while (new != kdMonitorTimings)
{
new--;
if (new->horizontal != old->horizontal &&
new->vertical != old->vertical)
{
break;
}
}
while (new != kdMonitorTimings)
{
prev = new - 1;
if (prev->horizontal == new->horizontal &&
prev->vertical == new->vertical &&
prev->rate > old->rate)
{
break;
}
new--;
}
return new;
}
Bool
KdTuneMode (KdScreenInfo *screen,
Bool (*usable) (KdScreenInfo *),
Bool (*supported) (KdScreenInfo *,
const KdMonitorTiming *))
{
const KdMonitorTiming *t;
while (!(*usable) (screen))
{
if (screen->fb[1].depth)
screen->fb[1].depth = 0;
else if (screen->fb[0].depth > 16)
screen->fb[0].depth = 16;
else if (screen->fb[0].depth > 8)
screen->fb[0].depth = 8;
else
{
t = kdFindPrevSize (KdFindMode (screen, supported));
if (!t)
return FALSE;
screen->width = t->horizontal;
screen->height = t->vertical;
screen->rate = t->rate;
}
}
return TRUE;
}
#ifdef RANDR
Bool
KdRandRGetInfo (ScreenPtr pScreen,
int randr,
Bool (*supported) (ScreenPtr pScreen,
const KdMonitorTiming *))
{
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
int i;
const KdMonitorTiming *t;
for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++)
{
if ((*supported) (pScreen, t))
{
RRScreenSizePtr pSize;
pSize = RRRegisterSize (pScreen,
t->horizontal,
t->vertical,
screen->width_mm,
screen->height_mm);
if (!pSize)
return FALSE;
if (!RRRegisterRate (pScreen, pSize, t->rate))
return FALSE;
if (t->horizontal == screen->width &&
t->vertical == screen->height &&
t->rate == screen->rate)
RRSetCurrentConfig (pScreen, randr, t->rate, pSize);
}
}
return TRUE;
}
const KdMonitorTiming *
KdRandRGetTiming (ScreenPtr pScreen,
Bool (*supported) (ScreenPtr pScreen,
const KdMonitorTiming *),
int rate,
RRScreenSizePtr pSize)
{
int i;
const KdMonitorTiming *t;
for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++)
{
if (t->horizontal == pSize->width &&
t->vertical == pSize->height &&
t->rate == rate &&
(*supported) (pScreen, t))
return t;
}
return 0;
}
#endif