typedef struct tagSC1200PLL
{
long frequency;
unsigned long clock_select;
}
SC1200PLL;
SC1200PLL gfx_sc1200_clock_table[] = {
{(25L << 16) | ((1750L * 65536L) / 10000L), 0x0070E00C},
{(27L << 16) | ((0000L * 65536L) / 10000L), 0x00300100},
{(28L << 16) | ((3220L * 65536L) / 10000L), 0x0070EC0C},
{(31L << 16) | ((5000L * 65536L) / 10000L), 0x00500D02},
{(36L << 16) | ((0000L * 65536L) / 10000L), 0x00500F02},
{(37L << 16) | ((5000L * 65536L) / 10000L), 0x0050B108},
{(40L << 16) | ((0000L * 65536L) / 10000L), 0x0050D20D},
{(44L << 16) | ((9000L * 65536L) / 10000L), 0x0050DC0D},
{(49L << 16) | ((5000L * 65536L) / 10000L), 0x00501502},
{(50L << 16) | ((0000L * 65536L) / 10000L), 0x0050A404},
{(50L << 16) | ((3500L * 65536L) / 10000L), 0x0050E00C},
{(54L << 16) | ((0000L * 65536L) / 10000L), 0x00300300},
{(56L << 16) | ((3916L * 65536L) / 10000L), 0x0050F40D},
{(56L << 16) | ((6440L * 65536L) / 10000L), 0x0050EC0C},
{(59L << 16) | ((0000L * 65536L) / 10000L), 0x0030A207},
{(63L << 16) | ((0000L * 65536L) / 10000L), 0x00300D02},
{(65L << 16) | ((0000L * 65536L) / 10000L), 0x0030CC0F},
{(67L << 16) | ((5000L * 65536L) / 10000L), 0x00300400},
{(70L << 16) | ((8000L * 65536L) / 10000L), 0x00301403},
{(72L << 16) | ((0000L * 65536L) / 10000L), 0x00300F02},
{(75L << 16) | ((0000L * 65536L) / 10000L), 0x0030B108},
{(78L << 16) | ((7500L * 65536L) / 10000L), 0x0030A205},
{(80L << 16) | ((0000L * 65536L) / 10000L), 0x0030D20D},
{(87L << 16) | ((2728L * 65536L) / 10000L), 0x0030E00E},
{(89L << 16) | ((8000L * 65536L) / 10000L), 0x0030DC0D},
{(94L << 16) | ((5000L * 65536L) / 10000L), 0x00300600},
{(99L << 16) | ((0000L * 65536L) / 10000L), 0x00301502},
{(100L << 16) | ((0000L * 65536L) / 10000L), 0x0030A404},
{(108L << 16) | ((0000L * 65536L) / 10000L), 0x00100300},
{(112L << 16) | ((5000L * 65536L) / 10000L), 0x00301802},
{(130L << 16) | ((0000L * 65536L) / 10000L), 0x0010CC0F},
{(135L << 16) | ((0000L * 65536L) / 10000L), 0x00100400},
{(157L << 16) | ((5000L * 65536L) / 10000L), 0x0010A205},
{(162L << 16) | ((0000L * 65536L) / 10000L), 0x00100500},
{(175L << 16) | ((0000L * 65536L) / 10000L), 0x0010E00E},
{(189L << 16) | ((0000L * 65536L) / 10000L), 0x00100600},
{(202L << 16) | ((0000L * 65536L) / 10000L), 0x0010EF0E},
{(232L << 16) | ((0000L * 65536L) / 10000L), 0x0010AA04},
{0x0018EC4D, 0x000F0000},
{0x00192CCC, 0x00000000},
{0x001B0000, 0x00300100},
{0x001F8000, 0x00010000},
{0x00240000, 0x00020000},
{0x00280000, 0x00030000},
{0x00318000, 0x00050000},
{0x00320000, 0x00040000},
{0x00384000, 0x00060000},
{0x00410000, 0x00080000},
{0x004E8000, 0x000A0000},
{0x005E8000, 0x000B0000},
{0x006C0000, 0x000C0000},
{0x00870000, 0x000D0000},
};
#define NUM_SC1200_FREQUENCIES sizeof(gfx_sc1200_clock_table)/sizeof(SC1200PLL)
int sc1200_set_video_enable(int enable);
int sc1200_set_video_format(unsigned long format);
int sc1200_set_video_size(unsigned short width, unsigned short height);
int sc1200_set_video_yuv_pitch(unsigned long ypitch, unsigned long uvpitch);
int sc1200_set_video_offset(unsigned long offset);
int sc1200_set_video_yuv_offsets(unsigned long yoffset, unsigned long uoffset,
unsigned long voffset);
int sc1200_set_video_window(short x, short y, unsigned short w,
unsigned short h);
int sc1200_set_video_left_crop(unsigned short x);
int sc1200_set_video_upscale(unsigned short srcw, unsigned short srch,
unsigned short dstw, unsigned short dsth);
int sc1200_set_video_scale(unsigned short srcw, unsigned short srch,
unsigned short dstw, unsigned short dsth);
int sc1200_set_video_vertical_downscale(unsigned short srch,
unsigned short dsth);
void sc1200_set_video_vertical_downscale_enable(int enable);
int sc1200_set_video_downscale_config(unsigned short type, unsigned short m);
int sc1200_set_video_color_key(unsigned long key, unsigned long mask,
int bluescreen);
int sc1200_set_video_filter(int xfilter, int yfilter);
int sc1200_set_video_palette(unsigned long *palette);
int sc1200_set_video_palette_entry(unsigned long index, unsigned long color);
int sc1200_set_video_downscale_coefficients(unsigned short coef1,
unsigned short coef2,
unsigned short coef3,
unsigned short coef4);
int sc1200_set_video_downscale_enable(int enable);
int sc1200_set_video_source(VideoSourceType source);
int sc1200_set_vbi_source(VbiSourceType source);
int sc1200_set_vbi_lines(unsigned long even, unsigned long odd);
int sc1200_set_vbi_total(unsigned long even, unsigned long odd);
int sc1200_set_video_interlaced(int enable);
int sc1200_set_color_space_YUV(int enable);
int sc1200_set_vertical_scaler_offset(char offset);
int sc1200_set_top_line_in_odd(int enable);
int sc1200_set_genlock_delay(unsigned long delay);
int sc1200_set_genlock_enable(int flags);
int sc1200_set_video_cursor(unsigned long key, unsigned long mask,
unsigned short select_color2,
unsigned long color1, unsigned long color2);
int sc1200_set_video_cursor_enable(int enable);
int sc1200_set_video_request(short x, short y);
int sc1200_select_alpha_region(int region);
int sc1200_set_alpha_enable(int enable);
int sc1200_set_alpha_window(short x, short y,
unsigned short width, unsigned short height);
int sc1200_set_alpha_value(unsigned char alpha, char delta);
int sc1200_set_alpha_priority(int priority);
int sc1200_set_alpha_color(unsigned long color);
int sc1200_set_alpha_color_enable(int enable);
int sc1200_set_no_ck_outside_alpha(int enable);
int sc1200_disable_softvga(void);
int sc1200_enable_softvga(void);
int sc1200_set_macrovision_enable(int enable);
void sc1200_reset_video(void);
int sc1200_set_display_control(int sync_polarities);
void sc1200_set_clock_frequency(unsigned long frequency);
int sc1200_set_screen_enable(int enable);
int sc1200_set_crt_enable(int enable);
int sc1200_get_video_enable(void);
int sc1200_get_video_format(void);
unsigned long sc1200_get_video_src_size(void);
unsigned long sc1200_get_video_line_size(void);
unsigned long sc1200_get_video_xclip(void);
unsigned long sc1200_get_video_offset(void);
void sc1200_get_video_yuv_offsets(unsigned long *yoffset,
unsigned long *uoffset,
unsigned long *voffset);
void sc1200_get_video_yuv_pitch(unsigned long *ypitch,
unsigned long *uvpitch);
unsigned long sc1200_get_video_upscale(void);
unsigned long sc1200_get_video_scale(void);
unsigned long sc1200_get_video_downscale_delta(void);
int sc1200_get_video_vertical_downscale_enable(void);
int sc1200_get_video_downscale_config(unsigned short *type,
unsigned short *m);
void sc1200_get_video_downscale_coefficients(unsigned short *coef1,
unsigned short *coef2,
unsigned short *coef3,
unsigned short *coef4);
void sc1200_get_video_downscale_enable(int *enable);
unsigned long sc1200_get_video_dst_size(void);
unsigned long sc1200_get_video_position(void);
unsigned long sc1200_get_video_color_key(void);
unsigned long sc1200_get_video_color_key_mask(void);
int sc1200_get_video_palette_entry(unsigned long index,
unsigned long *palette);
int sc1200_get_video_color_key_src(void);
int sc1200_get_video_filter(void);
int sc1200_get_video_request(short *x, short *y);
int sc1200_get_video_source(VideoSourceType * source);
int sc1200_get_vbi_source(VbiSourceType * source);
unsigned long sc1200_get_vbi_lines(int odd);
unsigned long sc1200_get_vbi_total(int odd);
int sc1200_get_video_interlaced(void);
int sc1200_get_color_space_YUV(void);
int sc1200_get_vertical_scaler_offset(char *offset);
unsigned long sc1200_get_genlock_delay(void);
int sc1200_get_genlock_enable(void);
int sc1200_get_video_cursor(unsigned long *key, unsigned long *mask,
unsigned short *select_color2,
unsigned long *color1, unsigned short *color2);
unsigned long sc1200_read_crc(void);
unsigned long sc1200_read_crc32(void);
unsigned long sc1200_read_window_crc(int source, unsigned short x,
unsigned short y, unsigned short width,
unsigned short height, int crc32);
int sc1200_get_macrovision_enable(void);
void sc1200_get_alpha_enable(int *enable);
void sc1200_get_alpha_size(unsigned short *x, unsigned short *y,
unsigned short *width, unsigned short *height);
void sc1200_get_alpha_value(unsigned char *alpha, char *delta);
void sc1200_get_alpha_priority(int *priority);
void sc1200_get_alpha_color(unsigned long *color);
unsigned long sc1200_get_clock_frequency(void);
int sc1200_get_vsa2_softvga_enable(void);
int sc1200_get_sync_polarities(void);
#if GFX_VIDEO_DYNAMIC
void
sc1200_reset_video(void)
#else
void
gfx_reset_video(void)
#endif
{
int i;
gfx_set_video_enable(0);
for (i = 2; i >= 0; i--) {
gfx_select_alpha_region(i);
gfx_set_alpha_enable(0);
gfx_set_alpha_color_enable(0);
}
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_display_control(int sync_polarities)
#else
int
gfx_set_display_control(int sync_polarities)
#endif
{
unsigned long dcfg;
dcfg = READ_VID32(SC1200_DISPLAY_CONFIG);
dcfg &= ~(SC1200_DCFG_CRT_SYNC_SKW_MASK | SC1200_DCFG_PWR_SEQ_DLY_MASK |
SC1200_DCFG_CRT_HSYNC_POL | SC1200_DCFG_CRT_VSYNC_POL |
SC1200_DCFG_FP_PWR_EN | SC1200_DCFG_FP_DATA_EN);
dcfg |= (SC1200_DCFG_CRT_SYNC_SKW_INIT |
SC1200_DCFG_PWR_SEQ_DLY_INIT | SC1200_DCFG_GV_PAL_BYP);
if (PanelEnable)
dcfg |= SC1200_DCFG_FP_PWR_EN;
if (sync_polarities & 0x1)
dcfg |= SC1200_DCFG_CRT_HSYNC_POL;
if (sync_polarities & 0x2)
dcfg |= SC1200_DCFG_CRT_VSYNC_POL;
WRITE_VID32(SC1200_DISPLAY_CONFIG, dcfg);
return (0);
}
#if GFX_VIDEO_DYNAMIC
void
sc1200_set_clock_frequency(unsigned long frequency)
#else
void
gfx_set_clock_frequency(unsigned long frequency)
#endif
{
unsigned int index;
unsigned long value, pll;
long min, diff;
value = gfx_sc1200_clock_table[0].clock_select;
min = (long)gfx_sc1200_clock_table[0].frequency - frequency;
if (min < 0L)
min = -min;
for (index = 1; index < NUM_SC1200_FREQUENCIES; index++) {
diff = (long)gfx_sc1200_clock_table[index].frequency - frequency;
if (diff < 0L)
diff = -diff;
if (diff < min) {
min = diff;
value = gfx_sc1200_clock_table[index].clock_select;
}
}
pll = READ_VID32(SC1200_VID_MISC);
WRITE_VID32(SC1200_VID_MISC, pll | SC1200_PLL_POWER_NORMAL);
WRITE_VID32(SC1200_VID_CLOCK_SELECT, value);
return;
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_screen_enable(int enable)
#else
int
gfx_set_screen_enable(int enable)
#endif
{
unsigned long config;
config = READ_VID32(SC1200_DISPLAY_CONFIG);
if (enable)
WRITE_VID32(SC1200_DISPLAY_CONFIG, config | SC1200_DCFG_DIS_EN);
else
WRITE_VID32(SC1200_DISPLAY_CONFIG, config & ~SC1200_DCFG_DIS_EN);
return (GFX_STATUS_OK);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_crt_enable(int enable)
#else
int
gfx_set_crt_enable(int enable)
#endif
{
unsigned long config, misc;
config = READ_VID32(SC1200_DISPLAY_CONFIG);
misc = READ_VID32(SC1200_VID_MISC);
switch (enable) {
case CRT_DISABLE:
WRITE_VID32(SC1200_DISPLAY_CONFIG, config & ~(SC1200_DCFG_HSYNC_EN
| SC1200_DCFG_VSYNC_EN
| SC1200_DCFG_DAC_BL_EN));
WRITE_VID32(SC1200_VID_MISC, misc | SC1200_DAC_POWER_DOWN);
break;
case CRT_ENABLE:
WRITE_VID32(SC1200_DISPLAY_CONFIG, config | SC1200_DCFG_HSYNC_EN
| SC1200_DCFG_VSYNC_EN | SC1200_DCFG_DAC_BL_EN);
WRITE_VID32(SC1200_VID_MISC, misc & ~SC1200_DAC_POWER_DOWN);
gfx_set_screen_enable(1);
break;
case CRT_STANDBY:
WRITE_VID32(SC1200_DISPLAY_CONFIG, (config & ~(SC1200_DCFG_HSYNC_EN
| SC1200_DCFG_DAC_BL_EN))
| SC1200_DCFG_VSYNC_EN);
WRITE_VID32(SC1200_VID_MISC, misc | SC1200_DAC_POWER_DOWN);
break;
case CRT_SUSPEND:
WRITE_VID32(SC1200_DISPLAY_CONFIG, (config & ~(SC1200_DCFG_VSYNC_EN
| SC1200_DCFG_DAC_BL_EN))
| SC1200_DCFG_HSYNC_EN);
WRITE_VID32(SC1200_VID_MISC, misc | SC1200_DAC_POWER_DOWN);
break;
default:
return GFX_STATUS_BAD_PARAMETER;
}
return (GFX_STATUS_OK);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_enable(int enable)
#else
int
gfx_set_video_enable(int enable)
#endif
{
unsigned long vcfg;
if (gfx_test_timing_active()) {
if (!gfx_test_vertical_active()) {
while (!gfx_test_vertical_active()) ;
}
while (gfx_test_vertical_active()) ;
}
vcfg = READ_VID32(SC1200_VIDEO_CONFIG);
if (enable) {
gfx_set_display_video_enable(1);
vcfg |= SC1200_VCFG_VID_EN;
WRITE_VID32(SC1200_VIDEO_CONFIG, vcfg);
} else {
vcfg &= ~SC1200_VCFG_VID_EN;
WRITE_VID32(SC1200_VIDEO_CONFIG, vcfg);
gfx_set_display_video_enable(0);
}
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_format(unsigned long format)
#else
int
gfx_set_video_format(unsigned long format)
#endif
{
unsigned long ctrl, vcfg = 0;
vcfg = READ_VID32(SC1200_VIDEO_CONFIG);
ctrl = READ_VID32(SC1200_VID_ALPHA_CONTROL);
ctrl &= ~(SC1200_VIDEO_INPUT_IS_RGB);
vcfg &= ~(SC1200_VCFG_VID_INP_FORMAT | SC1200_VCFG_4_2_0_MODE);
switch (format) {
case VIDEO_FORMAT_UYVY:
vcfg |= SC1200_VCFG_UYVY_FORMAT;
break;
case VIDEO_FORMAT_YUYV:
vcfg |= SC1200_VCFG_YUYV_FORMAT;
break;
case VIDEO_FORMAT_Y2YU:
vcfg |= SC1200_VCFG_Y2YU_FORMAT;
break;
case VIDEO_FORMAT_YVYU:
vcfg |= SC1200_VCFG_YVYU_FORMAT;
break;
case VIDEO_FORMAT_Y0Y1Y2Y3:
vcfg |= SC1200_VCFG_UYVY_FORMAT;
vcfg |= SC1200_VCFG_4_2_0_MODE;
break;
case VIDEO_FORMAT_Y3Y2Y1Y0:
vcfg |= SC1200_VCFG_Y2YU_FORMAT;
vcfg |= SC1200_VCFG_4_2_0_MODE;
break;
case VIDEO_FORMAT_Y1Y0Y3Y2:
vcfg |= SC1200_VCFG_YUYV_FORMAT;
vcfg |= SC1200_VCFG_4_2_0_MODE;
break;
case VIDEO_FORMAT_Y1Y2Y3Y0:
vcfg |= SC1200_VCFG_YVYU_FORMAT;
vcfg |= SC1200_VCFG_4_2_0_MODE;
break;
case VIDEO_FORMAT_RGB:
ctrl |= SC1200_VIDEO_INPUT_IS_RGB;
vcfg |= SC1200_VCFG_UYVY_FORMAT;
break;
case VIDEO_FORMAT_P2M_P2L_P1M_P1L:
ctrl |= SC1200_VIDEO_INPUT_IS_RGB;
vcfg |= SC1200_VCFG_Y2YU_FORMAT;
break;
case VIDEO_FORMAT_P1M_P1L_P2M_P2L:
ctrl |= SC1200_VIDEO_INPUT_IS_RGB;
vcfg |= SC1200_VCFG_YUYV_FORMAT;
break;
case VIDEO_FORMAT_P1M_P2L_P2M_P1L:
ctrl |= SC1200_VIDEO_INPUT_IS_RGB;
vcfg |= SC1200_VCFG_YVYU_FORMAT;
break;
default:
return GFX_STATUS_BAD_PARAMETER;
}
ctrl &= ~SC1200_CSC_GFX_RGB_TO_YUV;
if (ctrl & SC1200_VIDEO_INPUT_IS_RGB)
ctrl &= ~SC1200_CSC_VIDEO_YUV_TO_RGB;
else
ctrl |= SC1200_CSC_VIDEO_YUV_TO_RGB;
WRITE_VID32(SC1200_VIDEO_CONFIG, vcfg);
WRITE_VID32(SC1200_VID_ALPHA_CONTROL, ctrl);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_size(unsigned short width, unsigned short height)
#else
int
gfx_set_video_size(unsigned short width, unsigned short height)
#endif
{
unsigned long size, vcfg;
vcfg = READ_VID32(SC1200_VIDEO_CONFIG);
vcfg &= ~(SC1200_VCFG_LINE_SIZE_LOWER_MASK | SC1200_VCFG_LINE_SIZE_UPPER);
size = (width >> 1);
vcfg |= (size & 0x00FF) << 8;
if (size & 0x0100)
vcfg |= SC1200_VCFG_LINE_SIZE_UPPER;
WRITE_VID32(SC1200_VIDEO_CONFIG, vcfg);
gfx_set_display_video_size(width, (unsigned short)(height + 2));
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_offset(unsigned long offset)
#else
int
gfx_set_video_offset(unsigned long offset)
#endif
{
gfx_vid_offset = offset;
gfx_set_display_video_offset(offset);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_upscale(unsigned short srcw, unsigned short srch,
unsigned short dstw, unsigned short dsth)
#else
int
gfx_set_video_upscale(unsigned short srcw, unsigned short srch,
unsigned short dstw, unsigned short dsth)
#endif
{
unsigned long xscale, yscale;
if (dstw != 0) {
gfx_vid_srcw = srcw;
gfx_vid_dstw = dstw;
}
if (dsth != 0) {
gfx_vid_srch = srch;
gfx_vid_dsth = dsth;
}
if (dstw == 0)
xscale = READ_VID32(SC1200_VIDEO_UPSCALE) & 0xffff;
else if (dstw <= srcw)
xscale = 0x2000l;
else if ((srcw == 1) || (dstw == 1))
return GFX_STATUS_BAD_PARAMETER;
else
xscale = (0x2000l * (srcw - 1l)) / (dstw - 1l);
if (dsth == 0)
yscale = (READ_VID32(SC1200_VIDEO_UPSCALE) & 0xffff0000) >> 16;
else if (dsth <= srch)
yscale = 0x2000l;
else if ((srch == 1) || (dsth == 1))
return GFX_STATUS_BAD_PARAMETER;
else
yscale = (0x2000l * (srch - 1l)) / (dsth - 1l);
WRITE_VID32(SC1200_VIDEO_UPSCALE, (yscale << 16) | xscale);
gfx_set_video_window(gfx_vid_xpos, gfx_vid_ypos, gfx_vid_width,
gfx_vid_height);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_scale(unsigned short srcw, unsigned short srch,
unsigned short dstw, unsigned short dsth)
#else
int
gfx_set_video_scale(unsigned short srcw, unsigned short srch,
unsigned short dstw, unsigned short dsth)
#endif
{
return gfx_set_video_upscale(srcw, srch, dstw, dsth);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_downscale_config(unsigned short type, unsigned short m)
#else
int
gfx_set_video_downscale_config(unsigned short type, unsigned short m)
#endif
{
unsigned long downscale;
if ((m < 1) || (m > 16))
return GFX_STATUS_BAD_PARAMETER;
downscale = READ_VID32(SC1200_VIDEO_DOWNSCALER_CONTROL);
downscale &=
~(SC1200_VIDEO_DOWNSCALE_FACTOR_MASK |
SC1200_VIDEO_DOWNSCALE_TYPE_MASK);
downscale |= ((m - 1l) << SC1200_VIDEO_DOWNSCALE_FACTOR_POS);
switch (type) {
case VIDEO_DOWNSCALE_KEEP_1_OF:
downscale |= SC1200_VIDEO_DOWNSCALE_TYPE_A;
break;
case VIDEO_DOWNSCALE_DROP_1_OF:
downscale |= SC1200_VIDEO_DOWNSCALE_TYPE_B;
break;
default:
return GFX_STATUS_BAD_PARAMETER;
}
WRITE_VID32(SC1200_VIDEO_DOWNSCALER_CONTROL, downscale);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_downscale_coefficients(unsigned short coef1,
unsigned short coef2,
unsigned short coef3,
unsigned short coef4)
#else
int
gfx_set_video_downscale_coefficients(unsigned short coef1,
unsigned short coef2,
unsigned short coef3,
unsigned short coef4)
#endif
{
if ((coef1 + coef2 + coef3 + coef4) != 16)
return GFX_STATUS_BAD_PARAMETER;
WRITE_VID32(SC1200_VIDEO_DOWNSCALER_COEFFICIENTS,
((unsigned long)coef1 << SC1200_VIDEO_DOWNSCALER_COEF1_POS) |
((unsigned long)coef2 << SC1200_VIDEO_DOWNSCALER_COEF2_POS) |
((unsigned long)coef3 << SC1200_VIDEO_DOWNSCALER_COEF3_POS) |
((unsigned long)coef4 << SC1200_VIDEO_DOWNSCALER_COEF4_POS));
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_downscale_enable(int enable)
#else
int
gfx_set_video_downscale_enable(int enable)
#endif
{
unsigned long downscale;
downscale = READ_VID32(SC1200_VIDEO_DOWNSCALER_CONTROL);
downscale &= ~SC1200_VIDEO_DOWNSCALE_ENABLE;
if (enable)
downscale |= SC1200_VIDEO_DOWNSCALE_ENABLE;
WRITE_VID32(SC1200_VIDEO_DOWNSCALER_CONTROL, downscale);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_window(short x, short y, unsigned short w, unsigned short h)
#else
int
gfx_set_video_window(short x, short y, unsigned short w, unsigned short h)
#endif
{
unsigned long control;
unsigned long hadjust, vadjust;
unsigned long xstart, ystart, xend, yend;
if (x < 0)
return GFX_STATUS_BAD_PARAMETER;
gfx_vid_xpos = x;
gfx_vid_ypos = y;
gfx_vid_width = w;
gfx_vid_height = h;
hadjust = gfx_get_htotal() - gfx_get_hsync_end() - 14l;
vadjust = gfx_get_vtotal() - gfx_get_vsync_end() + 1l;
xstart = (unsigned long)x + hadjust;
if ((x + w) < gfx_get_hactive())
xend = (unsigned long)x + (unsigned long)w + hadjust;
else
xend = (unsigned long)gfx_get_hactive() + hadjust;
ystart = (unsigned long)y + vadjust;
if ((y + h) < gfx_get_vactive())
yend = (unsigned long)y + (unsigned long)h + vadjust;
else
yend = (unsigned long)gfx_get_vactive() + vadjust;
control = READ_VID32(SC1200_VID_ALPHA_CONTROL);
if (y & 0x1)
WRITE_VID32(SC1200_VID_ALPHA_CONTROL,
control | SC1200_VIDEO_LINE_OFFSET_ODD);
else
WRITE_VID32(SC1200_VID_ALPHA_CONTROL,
control & ~SC1200_VIDEO_LINE_OFFSET_ODD);
WRITE_VID32(SC1200_VIDEO_X_POS, (xend << 16) | xstart);
WRITE_VID32(SC1200_VIDEO_Y_POS, (yend << 16) | ystart);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_left_crop(unsigned short x)
#else
int
gfx_set_video_left_crop(unsigned short x)
#endif
{
unsigned long vcfg, initread;
if (gfx_vid_dstw)
initread = (unsigned long)x *gfx_vid_srcw / gfx_vid_dstw;
else
initread = 0l;
vcfg = READ_VID32(SC1200_VIDEO_CONFIG);
vcfg &= ~SC1200_VCFG_INIT_READ_MASK;
vcfg |= (initread << 15) & SC1200_VCFG_INIT_READ_MASK;
WRITE_VID32(SC1200_VIDEO_CONFIG, vcfg);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_color_key(unsigned long key, unsigned long mask,
int graphics)
#else
int
gfx_set_video_color_key(unsigned long key, unsigned long mask, int graphics)
#endif
{
unsigned long dcfg = 0;
WRITE_VID32(SC1200_VIDEO_COLOR_KEY, key);
WRITE_VID32(SC1200_VIDEO_COLOR_MASK, mask);
dcfg = READ_VID32(SC1200_DISPLAY_CONFIG);
if (graphics & 0x01)
dcfg &= ~SC1200_DCFG_VG_CK;
else
dcfg |= SC1200_DCFG_VG_CK;
WRITE_VID32(SC1200_DISPLAY_CONFIG, dcfg);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_filter(int xfilter, int yfilter)
#else
int
gfx_set_video_filter(int xfilter, int yfilter)
#endif
{
unsigned long vcfg = 0;
vcfg = READ_VID32(SC1200_VIDEO_CONFIG);
vcfg &= ~(SC1200_VCFG_X_FILTER_EN | SC1200_VCFG_Y_FILTER_EN);
if (xfilter)
vcfg |= SC1200_VCFG_X_FILTER_EN;
if (yfilter)
vcfg |= SC1200_VCFG_Y_FILTER_EN;
WRITE_VID32(SC1200_VIDEO_CONFIG, vcfg);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_palette(unsigned long *palette)
#else
int
gfx_set_video_palette(unsigned long *palette)
#endif
{
unsigned long i, entry;
if (gfx_test_timing_active()) {
if (gfx_test_vertical_active()) {
while (gfx_test_vertical_active()) ;
}
while (!gfx_test_vertical_active()) ;
}
WRITE_VID32(SC1200_PALETTE_ADDRESS, 0);
for (i = 0; i < 256; i++) {
if (palette)
entry = palette[i];
else
entry = (i << 8) | (i << 16) | (i << 24);
WRITE_VID32(SC1200_PALETTE_DATA, entry);
}
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_palette_entry(unsigned long index, unsigned long palette)
#else
int
gfx_set_video_palette_entry(unsigned long index, unsigned long palette)
#endif
{
if (index > 0xFF)
return GFX_STATUS_BAD_PARAMETER;
if (gfx_test_timing_active()) {
if (gfx_test_vertical_active()) {
while (gfx_test_vertical_active()) ;
}
while (!gfx_test_vertical_active()) ;
}
WRITE_VID32(SC1200_PALETTE_ADDRESS, index);
WRITE_VID32(SC1200_PALETTE_DATA, palette);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_request(short x, short y)
#else
int
gfx_set_video_request(short x, short y)
#endif
{
x += gfx_get_htotal() - gfx_get_hsync_end() - 2;
y += gfx_get_vtotal() - gfx_get_vsync_end() + 1;
if ((x < 0) || (x > SC1200_VIDEO_REQUEST_MASK) ||
(y < 0) || (y > SC1200_VIDEO_REQUEST_MASK))
return GFX_STATUS_BAD_PARAMETER;
WRITE_VID32(SC1200_VIDEO_REQUEST,
((unsigned long)x << SC1200_VIDEO_X_REQUEST_POS) |
((unsigned long)y << SC1200_VIDEO_Y_REQUEST_POS));
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_source(VideoSourceType source)
#else
int
gfx_set_video_source(VideoSourceType source)
#endif
{
unsigned long display_mode;
display_mode = READ_VID32(SC1200_VIDEO_DISPLAY_MODE);
switch (source) {
case VIDEO_SOURCE_MEMORY:
WRITE_VID32(SC1200_VIDEO_DISPLAY_MODE,
(display_mode & ~SC1200_VIDEO_SOURCE_MASK) |
SC1200_VIDEO_SOURCE_GX1);
break;
case VIDEO_SOURCE_DVIP:
WRITE_VID32(SC1200_VIDEO_DISPLAY_MODE,
(display_mode & ~SC1200_VIDEO_SOURCE_MASK) |
SC1200_VIDEO_SOURCE_DVIP);
break;
default:
return GFX_STATUS_BAD_PARAMETER;
}
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_vbi_source(VbiSourceType source)
#else
int
gfx_set_vbi_source(VbiSourceType source)
#endif
{
unsigned long display_mode;
display_mode = READ_VID32(SC1200_VIDEO_DISPLAY_MODE);
switch (source) {
case VBI_SOURCE_MEMORY:
WRITE_VID32(SC1200_VIDEO_DISPLAY_MODE,
(display_mode & ~SC1200_VBI_SOURCE_MASK) |
SC1200_VBI_SOURCE_GX1);
break;
case VBI_SOURCE_DVIP:
WRITE_VID32(SC1200_VIDEO_DISPLAY_MODE,
(display_mode & ~SC1200_VBI_SOURCE_MASK) |
SC1200_VBI_SOURCE_DVIP);
break;
default:
return GFX_STATUS_BAD_PARAMETER;
}
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_vbi_lines(unsigned long even, unsigned long odd)
#else
int
gfx_set_vbi_lines(unsigned long even, unsigned long odd)
#endif
{
WRITE_VID32(SC1200_VIDEO_EVEN_VBI_LINE_ENABLE,
even & SC1200_VIDEO_VBI_LINE_ENABLE_MASK);
WRITE_VID32(SC1200_VIDEO_ODD_VBI_LINE_ENABLE,
odd & SC1200_VIDEO_VBI_LINE_ENABLE_MASK);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_vbi_total(unsigned long even, unsigned long odd)
#else
int
gfx_set_vbi_total(unsigned long even, unsigned long odd)
#endif
{
WRITE_VID32(SC1200_VIDEO_EVEN_VBI_TOTAL_COUNT,
even & SC1200_VIDEO_VBI_TOTAL_COUNT_MASK);
WRITE_VID32(SC1200_VIDEO_ODD_VBI_TOTAL_COUNT,
odd & SC1200_VIDEO_VBI_TOTAL_COUNT_MASK);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_interlaced(int enable)
#else
int
gfx_set_video_interlaced(int enable)
#endif
{
unsigned long control;
control = READ_VID32(SC1200_VID_ALPHA_CONTROL);
if (enable)
WRITE_VID32(SC1200_VID_ALPHA_CONTROL,
control | SC1200_VIDEO_IS_INTERLACED);
else
WRITE_VID32(SC1200_VID_ALPHA_CONTROL,
control & ~SC1200_VIDEO_IS_INTERLACED);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_color_space_YUV(int enable)
#else
int
gfx_set_color_space_YUV(int enable)
#endif
{
unsigned long control;
control = READ_VID32(SC1200_VID_ALPHA_CONTROL);
if (enable) {
control |= SC1200_CSC_GFX_RGB_TO_YUV;
control &= ~SC1200_CSC_VIDEO_YUV_TO_RGB;
if (control & SC1200_VIDEO_INPUT_IS_RGB)
return (GFX_STATUS_UNSUPPORTED);
} else {
control &= ~SC1200_CSC_GFX_RGB_TO_YUV;
if (control & SC1200_VIDEO_INPUT_IS_RGB)
control &= ~SC1200_CSC_VIDEO_YUV_TO_RGB;
else
control |= SC1200_CSC_VIDEO_YUV_TO_RGB;
}
WRITE_VID32(SC1200_VID_ALPHA_CONTROL, control);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_vertical_scaler_offset(char offset)
#else
int
gfx_set_vertical_scaler_offset(char offset)
#endif
{
unsigned long control;
control = READ_VID32(SC1200_VID_ALPHA_CONTROL);
if (offset == 1) {
control &= ~SC1200_VERTICAL_SCALER_SHIFT_MASK;
control |= SC1200_VERTICAL_SCALER_SHIFT_INIT;
control |= SC1200_VERTICAL_SCALER_SHIFT_EN;
} else if (offset == 0) {
control &= ~SC1200_VERTICAL_SCALER_SHIFT_EN;
control &= ~SC1200_VERTICAL_SCALER_SHIFT_MASK;
} else
return (GFX_STATUS_BAD_PARAMETER);
WRITE_VID32(SC1200_VID_ALPHA_CONTROL, control);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_top_line_in_odd(int enable)
#else
int
gfx_set_top_line_in_odd(int enable)
#endif
{
unsigned long control;
control = READ_VID32(SC1200_VID_ALPHA_CONTROL);
if (enable)
control |= SC1200_TOP_LINE_IN_ODD;
else
control &= ~SC1200_TOP_LINE_IN_ODD;
WRITE_VID32(SC1200_VID_ALPHA_CONTROL, control);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_genlock_delay(unsigned long delay)
#else
int
gfx_set_genlock_delay(unsigned long delay)
#endif
{
WRITE_VID32(SC1200_GENLOCK_DELAY, delay & SC1200_GENLOCK_DELAY_MASK);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_genlock_enable(int flags)
#else
int
gfx_set_genlock_enable(int flags)
#endif
{
unsigned long genlock = 0;
if (flags) {
if (flags & GENLOCK_SINGLE)
genlock |= SC1200_GENLOCK_SINGLE_ENABLE;
if (flags & GENLOCK_FIELD_SYNC)
genlock |= SC1200_GENLOCK_FIELD_SYNC_ENABLE;
if (flags & GENLOCK_CONTINUOUS)
genlock |= SC1200_GENLOCK_CONTINUOUS_ENABLE;
if (flags & GENLOCK_SYNCED_EDGE_FALLING)
genlock |= SC1200_GENLOCK_GX_VSYNC_FALLING_EDGE;
if (flags & GENLOCK_SYNCING_EDGE_FALLING)
genlock |= SC1200_GENLOCK_VIP_VSYNC_FALLING_EDGE;
if (flags & GENLOCK_TIMEOUT)
genlock |= SC1200_GENLOCK_TIMEOUT_ENABLE;
if (flags & GENLOCK_TVENC_RESET_EVEN_FIELD)
genlock |= SC1200_GENLOCK_TVENC_RESET_EVEN_FIELD;
if (flags & GENLOCK_TVENC_RESET_BEFORE_DELAY)
genlock |= SC1200_GENLOCK_TVENC_RESET_BEFORE_DELAY;
if (flags & GENLOCK_TVENC_RESET)
genlock |= SC1200_GENLOCK_TVENC_RESET_ENABLE;
if (flags & GENLOCK_SYNC_TO_TVENC)
genlock |= SC1200_GENLOCK_SYNC_TO_TVENC;
}
WRITE_VID32(SC1200_GENLOCK, genlock);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_video_cursor(unsigned long key, unsigned long mask,
unsigned short select_color2, unsigned long color1,
unsigned long color2)
#else
int
gfx_set_video_cursor(unsigned long key, unsigned long mask,
unsigned short select_color2, unsigned long color1,
unsigned long color2)
#endif
{
if (select_color2 > SC1200_CURSOR_COLOR_BITS)
return GFX_STATUS_BAD_PARAMETER;
key = (key & SC1200_COLOR_MASK) | ((unsigned long)select_color2 <<
SC1200_CURSOR_COLOR_KEY_OFFSET_POS);
WRITE_VID32(SC1200_CURSOR_COLOR_KEY, key);
WRITE_VID32(SC1200_CURSOR_COLOR_MASK, mask);
WRITE_VID32(SC1200_CURSOR_COLOR_1, color1);
WRITE_VID32(SC1200_CURSOR_COLOR_2, color2);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_alpha_enable(int enable)
#else
int
gfx_set_alpha_enable(int enable)
#endif
{
unsigned long address = 0, value = 0;
if (gfx_alpha_select > 2)
return (GFX_STATUS_UNSUPPORTED);
address = SC1200_ALPHA_CONTROL_1 + ((unsigned long)gfx_alpha_select << 4);
value = READ_VID32(address);
if (enable)
value |= (SC1200_ACTRL_WIN_ENABLE | SC1200_ACTRL_LOAD_ALPHA);
else
value &= ~(SC1200_ACTRL_WIN_ENABLE);
WRITE_VID32(address, value);
return (GFX_STATUS_OK);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_alpha_window(short x, short y,
unsigned short width, unsigned short height)
#else
int
gfx_set_alpha_window(short x, short y,
unsigned short width, unsigned short height)
#endif
{
unsigned long address = 0;
if ((x + width) > gfx_get_hactive())
width = gfx_get_hactive() - x;
if ((y + height) > gfx_get_vactive())
height = gfx_get_vactive() - y;
x += gfx_get_htotal() - gfx_get_hsync_end() - 2;
y += gfx_get_vtotal() - gfx_get_vsync_end() + 1;
if (gfx_alpha_select > 2)
return (GFX_STATUS_UNSUPPORTED);
address = SC1200_ALPHA_XPOS_1 + ((unsigned long)gfx_alpha_select << 4);
WRITE_VID32(address, (unsigned long)x |
((unsigned long)(x + width) << 16));
WRITE_VID32(address + 4l, (unsigned long)y |
((unsigned long)(y + height) << 16));
return (GFX_STATUS_OK);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_alpha_value(unsigned char alpha, char delta)
#else
int
gfx_set_alpha_value(unsigned char alpha, char delta)
#endif
{
unsigned long address = 0, value = 0;
unsigned char new_value = 0;
int loop = 1;
if (gfx_alpha_select > 2)
return (GFX_STATUS_UNSUPPORTED);
address = SC1200_ALPHA_CONTROL_1 + ((unsigned long)gfx_alpha_select << 4);
value = READ_VID32(address);
value &= SC1200_ACTRL_WIN_ENABLE;
value |= (unsigned long)alpha;
value |= (((unsigned long)delta) & 0xff) << 8;
value |= SC1200_ACTRL_LOAD_ALPHA;
WRITE_VID32(address, value);
while (1) {
if (gfx_test_timing_active()) {
if (gfx_test_vertical_active())
while (gfx_test_vertical_active()) ;
while (!gfx_test_vertical_active()) ;
}
new_value =
(unsigned
char)((READ_VID32(SC1200_ALPHA_WATCH) >> (gfx_alpha_select << 3))
& 0xff);
if (new_value == alpha)
return GFX_STATUS_OK;
if (++loop > 10)
return GFX_STATUS_ERROR;
WRITE_VID32(address, value);
}
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_alpha_priority(int priority)
#else
int
gfx_set_alpha_priority(int priority)
#endif
{
unsigned long pos = 0, value = 0;
if (priority > 3)
return (GFX_STATUS_BAD_PARAMETER);
if (gfx_alpha_select > 2)
return (GFX_STATUS_UNSUPPORTED);
value = READ_VID32(SC1200_VID_ALPHA_CONTROL);
pos = 16 + (gfx_alpha_select << 1);
value &= ~(0x03l << pos);
value |= (unsigned long)priority << pos;
WRITE_VID32(SC1200_VID_ALPHA_CONTROL, value);
return (GFX_STATUS_OK);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_alpha_color(unsigned long color)
#else
int
gfx_set_alpha_color(unsigned long color)
#endif
{
unsigned long address = 0;
if (gfx_alpha_select > 2)
return (GFX_STATUS_UNSUPPORTED);
address = SC1200_ALPHA_COLOR_1 + ((unsigned long)gfx_alpha_select << 4);
color &= 0xffffffl;
WRITE_VID32(address, (color | (READ_VID32(address) & ~0xffffffl)));
return (GFX_STATUS_OK);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_alpha_color_enable(int enable)
#else
int
gfx_set_alpha_color_enable(int enable)
#endif
{
unsigned long color;
unsigned long address = 0;
if (gfx_alpha_select > 2)
return (GFX_STATUS_UNSUPPORTED);
address = SC1200_ALPHA_COLOR_1 + ((unsigned long)gfx_alpha_select << 4);
color = READ_VID32(address);
if (enable)
color |= SC1200_ALPHA_COLOR_ENABLE;
else
color &= ~SC1200_ALPHA_COLOR_ENABLE;
WRITE_VID32(address, color);
return (GFX_STATUS_OK);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_no_ck_outside_alpha(int enable)
#else
int
gfx_set_no_ck_outside_alpha(int enable)
#endif
{
unsigned long value;
value = READ_VID32(SC1200_VID_ALPHA_CONTROL);
if (enable)
WRITE_VID32(SC1200_VID_ALPHA_CONTROL,
value | SC1200_NO_CK_OUTSIDE_ALPHA);
else
WRITE_VID32(SC1200_VID_ALPHA_CONTROL,
value & ~SC1200_NO_CK_OUTSIDE_ALPHA);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_set_macrovision_enable(int enable)
#else
int
gfx_set_macrovision_enable(int enable)
#endif
{
if (enable)
WRITE_VID32(SC1200_TVENC_MV_CONTROL, SC1200_TVENC_MV_ENABLE);
else
WRITE_VID32(SC1200_TVENC_MV_CONTROL, 0);
return (GFX_STATUS_OK);
}
#define SC1200_VIDEO_PCI_44 0x80009444
#if GFX_VIDEO_DYNAMIC
int
sc1200_disable_softvga(void)
#else
int
gfx_disable_softvga(void)
#endif
{
unsigned long reg_val;
reg_val = gfx_pci_config_read(SC1200_VIDEO_PCI_44);
reg_val |= 0x1;
gfx_pci_config_write(SC1200_VIDEO_PCI_44, reg_val);
reg_val = gfx_pci_config_read(SC1200_VIDEO_PCI_44);
if ((reg_val & 0x1) == 0x1)
return (1);
else
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_enable_softvga(void)
#else
int
gfx_enable_softvga(void)
#endif
{
unsigned long reg_val;
reg_val = gfx_pci_config_read(SC1200_VIDEO_PCI_44);
gfx_pci_config_write(SC1200_VIDEO_PCI_44, reg_val & 0xfffffffel);
reg_val = gfx_pci_config_read(SC1200_VIDEO_PCI_44);
if ((reg_val & 0x1) == 0)
return (1);
else
return (0);
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_clock_frequency(void)
#else
unsigned long
gfx_get_clock_frequency(void)
#endif
{
unsigned int index;
unsigned long value, mask;
mask = 0x007FFF0F;
value = READ_VID32(SC1200_VID_CLOCK_SELECT) & mask;
for (index = 0; index < NUM_SC1200_FREQUENCIES; index++) {
if ((gfx_sc1200_clock_table[index].clock_select & mask) == value)
return (gfx_sc1200_clock_table[index].frequency);
}
return (0);
}
#if GFX_READ_ROUTINES
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_vsa2_softvga_enable(void)
#else
int
gfx_get_vsa2_softvga_enable(void)
#endif
{
unsigned long reg_val;
reg_val = gfx_pci_config_read(SC1200_VIDEO_PCI_44);
if ((reg_val & 0x1) == 0)
return (1);
else
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_sync_polarities(void)
#else
int
gfx_get_sync_polarities(void)
#endif
{
int polarities = 0;
if (READ_VID32(SC1200_DISPLAY_CONFIG) & SC1200_DCFG_CRT_HSYNC_POL)
polarities |= 1;
if (READ_VID32(SC1200_DISPLAY_CONFIG) & SC1200_DCFG_CRT_VSYNC_POL)
polarities |= 2;
return (polarities);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_video_palette_entry(unsigned long index, unsigned long *palette)
#else
int
gfx_get_video_palette_entry(unsigned long index, unsigned long *palette)
#endif
{
if (index > 0xFF)
return GFX_STATUS_BAD_PARAMETER;
WRITE_VID32(SC1200_PALETTE_ADDRESS, index);
*palette = READ_VID32(SC1200_PALETTE_DATA);
return (GFX_STATUS_OK);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_video_enable(void)
#else
int
gfx_get_video_enable(void)
#endif
{
if (READ_VID32(SC1200_VIDEO_CONFIG) & SC1200_VCFG_VID_EN)
return (1);
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_video_format(void)
#else
int
gfx_get_video_format(void)
#endif
{
unsigned long ctrl, vcfg;
ctrl = READ_VID32(SC1200_VID_ALPHA_CONTROL);
vcfg = READ_VID32(SC1200_VIDEO_CONFIG);
if (ctrl & SC1200_VIDEO_INPUT_IS_RGB) {
switch (vcfg & SC1200_VCFG_VID_INP_FORMAT) {
case SC1200_VCFG_UYVY_FORMAT:
return VIDEO_FORMAT_RGB;
case SC1200_VCFG_Y2YU_FORMAT:
return VIDEO_FORMAT_P2M_P2L_P1M_P1L;
case SC1200_VCFG_YUYV_FORMAT:
return VIDEO_FORMAT_P1M_P1L_P2M_P2L;
case SC1200_VCFG_YVYU_FORMAT:
return VIDEO_FORMAT_P1M_P2L_P2M_P1L;
}
}
if (vcfg & SC1200_VCFG_4_2_0_MODE) {
switch (vcfg & SC1200_VCFG_VID_INP_FORMAT) {
case SC1200_VCFG_UYVY_FORMAT:
return VIDEO_FORMAT_Y0Y1Y2Y3;
case SC1200_VCFG_Y2YU_FORMAT:
return VIDEO_FORMAT_Y3Y2Y1Y0;
case SC1200_VCFG_YUYV_FORMAT:
return VIDEO_FORMAT_Y1Y0Y3Y2;
case SC1200_VCFG_YVYU_FORMAT:
return VIDEO_FORMAT_Y1Y2Y3Y0;
}
} else {
switch (vcfg & SC1200_VCFG_VID_INP_FORMAT) {
case SC1200_VCFG_UYVY_FORMAT:
return VIDEO_FORMAT_UYVY;
case SC1200_VCFG_Y2YU_FORMAT:
return VIDEO_FORMAT_Y2YU;
case SC1200_VCFG_YUYV_FORMAT:
return VIDEO_FORMAT_YUYV;
case SC1200_VCFG_YVYU_FORMAT:
return VIDEO_FORMAT_YVYU;
}
}
return (GFX_STATUS_ERROR);
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_video_src_size(void)
#else
unsigned long
gfx_get_video_src_size(void)
#endif
{
unsigned long width = 0, height = 0;
width = (READ_VID32(SC1200_VIDEO_CONFIG) >> 7) & 0x000001FE;
if (READ_VID32(SC1200_VIDEO_CONFIG) & SC1200_VCFG_LINE_SIZE_UPPER)
width += 512l;
if (width) {
height = gfx_get_display_video_size() / (width << 1);
}
return ((height << 16) | width);
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_video_line_size(void)
#else
unsigned long
gfx_get_video_line_size(void)
#endif
{
unsigned long width = 0;
width = (READ_VID32(SC1200_VIDEO_CONFIG) >> 7) & 0x000001FE;
if (READ_VID32(SC1200_VIDEO_CONFIG) & SC1200_VCFG_LINE_SIZE_UPPER)
width += 512l;
return (width);
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_video_xclip(void)
#else
unsigned long
gfx_get_video_xclip(void)
#endif
{
unsigned long clip = 0;
clip = (READ_VID32(SC1200_VIDEO_CONFIG) >> 14) & 0x000007FC;
return (clip);
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_video_offset(void)
#else
unsigned long
gfx_get_video_offset(void)
#endif
{
return (gfx_get_display_video_offset());
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_video_upscale(void)
#else
unsigned long
gfx_get_video_upscale(void)
#endif
{
return (READ_VID32(SC1200_VIDEO_UPSCALE));
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_video_scale(void)
#else
unsigned long
gfx_get_video_scale(void)
#endif
{
return gfx_get_video_upscale();
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_video_downscale_config(unsigned short *type, unsigned short *m)
#else
int
gfx_get_video_downscale_config(unsigned short *type, unsigned short *m)
#endif
{
unsigned long downscale;
downscale = READ_VID32(SC1200_VIDEO_DOWNSCALER_CONTROL);
*m = (unsigned short)((downscale & SC1200_VIDEO_DOWNSCALE_FACTOR_MASK) >>
SC1200_VIDEO_DOWNSCALE_FACTOR_POS) + 1;
switch (downscale & SC1200_VIDEO_DOWNSCALE_TYPE_MASK) {
case SC1200_VIDEO_DOWNSCALE_TYPE_A:
*type = VIDEO_DOWNSCALE_KEEP_1_OF;
break;
case SC1200_VIDEO_DOWNSCALE_TYPE_B:
*type = VIDEO_DOWNSCALE_DROP_1_OF;
break;
default:
return GFX_STATUS_ERROR;
break;
}
return (0);
}
#if GFX_VIDEO_DYNAMIC
void
sc1200_get_video_downscale_coefficients(unsigned short *coef1,
unsigned short *coef2,
unsigned short *coef3,
unsigned short *coef4)
#else
void
gfx_get_video_downscale_coefficients(unsigned short *coef1,
unsigned short *coef2,
unsigned short *coef3,
unsigned short *coef4)
#endif
{
unsigned long coef;
coef = READ_VID32(SC1200_VIDEO_DOWNSCALER_COEFFICIENTS);
*coef1 =
(unsigned short)((coef >> SC1200_VIDEO_DOWNSCALER_COEF1_POS) &
SC1200_VIDEO_DOWNSCALER_COEF_MASK);
*coef2 =
(unsigned short)((coef >> SC1200_VIDEO_DOWNSCALER_COEF2_POS) &
SC1200_VIDEO_DOWNSCALER_COEF_MASK);
*coef3 =
(unsigned short)((coef >> SC1200_VIDEO_DOWNSCALER_COEF3_POS) &
SC1200_VIDEO_DOWNSCALER_COEF_MASK);
*coef4 =
(unsigned short)((coef >> SC1200_VIDEO_DOWNSCALER_COEF4_POS) &
SC1200_VIDEO_DOWNSCALER_COEF_MASK);
return;
}
#if GFX_VIDEO_DYNAMIC
void
sc1200_get_video_downscale_enable(int *enable)
#else
void
gfx_get_video_downscale_enable(int *enable)
#endif
{
if (READ_VID32(SC1200_VIDEO_DOWNSCALER_CONTROL) &
SC1200_VIDEO_DOWNSCALE_ENABLE)
*enable = 1;
else
*enable = 0;
return;
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_video_dst_size(void)
#else
unsigned long
gfx_get_video_dst_size(void)
#endif
{
unsigned long xsize, ysize;
xsize = READ_VID32(SC1200_VIDEO_X_POS);
xsize = ((xsize >> 16) & 0x7FF) - (xsize & 0x7FF);
ysize = READ_VID32(SC1200_VIDEO_Y_POS);
ysize = ((ysize >> 16) & 0x7FF) - (ysize & 0x7FF);
return ((ysize << 16) | xsize);
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_video_position(void)
#else
unsigned long
gfx_get_video_position(void)
#endif
{
unsigned long hadjust, vadjust;
unsigned long xpos, ypos;
xpos = READ_VID32(SC1200_VIDEO_X_POS) & 0x000007FF;
ypos = READ_VID32(SC1200_VIDEO_Y_POS) & 0x000007FF;
hadjust =
(unsigned long)gfx_get_htotal() -
(unsigned long)gfx_get_hsync_end() - 14l;
vadjust =
(unsigned long)gfx_get_vtotal() -
(unsigned long)gfx_get_vsync_end() + 1l;
xpos -= hadjust;
ypos -= vadjust;
return ((ypos << 16) | (xpos & 0x0000FFFF));
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_video_color_key(void)
#else
unsigned long
gfx_get_video_color_key(void)
#endif
{
return (READ_VID32(SC1200_VIDEO_COLOR_KEY));
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_video_color_key_mask(void)
#else
unsigned long
gfx_get_video_color_key_mask(void)
#endif
{
return (READ_VID32(SC1200_VIDEO_COLOR_MASK));
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_video_color_key_src(void)
#else
int
gfx_get_video_color_key_src(void)
#endif
{
if (READ_VID32(SC1200_DISPLAY_CONFIG) & SC1200_DCFG_VG_CK)
return (0);
return (1);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_video_filter(void)
#else
int
gfx_get_video_filter(void)
#endif
{
int retval = 0;
if (READ_VID32(SC1200_VIDEO_CONFIG) & SC1200_VCFG_X_FILTER_EN)
retval |= 1;
if (READ_VID32(SC1200_VIDEO_CONFIG) & SC1200_VCFG_Y_FILTER_EN)
retval |= 2;
return (retval);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_video_request(short *x, short *y)
#else
int
gfx_get_video_request(short *x, short *y)
#endif
{
int request = 0;
request = (int)(READ_VID32(SC1200_VIDEO_REQUEST));
*x = (request >> SC1200_VIDEO_X_REQUEST_POS) & SC1200_VIDEO_REQUEST_MASK;
*y = (request >> SC1200_VIDEO_Y_REQUEST_POS) & SC1200_VIDEO_REQUEST_MASK;
*x -= gfx_get_htotal() - gfx_get_hsync_end() - 2;
*y -= gfx_get_vtotal() - gfx_get_vsync_end() + 1;
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_video_source(VideoSourceType * source)
#else
int
gfx_get_video_source(VideoSourceType * source)
#endif
{
switch (READ_VID32(SC1200_VIDEO_DISPLAY_MODE) & SC1200_VIDEO_SOURCE_MASK) {
case SC1200_VIDEO_SOURCE_GX1:
*source = VIDEO_SOURCE_MEMORY;
break;
case SC1200_VIDEO_SOURCE_DVIP:
*source = VIDEO_SOURCE_DVIP;
break;
default:
return GFX_STATUS_ERROR;
}
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_vbi_source(VbiSourceType * source)
#else
int
gfx_get_vbi_source(VbiSourceType * source)
#endif
{
switch (READ_VID32(SC1200_VIDEO_DISPLAY_MODE) & SC1200_VBI_SOURCE_MASK) {
case SC1200_VBI_SOURCE_GX1:
*source = VBI_SOURCE_MEMORY;
break;
case SC1200_VBI_SOURCE_DVIP:
*source = VBI_SOURCE_DVIP;
break;
default:
return GFX_STATUS_ERROR;
}
return (0);
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_vbi_lines(int odd)
#else
unsigned long
gfx_get_vbi_lines(int odd)
#endif
{
if (odd)
return (READ_VID32(SC1200_VIDEO_ODD_VBI_LINE_ENABLE) &
SC1200_VIDEO_VBI_LINE_ENABLE_MASK);
return (READ_VID32(SC1200_VIDEO_EVEN_VBI_LINE_ENABLE) &
SC1200_VIDEO_VBI_LINE_ENABLE_MASK);
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_vbi_total(int odd)
#else
unsigned long
gfx_get_vbi_total(int odd)
#endif
{
if (odd)
return (READ_VID32(SC1200_VIDEO_ODD_VBI_TOTAL_COUNT) &
SC1200_VIDEO_VBI_TOTAL_COUNT_MASK);
return (READ_VID32(SC1200_VIDEO_EVEN_VBI_TOTAL_COUNT) &
SC1200_VIDEO_VBI_TOTAL_COUNT_MASK);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_video_interlaced(void)
#else
int
gfx_get_video_interlaced(void)
#endif
{
if (READ_VID32(SC1200_VID_ALPHA_CONTROL) & SC1200_VIDEO_IS_INTERLACED)
return (1);
else
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_color_space_YUV(void)
#else
int
gfx_get_color_space_YUV(void)
#endif
{
unsigned long control;
control = READ_VID32(SC1200_VID_ALPHA_CONTROL);
if ((control & SC1200_VIDEO_INPUT_IS_RGB)
|| (control & SC1200_CSC_VIDEO_YUV_TO_RGB))
return (0);
else
return (1);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_vertical_scaler_offset(char *offset)
#else
int
gfx_get_vertical_scaler_offset(char *offset)
#endif
{
unsigned long control;
control = READ_VID32(SC1200_VID_ALPHA_CONTROL);
if (control & SC1200_VERTICAL_SCALER_SHIFT_EN) {
if ((control & SC1200_VERTICAL_SCALER_SHIFT_MASK) ==
SC1200_VERTICAL_SCALER_SHIFT_INIT)
*offset = 1;
else
return GFX_STATUS_ERROR;
} else
*offset = 0;
return (0);
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_get_genlock_delay(void)
#else
unsigned long
gfx_get_genlock_delay(void)
#endif
{
return (READ_VID32(SC1200_GENLOCK_DELAY) & SC1200_GENLOCK_DELAY_MASK);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_genlock_enable(void)
#else
int
gfx_get_genlock_enable(void)
#endif
{
if (READ_VID32(SC1200_GENLOCK) &
(SC1200_GENLOCK_SINGLE_ENABLE | SC1200_GENLOCK_CONTINUOUS_ENABLE))
return (1);
else
return (0);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_video_cursor(unsigned long *key, unsigned long *mask,
unsigned short *select_color2, unsigned long *color1,
unsigned short *color2)
#else
int
gfx_get_video_cursor(unsigned long *key, unsigned long *mask,
unsigned short *select_color2, unsigned long *color1,
unsigned short *color2)
#endif
{
*select_color2 =
(unsigned short)(READ_VID32(SC1200_CURSOR_COLOR_KEY) >>
SC1200_CURSOR_COLOR_KEY_OFFSET_POS);
*key = READ_VID32(SC1200_CURSOR_COLOR_KEY) & SC1200_COLOR_MASK;
*mask = READ_VID32(SC1200_CURSOR_COLOR_MASK) & SC1200_COLOR_MASK;
*color1 = READ_VID32(SC1200_CURSOR_COLOR_1) & SC1200_COLOR_MASK;
*color2 =
(unsigned short)(READ_VID32(SC1200_CURSOR_COLOR_2) &
SC1200_COLOR_MASK);
return (0);
}
#if GFX_VIDEO_DYNAMIC
unsigned long
sc1200_read_crc(void)
#else
unsigned long
gfx_read_crc(void)
#endif
{
unsigned long crc = 0xFFFFFFFF;
if (gfx_test_timing_active()) {
while (!gfx_test_vertical_active()) ;
WRITE_VID32(SC1200_VID_CRC, 0);
WRITE_VID32(SC1200_VID_CRC, 1);
while (gfx_test_vertical_active()) ;
while (!gfx_test_vertical_active()) ;
while (gfx_test_vertical_active()) ;
while (!gfx_test_vertical_active()) ;
crc = READ_VID32(SC1200_VID_CRC) >> 8;
}
return (crc);
}
#if GFX_VIDEO_DYNAMIC
int
sc1200_get_macrovision_enable(void)
#else
int
gfx_get_macrovision_enable(void)
#endif
{
if (READ_VID32(SC1200_TVENC_MV_CONTROL) == SC1200_TVENC_MV_ENABLE)
return (1);
return (0);
}
#if GFX_VIDEO_DYNAMIC
void
sc1200_get_alpha_enable(int *enable)
#else
void
gfx_get_alpha_enable(int *enable)
#endif
{
unsigned long value = 0;
*enable = 0;
if (gfx_alpha_select <= 2) {
value =
READ_VID32(SC1200_ALPHA_CONTROL_1 +
((unsigned long)gfx_alpha_select << 4));
if (value & SC1200_ACTRL_WIN_ENABLE)
*enable = 1;
}
return;
}
#if GFX_VIDEO_DYNAMIC
void
sc1200_get_alpha_size(unsigned short *x, unsigned short *y,
unsigned short *width, unsigned short *height)
#else
void
gfx_get_alpha_size(unsigned short *x, unsigned short *y,
unsigned short *width, unsigned short *height)
#endif
{
unsigned long value = 0;
*x = 0;
*y = 0;
*width = 0;
*height = 0;
if (gfx_alpha_select <= 2) {
value =
READ_VID32(SC1200_ALPHA_XPOS_1 +
((unsigned long)gfx_alpha_select << 4));
*x = (unsigned short)(value & 0x000007FF);
*width = (unsigned short)((value >> 16) & 0x000007FF) - *x;
value =
READ_VID32(SC1200_ALPHA_YPOS_1 +
((unsigned long)gfx_alpha_select << 4));
*y = (unsigned short)(value & 0x000007FF);
*height = (unsigned short)((value >> 16) & 0x000007FF) - *y;
}
*x -= gfx_get_htotal() - gfx_get_hsync_end() - 2;
*y -= gfx_get_vtotal() - gfx_get_vsync_end() + 1;
return;
}
#if GFX_VIDEO_DYNAMIC
void
sc1200_get_alpha_value(unsigned char *alpha, char *delta)
#else
void
gfx_get_alpha_value(unsigned char *alpha, char *delta)
#endif
{
unsigned long value = 0;
*alpha = 0;
*delta = 0;
if (gfx_alpha_select <= 2) {
value =
READ_VID32(SC1200_ALPHA_CONTROL_1 +
((unsigned long)gfx_alpha_select << 4));
*alpha = (unsigned char)(value & 0x00FF);
*delta = (char)((value >> 8) & 0x00FF);
}
return;
}
#if GFX_VIDEO_DYNAMIC
void
sc1200_get_alpha_priority(int *priority)
#else
void
gfx_get_alpha_priority(int *priority)
#endif
{
unsigned long pos = 0, value = 0;
*priority = 0;
if (gfx_alpha_select <= 2) {
value = READ_VID32(SC1200_VID_ALPHA_CONTROL);
pos = 16 + (gfx_alpha_select << 1);
*priority = (int)((value >> pos) & 3);
}
return;
}
#if GFX_VIDEO_DYNAMIC
void
sc1200_get_alpha_color(unsigned long *color)
#else
void
gfx_get_alpha_color(unsigned long *color)
#endif
{
*color = 0;
if (gfx_alpha_select <= 2) {
*color =
READ_VID32(SC1200_ALPHA_COLOR_1 +
((unsigned long)gfx_alpha_select << 4));
}
return;
}
#endif