int sc1200_set_tv_format(TVStandardType format, GfxOnTVType resolution);
int sc1200_set_tv_output(int output);
int sc1200_set_tv_enable(int enable);
int sc1200_set_tv_flicker_filter(int ff);
int sc1200_set_tv_sub_carrier_reset(int screset);
int sc1200_set_tv_vphase(int vphase);
int sc1200_set_tv_YC_delay(int delay);
int sc1200_set_tvenc_reset_interval(int interval);
int sc1200_set_tv_cc_enable(int enable);
int sc1200_set_tv_cc_data(unsigned char data1, unsigned char data2);
int sc1200_set_tv_display(int width, int height);
int sc1200_test_tvout_odd_field(void);
int sc1200_test_tvenc_odd_field(void);
int sc1200_set_tv_field_status_invert(int enable);
int sc1200_get_tv_vphase(void);
int sc1200_get_tv_enable(unsigned int *p_on);
int sc1200_get_tv_output(void);
int sc1200_get_tv_mode_count(TVStandardType format);
int sc1200_get_tv_display_mode(int *width, int *height, int *bpp, int *hz);
int sc1200_get_tv_display_mode_frequency(unsigned short width,
unsigned short height,
TVStandardType format,
int *frequency);
int sc1200_is_tv_display_mode_supported(unsigned short width,
unsigned short height,
TVStandardType format);
int sc1200_get_tv_standard(unsigned long *p_standard);
int sc1200_get_available_tv_standards(unsigned long *p_standards);
int sc1200_set_tv_standard(unsigned long standard);
int sc1200_get_tv_vga_mode(unsigned long *p_vga_mode);
int sc1200_get_available_tv_vga_modes(unsigned long *p_vga_modes);
int sc1200_set_tv_vga_mode(unsigned long vga_mode);
int sc1200_get_tvout_mode(unsigned long *p_tvout_mode);
int sc1200_set_tvout_mode(unsigned long tvout_mode);
int sc1200_get_sharpness(int *p_sharpness);
int sc1200_set_sharpness(int sharpness);
int sc1200_get_flicker_filter(int *p_flicker);
int sc1200_set_flicker_filter(int flicker);
int sc1200_get_overscan(int *p_x, int *p_y);
int sc1200_set_overscan(int x, int y);
int sc1200_get_position(int *p_x, int *p_y);
int sc1200_set_position(int x, int y);
int sc1200_get_color(int *p_color);
int sc1200_set_color(int color);
int sc1200_get_brightness(int *p_brightness);
int sc1200_set_brightness(int brightness);
int sc1200_get_contrast(int *p_contrast);
int sc1200_set_contrast(int constrast);
int sc1200_get_yc_filter(unsigned int *p_yc_filter);
int sc1200_set_yc_filter(unsigned int yc_filter);
int sc1200_get_aps_trigger_bits(unsigned int *p_trigger_bits);
int sc1200_set_aps_trigger_bits(unsigned int trigger_bits);
unsigned char cc_add_parity_bit(unsigned char data);
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_format(TVStandardType format, GfxOnTVType resolution)
#else
int
gfx_set_tv_format(TVStandardType format, GfxOnTVType resolution)
#endif
{
unsigned long ctrl2, mode;
ctrl2 =
READ_VID32(SC1200_TVENC_TIM_CTRL_2) & (SC1200_TVENC_OUTPUT_YCBCR |
SC1200_TVENC_CFS_MASK);
mode = READ_VID32(SC1200_TVOUT_HORZ_SCALING) &
SC1200_TVOUT_FLICKER_FILTER_MASK;
switch (format) {
case TV_STANDARD_NTSC:
WRITE_VID32(SC1200_TVOUT_HORZ_SYNC, 0x03580350);
WRITE_VID32(SC1200_TVOUT_VERT_SYNC, 0x05001000);
if (gfx_chip_revision <= SC1200_REV_B3)
WRITE_VID32(SC1200_TVOUT_VERT_DOWNSCALE, 0xffffffff);
WRITE_VID32(SC1200_TVENC_TIM_CTRL_1, 0xa2a01050);
WRITE_VID32(SC1200_TVENC_TIM_CTRL_2, 0x9ff000f9 | ctrl2);
WRITE_VID32(SC1200_TVENC_SUB_FREQ, 0x21f07c1f);
WRITE_VID32(SC1200_TVENC_DISP_POS, 0x00120071);
WRITE_VID32(SC1200_TVENC_DISP_SIZE, 0x00ef02cf);
switch (resolution) {
case GFX_ON_TV_SQUARE_PIXELS:
if (gfx_chip_revision <= SC1200_REV_B3) {
WRITE_VID32(SC1200_TVOUT_HORZ_TIM, 0x00740359);
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x10020700 | mode);
WRITE_VID32(SC1200_TVOUT_LINE_END, 0x039700f0);
} else {
WRITE_VID32(SC1200_TVOUT_HORZ_TIM, 0x006f0359);
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x10020500 | mode);
WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE, 0x3A000000);
WRITE_VID32(SC1200_TVOUT_LINE_END, 0x038400f0);
}
break;
case GFX_ON_TV_NO_SCALING:
WRITE_VID32(SC1200_TVOUT_HORZ_TIM, 0x00740359);
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x10020500 | mode);
if (gfx_chip_revision >= SC1200_REV_C1)
WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE, 0x40000000);
WRITE_VID32(SC1200_TVOUT_LINE_END, 0x039700f0);
break;
default:
return (GFX_STATUS_BAD_PARAMETER);
}
break;
case TV_STANDARD_PAL:
WRITE_VID32(SC1200_TVOUT_HORZ_SYNC, 0x035e0356);
WRITE_VID32(SC1200_TVOUT_VERT_SYNC, 0x05001000);
if (gfx_chip_revision <= SC1200_REV_B3)
WRITE_VID32(SC1200_TVOUT_VERT_DOWNSCALE, 0xffffffff);
WRITE_VID32(SC1200_TVENC_TIM_CTRL_1, 0xB1201050);
WRITE_VID32(SC1200_TVENC_TIM_CTRL_2, 0x9ff000d9 | ctrl2);
WRITE_VID32(SC1200_TVENC_SUB_FREQ, 0x2a098acb);
WRITE_VID32(SC1200_TVENC_DISP_POS, 0x0016007b);
WRITE_VID32(SC1200_TVENC_DISP_SIZE, 0x011f02cf);
switch (resolution) {
case GFX_ON_TV_NO_SCALING:
WRITE_VID32(SC1200_TVOUT_HORZ_TIM, 0x007c035f);
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x10020500 | mode);
if (gfx_chip_revision >= SC1200_REV_C1)
WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE, 0x40000000);
WRITE_VID32(SC1200_TVOUT_LINE_END, 0x039c0120);
break;
case GFX_ON_TV_SQUARE_PIXELS:
WRITE_VID32(SC1200_TVOUT_HORZ_TIM, 0x007a035f);
if (gfx_chip_revision <= SC1200_REV_B3) {
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x1002040b | mode);
WRITE_VID32(SC1200_TVOUT_LINE_END, 0x038a0120);
} else {
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x10020500 | mode);
WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE, 0x46000000);
WRITE_VID32(SC1200_TVOUT_LINE_END, 0x03880120);
}
break;
default:
return (GFX_STATUS_BAD_PARAMETER);
}
break;
default:
return (GFX_STATUS_BAD_PARAMETER);
}
return (GFX_STATUS_OK);
}
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_output(int output)
#else
int
gfx_set_tv_output(int output)
#endif
{
unsigned long ctrl2, ctrl3;
ctrl2 = READ_VID32(SC1200_TVENC_TIM_CTRL_2);
ctrl3 = READ_VID32(SC1200_TVENC_TIM_CTRL_3);
ctrl2 &= ~(SC1200_TVENC_OUTPUT_YCBCR | SC1200_TVENC_CFS_MASK);
ctrl3 &= ~(SC1200_TVENC_CM | SC1200_TVENC_SYNCMODE_MASK | SC1200_TVENC_CS);
switch (output) {
case TV_OUTPUT_COMPOSITE:
WRITE_VID32(SC1200_TVENC_TIM_CTRL_2, ctrl2 | SC1200_TVENC_CFS_CVBS);
WRITE_VID32(SC1200_TVENC_TIM_CTRL_3, ctrl3);
break;
case TV_OUTPUT_S_VIDEO:
WRITE_VID32(SC1200_TVENC_TIM_CTRL_2, ctrl2 | SC1200_TVENC_CFS_SVIDEO);
WRITE_VID32(SC1200_TVENC_TIM_CTRL_3, ctrl3);
break;
case TV_OUTPUT_YUV:
WRITE_VID32(SC1200_TVENC_TIM_CTRL_2,
ctrl2 | SC1200_TVENC_OUTPUT_YCBCR |
SC1200_TVENC_CFS_BYPASS);
WRITE_VID32(SC1200_TVENC_TIM_CTRL_3,
ctrl3 | SC1200_TVENC_CM | SC1200_TVENC_CS);
break;
case TV_OUTPUT_SCART:
WRITE_VID32(SC1200_TVENC_TIM_CTRL_2, ctrl2 | SC1200_TVENC_CFS_CVBS);
WRITE_VID32(SC1200_TVENC_TIM_CTRL_3,
ctrl3 | SC1200_TVENC_CM | SC1200_TVENC_SYNC_ON_GREEN);
break;
default:
return (GFX_STATUS_BAD_PARAMETER);
}
ctrl2 = READ_VID32(SC1200_TVENC_DAC_CONTROL);
ctrl2 &= ~SC1200_TVENC_TRIM_MASK;
if ((gfx_chip_revision == SC1200_REV_B3) && (output == TV_OUTPUT_S_VIDEO))
ctrl2 |= 0x7;
else
ctrl2 |= 0x5;
WRITE_VID32(SC1200_TVENC_DAC_CONTROL, ctrl2);
WRITE_VID32(SC1200_TVOUT_DEBUG, SC1200_TVOUT_CONVERTER_INTERPOLATION);
return (GFX_STATUS_OK);
}
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_enable(int enable)
#else
int
gfx_set_tv_enable(int enable)
#endif
{
unsigned long value_tim, value_dac;
value_tim = READ_VID32(SC1200_TVENC_TIM_CTRL_1);
value_dac = READ_VID32(SC1200_TVENC_DAC_CONTROL);
if (enable) {
value_tim |= SC1200_TVENC_VIDEO_TIMING_ENABLE;
value_dac &= ~SC1200_TVENC_POWER_DOWN;
gfx_set_screen_enable(1);
} else {
value_tim &= ~SC1200_TVENC_VIDEO_TIMING_ENABLE;
value_dac |= SC1200_TVENC_POWER_DOWN;
}
WRITE_VID32(SC1200_TVENC_TIM_CTRL_1, value_tim);
WRITE_VID32(SC1200_TVENC_DAC_CONTROL, value_dac);
return (GFX_STATUS_OK);
}
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_flicker_filter(int ff)
#else
int
gfx_set_tv_flicker_filter(int ff)
#endif
{
unsigned long mode;
mode = READ_VID32(SC1200_TVOUT_HORZ_SCALING);
mode &= ~SC1200_TVOUT_FLICKER_FILTER_MASK;
switch (ff) {
case TV_FLICKER_FILTER_NONE:
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
mode | SC1200_TVOUT_FLICKER_FILTER_DISABLED);
break;
case TV_FLICKER_FILTER_NORMAL:
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
mode | SC1200_TVOUT_FLICKER_FILTER_FOURTH_HALF_FOURTH);
break;
case TV_FLICKER_FILTER_INTERLACED:
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
mode | SC1200_TVOUT_FLICKER_FILTER_HALF_ONE_HALF);
break;
default:
return GFX_STATUS_BAD_PARAMETER;
}
return (GFX_STATUS_OK);
}
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_sub_carrier_reset(int screset)
#else
int
gfx_set_tv_sub_carrier_reset(int screset)
#endif
{
unsigned long mode;
mode = READ_VID32(SC1200_TVENC_TIM_CTRL_1);
mode &= ~SC1200_TVENC_SUB_CARRIER_RESET_MASK;
switch (screset) {
case TV_SUB_CARRIER_RESET_NEVER:
WRITE_VID32(SC1200_TVENC_TIM_CTRL_1,
mode | SC1200_TVENC_SUB_CARRIER_RESET_NEVER);
break;
case TV_SUB_CARRIER_RESET_EVERY_TWO_LINES:
WRITE_VID32(SC1200_TVENC_TIM_CTRL_1,
mode | SC1200_TVENC_SUB_CARRIER_RESET_EVERY_TWO_LINES);
break;
case TV_SUB_CARRIER_RESET_EVERY_TWO_FRAMES:
WRITE_VID32(SC1200_TVENC_TIM_CTRL_1,
mode | SC1200_TVENC_SUB_CARRIER_RESET_EVERY_TWO_FRAMES);
break;
case TV_SUB_CARRIER_RESET_EVERY_FOUR_FRAMES:
WRITE_VID32(SC1200_TVENC_TIM_CTRL_1,
mode | SC1200_TVENC_SUB_CARRIER_RESET_EVERY_FOUR_FRAMES);
break;
default:
return GFX_STATUS_BAD_PARAMETER;
}
return (GFX_STATUS_OK);
}
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_vphase(int vphase)
#else
int
gfx_set_tv_vphase(int vphase)
#endif
{
unsigned long mode = READ_VID32(SC1200_TVENC_TIM_CTRL_1);
mode &= ~SC1200_TVENC_VPHASE_MASK;
mode |= (vphase << SC1200_TVENC_VPHASE_POS) & SC1200_TVENC_VPHASE_MASK;
WRITE_VID32(SC1200_TVENC_TIM_CTRL_1, mode);
return (GFX_STATUS_OK);
}
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_YC_delay(int delay)
#else
int
gfx_set_tv_YC_delay(int delay)
#endif
{
unsigned long mode;
if (gfx_chip_revision < SC1200_REV_C1)
return (GFX_STATUS_OK);
mode = READ_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE);
mode &= ~SC1200_TVOUT_YC_DELAY_MASK;
switch (delay) {
case TV_YC_DELAY_NONE:
WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE,
mode | SC1200_TVOUT_YC_DELAY_NONE);
break;
case TV_Y_DELAY_ONE_PIXEL:
WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE,
mode | SC1200_TVOUT_Y_DELAY_ONE_PIXEL);
break;
case TV_C_DELAY_ONE_PIXEL:
WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE,
mode | SC1200_TVOUT_C_DELAY_ONE_PIXEL);
break;
case TV_C_DELAY_TWO_PIXELS:
WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE,
mode | SC1200_TVOUT_C_DELAY_TWO_PIXELS);
break;
default:
return GFX_STATUS_BAD_PARAMETER;
}
return (GFX_STATUS_OK);
}
#if GFX_TV_DYNAMIC
int
sc1200_set_tvenc_reset_interval(int interval)
#else
int
gfx_set_tvenc_reset_interval(int interval)
#endif
{
unsigned long value;
value = READ_VID32(SC1200_TVOUT_HORZ_SCALING);
value &= ~SC1200_TVENC_EXTERNAL_RESET_INTERVAL_MASK;
switch (interval) {
case TVENC_RESET_EVERY_ODD_FIELD:
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
value | SC1200_TVENC_EXTERNAL_RESET_EVERY_ODD_FIELD);
break;
case TVENC_RESET_EVERY_EVEN_FIELD:
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
value | SC1200_TVENC_EXTERNAL_RESET_EVERY_EVEN_FIELD);
break;
case TVENC_RESET_NEXT_ODD_FIELD:
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
value | SC1200_TVENC_EXTERNAL_RESET_NEXT_ODD_FIELD);
break;
case TVENC_RESET_NEXT_EVEN_FIELD:
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
value | SC1200_TVENC_EXTERNAL_RESET_NEXT_EVEN_FIELD);
break;
case TVENC_RESET_EVERY_FIELD:
WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
value | SC1200_TVENC_EXTERNAL_RESET_EVERY_FIELD);
break;
case TVENC_RESET_EVERY_X_ODD_FIELDS:
case TVENC_RESET_EVERY_X_EVEN_FIELDS:
return GFX_STATUS_UNSUPPORTED;
default:
return GFX_STATUS_BAD_PARAMETER;
}
return (GFX_STATUS_OK);
}
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_cc_enable(int enable)
#else
int
gfx_set_tv_cc_enable(int enable)
#endif
{
unsigned long value;
value = READ_VID32(SC1200_TVENC_CC_CONTROL);
value &= ~(0x0005F);
if (enable)
value |= 0x51;
WRITE_VID32(SC1200_TVENC_CC_CONTROL, value);
return (0);
}
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_display(int width, int height)
#else
int
gfx_set_tv_display(int width, int height)
#endif
{
DISPLAYMODE *pMode;
unsigned int i;
for (i = 0; i < NUM_TV_MODES; i++) {
pMode = &TVTimings[i];
if ((unsigned)width == pMode->hactive
&& (unsigned)height == pMode->vactive)
break;
}
if (i == NUM_TV_MODES)
return 0;
gfx_set_display_timings(gfx_get_display_bpp(),
(unsigned short)pMode->flags, pMode->hactive,
pMode->hblankstart, pMode->hsyncstart,
pMode->hsyncend, pMode->hblankend, pMode->htotal,
pMode->vactive, pMode->vblankstart,
pMode->vsyncstart, pMode->vsyncend,
pMode->vblankend, pMode->vtotal, pMode->frequency);
return 1;
}
unsigned char
cc_add_parity_bit(unsigned char data)
{
int i, num = 0;
unsigned char d = data;
for (i = 0; i < 7; i++) {
if (d & 0x1)
num++;
d >>= 1;
}
if (num & 0x1)
return (data & ~0x80);
else
return (data | 0x80);
}
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_cc_data(unsigned char data1, unsigned char data2)
#else
int
gfx_set_tv_cc_data(unsigned char data1, unsigned char data2)
#endif
{
unsigned long value;
value = cc_add_parity_bit(data1) | (cc_add_parity_bit(data2) << 8);
WRITE_VID32(SC1200_TVENC_CC_DATA, value);
return (0);
}
#if GFX_TV_DYNAMIC
int
sc1200_test_tvout_odd_field(void)
#else
int
gfx_test_tvout_odd_field(void)
#endif
{
unsigned long debug = READ_VID32(SC1200_TVOUT_DEBUG);
WRITE_VID32(SC1200_TVOUT_DEBUG, debug | SC1200_TVOUT_FIELD_STATUS_TV);
if (READ_VID32(SC1200_TVOUT_DEBUG) & SC1200_TVOUT_FIELD_STATUS_EVEN)
return (0);
else
return (1);
}
#if GFX_TV_DYNAMIC
int
sc1200_test_tvenc_odd_field(void)
#else
int
gfx_test_tvenc_odd_field(void)
#endif
{
unsigned long debug = READ_VID32(SC1200_TVOUT_DEBUG);
WRITE_VID32(SC1200_TVOUT_DEBUG, debug & ~SC1200_TVOUT_FIELD_STATUS_TV);
if (READ_VID32(SC1200_TVOUT_DEBUG) & SC1200_TVOUT_FIELD_STATUS_EVEN)
return (0);
else
return (1);
}
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_field_status_invert(int enable)
#else
int
gfx_set_tv_field_status_invert(int enable)
#endif
{
unsigned long value;
value = READ_VID32(SC1200_TVOUT_DEBUG);
if (enable) {
value |= SC1200_TVOUT_FIELD_STATUS_INVERT;
} else {
value &= ~(SC1200_TVOUT_FIELD_STATUS_INVERT);
}
WRITE_VID32(SC1200_TVOUT_DEBUG, value);
return (GFX_STATUS_OK);
}
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_vphase(void)
#else
int
gfx_get_tv_vphase(void)
#endif
{
unsigned long mode = READ_VID32(SC1200_TVENC_TIM_CTRL_1);
return (int)((mode & SC1200_TVENC_VPHASE_MASK) >> SC1200_TVENC_VPHASE_POS);
}
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_enable(unsigned int *p_on)
#else
int
gfx_get_tv_enable(unsigned int *p_on)
#endif
{
unsigned long control = READ_VID32(SC1200_TVENC_DAC_CONTROL);
*p_on = (unsigned int)(!(control & SC1200_TVENC_POWER_DOWN));
return GFX_STATUS_OK;
}
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_output(void)
#else
int
gfx_get_tv_output(void)
#endif
{
unsigned long ctrl2, ctrl3;
int format = 0;
ctrl2 = READ_VID32(SC1200_TVENC_TIM_CTRL_2);
ctrl3 = READ_VID32(SC1200_TVENC_TIM_CTRL_3);
if ((ctrl2 & SC1200_TVENC_CFS_MASK) == SC1200_TVENC_CFS_SVIDEO)
format = TV_OUTPUT_S_VIDEO;
else if (ctrl2 & SC1200_TVENC_OUTPUT_YCBCR)
format = TV_OUTPUT_YUV;
else if ((ctrl2 & SC1200_TVENC_CFS_MASK) == SC1200_TVENC_CFS_CVBS) {
if (ctrl3 & SC1200_TVENC_CM)
format = TV_OUTPUT_SCART;
else
format = TV_OUTPUT_COMPOSITE;
}
return format;
}
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_mode_count(TVStandardType format)
#else
int
gfx_get_tv_mode_count(TVStandardType format)
#endif
{
unsigned int mode, count = 0;
unsigned long flag;
switch (format) {
case TV_STANDARD_NTSC:
flag = GFX_MODE_TV_NTSC;
break;
case TV_STANDARD_PAL:
flag = GFX_MODE_TV_PAL;
break;
default:
return 0;
}
for (mode = 0; mode < NUM_TV_MODES; mode++) {
if (TVTimings[mode].flags & flag)
count++;
}
return count;
}
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_display_mode(int *width, int *height, int *bpp, int *hz)
#else
int
gfx_get_tv_display_mode(int *width, int *height, int *bpp, int *hz)
#endif
{
unsigned long frequency;
unsigned long mode, flags;
*width = gfx_get_hactive();
*height = gfx_get_vactive();
*bpp = gfx_get_display_bpp();
frequency = gfx_get_clock_frequency();
for (mode = 0; mode < NUM_TV_MODES; mode++) {
if (TVTimings[mode].hactive == (unsigned short)(*width) &&
TVTimings[mode].vactive == (unsigned short)(*height) &&
TVTimings[mode].frequency == frequency) {
flags = TVTimings[mode].flags;
if (flags & GFX_MODE_TV_NTSC)
*hz = 60;
else if (flags & GFX_MODE_TV_PAL)
*hz = 50;
else
*hz = 0;
return (1);
}
}
return -1;
}
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_display_mode_frequency(unsigned short width,
unsigned short height,
TVStandardType format, int *frequency)
#else
int
gfx_get_tv_display_mode_frequency(unsigned short width, unsigned short height,
TVStandardType format, int *frequency)
#endif
{
unsigned long mode, flag;
int retval = -1;
*frequency = 0;
switch (format) {
case TV_STANDARD_NTSC:
flag = GFX_MODE_TV_NTSC;
break;
case TV_STANDARD_PAL:
flag = GFX_MODE_TV_PAL;
break;
default:
return -1;
}
for (mode = 0; mode < NUM_TV_MODES; mode++) {
if ((TVTimings[mode].hactive == width) &&
(TVTimings[mode].vactive == height) &&
(TVTimings[mode].flags & flag)) {
*frequency = TVTimings[mode].frequency;
retval = 1;
}
}
return retval;
}
#if GFX_TV_DYNAMIC
int
sc1200_is_tv_display_mode_supported(unsigned short width,
unsigned short height,
TVStandardType format)
#else
int
gfx_is_tv_display_mode_supported(unsigned short width, unsigned short height,
TVStandardType format)
#endif
{
unsigned long mode, flag;
switch (format) {
case TV_STANDARD_NTSC:
flag = GFX_MODE_TV_NTSC;
break;
case TV_STANDARD_PAL:
flag = GFX_MODE_TV_PAL;
break;
default:
return -1;
}
for (mode = 0; mode < NUM_TV_MODES; mode++) {
if (TVTimings[mode].hactive == width &&
TVTimings[mode].vactive == height &&
(TVTimings[mode].flags & flag)) {
return ((int)mode);
}
}
return -1;
}