void gu1_enable_compression(void);
void gu1_disable_compression(void);
void gfx_reset_video(void);
int gfx_set_display_control(int sync_polarities);
void gu1_delay_approximate(unsigned long milliseconds);
void gu1_delay_precise(unsigned long milliseconds);
int gu1_set_display_bpp(unsigned short bpp);
int gu1_is_display_mode_supported(int xres, int yres, int bpp, int hz);
int gu1_set_display_mode(int xres, int yres, int bpp, int hz);
int gu1_set_display_timings(unsigned short bpp, unsigned short flags,
unsigned short hactive,
unsigned short hblank_start,
unsigned short hsync_start,
unsigned short hsync_end,
unsigned short hblank_end, unsigned short htotal,
unsigned short vactive,
unsigned short vblank_start,
unsigned short vsync_start,
unsigned short vsync_end,
unsigned short vblank_end, unsigned short vtotal,
unsigned long frequency);
int gu1_set_vtotal(unsigned short vtotal);
void gu1_set_display_pitch(unsigned short pitch);
void gu1_set_display_offset(unsigned long offset);
int gu1_set_display_palette_entry(unsigned long index, unsigned long palette);
int gu1_set_display_palette(unsigned long *palette);
void gu1_video_shutdown(void);
void gu1_set_clock_frequency(unsigned long frequency);
int gu1_set_crt_enable(int enable);
void gu1_set_cursor_enable(int enable);
void gu1_set_cursor_colors(unsigned long bkcolor, unsigned long fgcolor);
void gu1_set_cursor_position(unsigned long memoffset,
unsigned short xpos, unsigned short ypos,
unsigned short xhotspot,
unsigned short yhotspot);
void gu1_set_cursor_shape32(unsigned long memoffset, unsigned long *andmask,
unsigned long *xormask);
void gu1_set_cursor_shape64(unsigned long memoffset, unsigned long *andmask,
unsigned long *xormask);
void gu1_set_icon_enable(int enable);
void gu1_set_icon_colors(unsigned long color0, unsigned long color1,
unsigned long color2);
void gu1_set_icon_position(unsigned long memoffset, unsigned short xpos);
void gu1_set_icon_shape64(unsigned long memoffset, unsigned long *andmask,
unsigned long *xormask, unsigned int lines);
int gu1_set_compression_enable(int enable);
int gu1_set_compression_offset(unsigned long offset);
int gu1_set_compression_pitch(unsigned short pitch);
int gu1_set_compression_size(unsigned short size);
void gu1_set_display_priority_high(int enable);
int gu1_test_timing_active(void);
int gu1_test_vertical_active(void);
int gu1_wait_vertical_blank(void);
void gu1_delay_milliseconds(unsigned long milliseconds);
void gu1_delay_microseconds(unsigned long microseconds);
void gu1_enable_panning(int x, int y);
int gu1_set_fixed_timings(int panelResX, int panelResY, unsigned short width,
unsigned short height, unsigned short bpp);
int gu1_set_panel_present(int panelResX, int panelResY, unsigned short width,
unsigned short height, unsigned short bpp);
void gu1_reset_timing_lock(void);
int gu1_get_display_details(unsigned int mode, int *xres, int *yres, int *hz);
unsigned short gu1_get_display_pitch(void);
int gu1_get_vsa2_softvga_enable(void);
int gu1_get_sync_polarities(void);
unsigned long gu1_get_clock_frequency(void);
unsigned long gu1_get_max_supported_pixel_clock(void);
int gu1_mode_frequency_supported(int xres, int yres, int bpp,
unsigned long frequency);
int gu1_get_refreshrate_from_frequency(int xres, int yres, int bpp, int *hz,
unsigned long frequency);
int gu1_get_refreshrate_from_mode(int xres, int yres, int bpp, int *hz,
unsigned long frequency);
int gu1_get_frequency_from_refreshrate(int xres, int yres, int bpp, int hz,
int *frequency);
int gu1_get_display_mode_count(void);
int gu1_get_display_mode(int *xres, int *yres, int *bpp, int *hz);
unsigned long gu1_get_frame_buffer_line_size(void);
unsigned short gu1_get_hactive(void);
unsigned short gu1_get_hblank_start(void);
unsigned short gu1_get_hsync_start(void);
unsigned short gu1_get_hsync_end(void);
unsigned short gu1_get_hblank_end(void);
unsigned short gu1_get_htotal(void);
unsigned short gu1_get_vactive(void);
unsigned short gu1_get_vline(void);
unsigned short gu1_get_vblank_start(void);
unsigned short gu1_get_vsync_start(void);
unsigned short gu1_get_vsync_end(void);
unsigned short gu1_get_vblank_end(void);
unsigned short gu1_get_vtotal(void);
unsigned short gu1_get_display_bpp(void);
unsigned long gu1_get_display_offset(void);
int gu1_get_display_palette_entry(unsigned long index,
unsigned long *palette);
void gu1_get_display_palette(unsigned long *palette);
unsigned long gu1_get_cursor_enable(void);
unsigned long gu1_get_cursor_offset(void);
unsigned long gu1_get_cursor_position(void);
unsigned long gu1_get_cursor_clip(void);
unsigned long gu1_get_cursor_color(int color);
unsigned long gu1_get_icon_enable(void);
unsigned long gu1_get_icon_offset(void);
unsigned long gu1_get_icon_position(void);
unsigned long gu1_get_icon_color(int color);
int gu1_get_compression_enable(void);
unsigned long gu1_get_compression_offset(void);
unsigned short gu1_get_compression_pitch(void);
unsigned short gu1_get_compression_size(void);
int gu1_get_display_priority_high(void);
int gu1_get_valid_bit(int line);
void gu1_set_display_video_enable(int enable);
int gu1_set_specified_mode(DISPLAYMODE * pMode, int bpp);
void gu1_set_display_video_size(unsigned short width, unsigned short height);
void gu1_set_display_video_offset(unsigned long offset);
unsigned long gu1_get_display_video_offset(void);
unsigned long gu1_get_display_video_size(void);
unsigned long vid_buf_size = 0;
int vid_enabled = 0;
void
gu1_delay_approximate(unsigned long milliseconds)
{
# define READS_PER_MILLISECOND 60000L
unsigned long loop;
loop = milliseconds * READS_PER_MILLISECOND;
while (loop-- > 0) {
READ_REG32(DC_UNLOCK);
}
}
void
gu1_delay_precise(unsigned long milliseconds)
{
#if GFX_VIDEO_SC1200
#define LOOP 1000
unsigned long i, timer_start, timer_end, total_ticks, previous_ticks,
temp_ticks;
timer_start = IND(SC1200_CB_BASE_ADDR + SC1200_CB_TMVALUE);
if (INB(SC1200_CB_BASE_ADDR + SC1200_CB_TMCNFG) & SC1200_TMCLKSEL_27MHZ)
total_ticks = 27000 * milliseconds;
else
total_ticks = 1000 * milliseconds;
if (total_ticks > ((unsigned long)0xffffffff - timer_start))
timer_end = total_ticks - ((unsigned long)0xffffffff - timer_start);
else
timer_end = timer_start + total_ticks;
if (timer_end < timer_start) {
previous_ticks = timer_start;
while (1) {
temp_ticks = IND(SC1200_CB_BASE_ADDR + SC1200_CB_TMVALUE);
if (temp_ticks < previous_ticks)
break;
else
previous_ticks = temp_ticks;
for (i = 0; i < LOOP; i++)
READ_REG32(DC_UNLOCK);
}
}
while (1) {
for (i = 0; i < LOOP; i++)
READ_REG32(DC_UNLOCK);
if (IND(SC1200_CB_BASE_ADDR + SC1200_CB_TMVALUE) > timer_end)
break;
}
#endif
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_delay_milliseconds(unsigned long milliseconds)
#else
void
gfx_delay_milliseconds(unsigned long milliseconds)
#endif
{
#if GFX_VIDEO_SC1200
#if GFX_VIDEO_DYNAMIC
if (gfx_video_type == GFX_VIDEO_TYPE_SC1200) {
#endif
gu1_delay_precise(milliseconds);
return;
#if GFX_VIDEO_DYNAMIC
}
#endif
#endif
gu1_delay_approximate(milliseconds);
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_delay_microseconds(unsigned long microseconds)
#else
void
gfx_delay_microseconds(unsigned long microseconds)
#endif
{
unsigned long loop_count = microseconds * 150;
while (loop_count-- > 0) {
;
}
}
void
gu1_video_shutdown(void)
{
unsigned long unlock;
unsigned long gcfg, tcfg;
gu1_disable_compression();
gfx_reset_video();
gfx_delay_milliseconds(1);
unlock = READ_REG32(DC_UNLOCK);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
gcfg = READ_REG32(DC_GENERAL_CFG);
tcfg = READ_REG32(DC_TIMING_CFG);
tcfg &= ~((unsigned long)DC_TCFG_BLKE | (unsigned long)DC_TCFG_TGEN);
WRITE_REG32(DC_TIMING_CFG, tcfg);
gfx_delay_milliseconds(1);
gcfg &= ~(unsigned long)(DC_GCFG_DFLE | DC_GCFG_CMPE | DC_GCFG_DECE);
WRITE_REG32(DC_GENERAL_CFG, gcfg);
WRITE_REG32(DC_UNLOCK, unlock);
return;
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_display_bpp(unsigned short bpp)
#else
int
gfx_set_display_bpp(unsigned short bpp)
#endif
{
unsigned long ocfg, lock;
lock = READ_REG32(DC_UNLOCK);
ocfg = READ_REG32(DC_OUTPUT_CFG) & ~(DC_OCFG_8BPP | DC_OCFG_555);
if (bpp == 8)
ocfg |= DC_OCFG_8BPP;
else if (bpp == 15)
ocfg |= DC_OCFG_555;
else if (bpp != 16)
return GFX_STATUS_BAD_PARAMETER;
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
WRITE_REG32(DC_OUTPUT_CFG, ocfg);
WRITE_REG32(DC_UNLOCK, lock);
gfx_set_bpp(bpp);
return 0;
}
int
gu1_set_specified_mode(DISPLAYMODE * pMode, int bpp)
{
unsigned long unlock, value;
unsigned long gcfg, tcfg, ocfg;
unsigned long size, pitch;
unsigned long vid_buffer_size;
unsigned long hactive, vactive;
gbpp = bpp;
if (gfx_timing_lock && !(pMode->flags & GFX_MODE_LOCK_TIMING))
return GFX_STATUS_ERROR;
if (pMode->flags & GFX_MODE_LOCK_TIMING)
gfx_timing_lock = 1;
gu1_disable_compression();
gfx_reset_video();
unlock = READ_REG32(DC_UNLOCK);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
gcfg = READ_REG32(DC_GENERAL_CFG);
tcfg = READ_REG32(DC_TIMING_CFG);
tcfg &= ~((unsigned long)DC_TCFG_BLKE | (unsigned long)DC_TCFG_TGEN);
WRITE_REG32(DC_TIMING_CFG, tcfg);
gfx_delay_milliseconds(1);
gcfg &= ~(unsigned long)(DC_GCFG_DFLE | DC_GCFG_CMPE | DC_GCFG_DECE);
WRITE_REG32(DC_GENERAL_CFG, gcfg);
gcfg &= ~(unsigned long)(DC_GCFG_DDCK | DC_GCFG_DPCK | DC_GCFG_DFCK);
gcfg &= ~(unsigned long)DC_GCFG_DCLK_MASK;
WRITE_REG32(DC_GENERAL_CFG, gcfg);
gfx_set_clock_frequency(pMode->frequency & 0x7FFFFFFF);
gfx_delay_milliseconds(1);
if (pMode->frequency & 0x80000000)
gcfg |= 0x0040;
else
gcfg |= 0x0080;
WRITE_REG32(DC_GENERAL_CFG, gcfg);
gfx_delay_milliseconds(1);
gfx_delay_milliseconds(1);
gfx_delay_milliseconds(1);
gfx_delay_milliseconds(1);
gfx_delay_milliseconds(1);
gfx_delay_milliseconds(1);
WRITE_REG32(DC_FB_ST_OFFSET, 0);
WRITE_REG32(DC_CB_ST_OFFSET, 0);
WRITE_REG32(DC_CURS_ST_OFFSET, 0);
if (PanelEnable)
size = ModeWidth;
else
size = pMode->hactive;
if (bpp > 8)
size <<= 1;
if (size <= 1024) {
pitch = 1024;
if ((pMode->flags & GFX_MODE_LINE_DOUBLE) && bpp > 8)
pitch <<= 1;
} else {
if (gfx_cpu_version == GFX_CPU_PYRAMID)
pitch = (size <= 2048) ? 2048 : 4096;
else
pitch = 2048;
}
WRITE_REG32(DC_LINE_DELTA, pitch >> 2);
if (PanelEnable) {
size = pMode->hactive;
if (bpp > 8)
size <<= 1;
}
vid_buffer_size = READ_REG32(DC_BUF_SIZE) & 0x3FFF0000;
WRITE_REG32(DC_BUF_SIZE, ((size >> 3) + 2) | vid_buffer_size);
ocfg = DC_OCFG_PCKE | DC_OCFG_PDEL | DC_OCFG_PDEH;
if (bpp == 8)
ocfg |= DC_OCFG_8BPP;
else if (bpp == 15)
ocfg |= DC_OCFG_555;
tcfg = DC_TCFG_FPPE | DC_TCFG_HSYE | DC_TCFG_VSYE | DC_TCFG_BLKE |
DC_TCFG_TGEN;
gcfg = (6 << DC_GCFG_DFHPEL_POS) | (5 << DC_GCFG_DFHPSL_POS) |
DC_GCFG_DFLE;
if (pMode->hactive == 1280 && pMode->vactive == 1024) {
if ((bpp == 8) && (pMode->flags & GFX_MODE_85HZ))
gcfg = (8l << DC_GCFG_DFHPEL_POS) | (7l << DC_GCFG_DFHPSL_POS) |
DC_GCFG_DFLE;
if ((bpp > 8) && (pMode->flags & GFX_MODE_75HZ))
gcfg = (7l << DC_GCFG_DFHPEL_POS) | (6l << DC_GCFG_DFHPSL_POS) |
DC_GCFG_DFLE;
if ((bpp > 8) && (pMode->flags & GFX_MODE_85HZ))
gcfg = (9l << DC_GCFG_DFHPEL_POS) | (8l << DC_GCFG_DFHPSL_POS) |
DC_GCFG_DFLE;
}
if (pMode->frequency & 0x80000000)
gcfg |= (1l << DC_GCFG_DCLK_POS);
else
gcfg |= (2l << DC_GCFG_DCLK_POS);
if (gfx_cpu_frequency > 266)
gcfg |= DC_GCFG_VCLK_DIV;
hactive = pMode->hactive;
vactive = pMode->vactive;
gfx_line_double = 0;
gfx_pixel_double = 0;
if (pMode->flags & GFX_MODE_LINE_DOUBLE) {
gcfg |= DC_GCFG_LDBL;
hactive <<= 1;
gfx_line_double = 1;
}
if (pMode->flags & GFX_MODE_PIXEL_DOUBLE) {
tcfg |= DC_TCFG_PXDB;
vactive <<= 1;
gfx_pixel_double = 1;
}
value = (unsigned long)(hactive - 1) |
(((unsigned long)(pMode->htotal - 1)) << 16);
WRITE_REG32(DC_H_TIMING_1, value);
value = (unsigned long)(pMode->hblankstart - 1) |
(((unsigned long)(pMode->hblankend - 1)) << 16);
WRITE_REG32(DC_H_TIMING_2, value);
value = (unsigned long)(pMode->hsyncstart - 1) |
(((unsigned long)(pMode->hsyncend - 1)) << 16);
WRITE_REG32(DC_H_TIMING_3, value);
WRITE_REG32(DC_FP_H_TIMING, value);
value = (unsigned long)(vactive - 1) |
(((unsigned long)(pMode->vtotal - 1)) << 16);
WRITE_REG32(DC_V_TIMING_1, value);
value = (unsigned long)(pMode->vblankstart - 1) |
(((unsigned long)(pMode->vblankend - 1)) << 16);
WRITE_REG32(DC_V_TIMING_2, value);
value = (unsigned long)(pMode->vsyncstart - 1) |
(((unsigned long)(pMode->vsyncend - 1)) << 16);
WRITE_REG32(DC_V_TIMING_3, value);
value = (unsigned long)(pMode->vsyncstart - 2) |
(((unsigned long)(pMode->vsyncend - 2)) << 16);
WRITE_REG32(DC_FP_V_TIMING, value);
WRITE_REG32(DC_OUTPUT_CFG, ocfg);
WRITE_REG32(DC_TIMING_CFG, tcfg);
gfx_delay_milliseconds(1);
WRITE_REG32(DC_GENERAL_CFG, gcfg);
if (PanelEnable) {
if (ModeWidth < PanelWidth) {
tcfg = READ_REG32(DC_TIMING_CFG);
tcfg = tcfg | DC_TCFG_FCEN;
WRITE_REG32(DC_TIMING_CFG, tcfg);
gfx_delay_milliseconds(1);
}
}
gfx_set_display_control(((pMode->flags & GFX_MODE_NEG_HSYNC) ? 1 : 0) |
((pMode->flags & GFX_MODE_NEG_VSYNC) ? 2 : 0));
WRITE_REG32(DC_UNLOCK, unlock);
value = 0;
if (bpp > 8)
value |= BC_16BPP;
if ((gfx_cpu_version == GFX_CPU_PYRAMID) && (pitch > 2048))
value |= BC_FB_WIDTH_4096;
else if (pitch > 1024)
value |= BC_FB_WIDTH_2048;
WRITE_REG16(GP_BLIT_STATUS, (unsigned short)value);
return GFX_STATUS_OK;
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_is_display_mode_supported(int xres, int yres, int bpp, int hz)
#else
int
gfx_is_display_mode_supported(int xres, int yres, int bpp, int hz)
#endif
{
unsigned int mode = 0;
unsigned long hz_flag = 0, bpp_flag = 0;
if (hz == 56)
hz_flag = GFX_MODE_56HZ;
else if (hz == 60)
hz_flag = GFX_MODE_60HZ;
else if (hz == 70)
hz_flag = GFX_MODE_70HZ;
else if (hz == 72)
hz_flag = GFX_MODE_72HZ;
else if (hz == 75)
hz_flag = GFX_MODE_75HZ;
else if (hz == 85)
hz_flag = GFX_MODE_85HZ;
else
return -1;
if (bpp == 8)
bpp_flag = GFX_MODE_8BPP;
else if (bpp == 15)
bpp_flag = GFX_MODE_15BPP;
else if (bpp == 16)
bpp_flag = GFX_MODE_16BPP;
else
return -1;
if (gfx_cpu_version != GFX_CPU_PYRAMID && xres > 1024) {
if (bpp > 8)
return (-1);
}
for (mode = 0; mode < NUM_GX_DISPLAY_MODES; mode++) {
if ((DisplayParams[mode].hactive == (unsigned short)xres) &&
(DisplayParams[mode].vactive == (unsigned short)yres) &&
(DisplayParams[mode].flags & hz_flag) &&
(DisplayParams[mode].flags & bpp_flag)) {
return (mode);
}
}
return (-1);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_display_mode(int xres, int yres, int bpp, int hz)
#else
int
gfx_set_display_mode(int xres, int yres, int bpp, int hz)
#endif
{
int mode;
PanelEnable = 0;
mode = gfx_is_display_mode_supported(xres, yres, bpp, hz);
if (mode >= 0) {
if (gu1_set_specified_mode(&DisplayParams[mode], bpp) == GFX_STATUS_OK)
return (1);
}
return (0);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_display_timings(unsigned short bpp, unsigned short flags,
unsigned short hactive, unsigned short hblankstart,
unsigned short hsyncstart, unsigned short hsyncend,
unsigned short hblankend, unsigned short htotal,
unsigned short vactive, unsigned short vblankstart,
unsigned short vsyncstart, unsigned short vsyncend,
unsigned short vblankend, unsigned short vtotal,
unsigned long frequency)
#else
int
gfx_set_display_timings(unsigned short bpp, unsigned short flags,
unsigned short hactive, unsigned short hblankstart,
unsigned short hsyncstart, unsigned short hsyncend,
unsigned short hblankend, unsigned short htotal,
unsigned short vactive, unsigned short vblankstart,
unsigned short vsyncstart, unsigned short vsyncend,
unsigned short vblankend, unsigned short vtotal,
unsigned long frequency)
#endif
{
gfx_display_mode.flags = 0;
if (flags & 1)
gfx_display_mode.flags |= GFX_MODE_NEG_HSYNC;
if (flags & 2)
gfx_display_mode.flags |= GFX_MODE_NEG_VSYNC;
if (flags & 0x1000)
gfx_display_mode.flags |= GFX_MODE_LOCK_TIMING;
gfx_display_mode.hactive = hactive;
gfx_display_mode.hblankstart = hblankstart;
gfx_display_mode.hsyncstart = hsyncstart;
gfx_display_mode.hsyncend = hsyncend;
gfx_display_mode.hblankend = hblankend;
gfx_display_mode.htotal = htotal;
gfx_display_mode.vactive = vactive;
gfx_display_mode.vblankstart = vblankstart;
gfx_display_mode.vsyncstart = vsyncstart;
gfx_display_mode.vsyncend = vsyncend;
gfx_display_mode.vblankend = vblankend;
gfx_display_mode.vtotal = vtotal;
gfx_display_mode.frequency = frequency;
return (gu1_set_specified_mode(&gfx_display_mode, bpp));
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_vtotal(unsigned short vtotal)
#else
int
gfx_set_vtotal(unsigned short vtotal)
#endif
{
unsigned long unlock, tcfg, timing1, timing2;
unlock = READ_REG32(DC_UNLOCK);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
tcfg = READ_REG32(DC_TIMING_CFG);
timing1 = READ_REG32(DC_V_TIMING_1);
timing2 = READ_REG32(DC_V_TIMING_2);
WRITE_REG32(DC_TIMING_CFG, tcfg & ~(unsigned long)DC_TCFG_TGEN);
WRITE_REG32(DC_V_TIMING_1,
(timing1 & 0xffff) | (unsigned long)(vtotal - 1) << 16);
WRITE_REG32(DC_V_TIMING_2,
(timing2 & 0xffff) | (unsigned long)(vtotal - 1) << 16);
WRITE_REG32(DC_TIMING_CFG, tcfg);
WRITE_REG32(DC_UNLOCK, unlock);
return (0);
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_set_display_pitch(unsigned short pitch)
#else
void
gfx_set_display_pitch(unsigned short pitch)
#endif
{
unsigned long value = 0;
unsigned long lock = READ_REG32(DC_UNLOCK);
value = READ_REG32(DC_LINE_DELTA) & 0xFFFFF000;
value |= (pitch >> 2);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
WRITE_REG32(DC_LINE_DELTA, value);
WRITE_REG32(DC_UNLOCK, lock);
value = (unsigned long)READ_REG16(GP_BLIT_STATUS);
value &= ~(BC_FB_WIDTH_2048 | BC_FB_WIDTH_4096);
if ((gfx_cpu_version == GFX_CPU_PYRAMID) && (pitch > 2048))
value |= BC_FB_WIDTH_4096;
else if (pitch > 1024)
value |= BC_FB_WIDTH_2048;
WRITE_REG16(GP_BLIT_STATUS, (unsigned short)value);
return;
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_set_display_offset(unsigned long offset)
#else
void
gfx_set_display_offset(unsigned long offset)
#endif
{
unsigned long lock;
lock = READ_REG32(DC_UNLOCK);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
if (offset == 0) {
WRITE_REG32(DC_FB_ST_OFFSET, offset);
if (gfx_compression_enabled) {
gfx_wait_vertical_blank();
gu1_enable_compression();
}
} else {
if (gfx_compression_active)
gu1_disable_compression();
WRITE_REG32(DC_FB_ST_OFFSET, offset);
}
WRITE_REG32(DC_UNLOCK, lock);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_display_palette_entry(unsigned long index, unsigned long palette)
#else
int
gfx_set_display_palette_entry(unsigned long index, unsigned long palette)
#endif
{
unsigned long data;
if (index > 0xFF)
return GFX_STATUS_BAD_PARAMETER;
WRITE_REG32(DC_PAL_ADDRESS, index);
data = ((palette >> 2) & 0x0003F) |
((palette >> 4) & 0x00FC0) | ((palette >> 6) & 0x3F000);
WRITE_REG32(DC_PAL_DATA, data);
return (0);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_display_palette(unsigned long *palette)
#else
int
gfx_set_display_palette(unsigned long *palette)
#endif
{
unsigned long data, i;
WRITE_REG32(DC_PAL_ADDRESS, 0);
if (palette) {
for (i = 0; i < 256; i++) {
data = ((palette[i] >> 2) & 0x0003F) |
((palette[i] >> 4) & 0x00FC0) | ((palette[i] >> 6) & 0x3F000);
WRITE_REG32(DC_PAL_DATA, data);
}
}
return (0);
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_set_cursor_enable(int enable)
#else
void
gfx_set_cursor_enable(int enable)
#endif
{
unsigned long unlock, gcfg;
unlock = READ_REG32(DC_UNLOCK);
gcfg = READ_REG32(DC_GENERAL_CFG);
if (enable)
gcfg |= DC_GCFG_CURE;
else
gcfg &= ~(DC_GCFG_CURE);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
WRITE_REG32(DC_GENERAL_CFG, gcfg);
WRITE_REG32(DC_UNLOCK, unlock);
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_set_cursor_colors(unsigned long bkcolor, unsigned long fgcolor)
#else
void
gfx_set_cursor_colors(unsigned long bkcolor, unsigned long fgcolor)
#endif
{
unsigned long value;
#if GFX_VIDEO_SC1200
if (gfx_test_timing_active())
while ((gfx_get_vline()) > gfx_get_vactive()) ;
#endif
WRITE_REG32(DC_PAL_ADDRESS, 0x100);
value = ((bkcolor & 0x000000FC) >> 2) |
((bkcolor & 0x0000FC00) >> (2 + 8 - 6)) |
((bkcolor & 0x00FC0000) >> (2 + 16 - 12));
WRITE_REG32(DC_PAL_DATA, value);
value = ((fgcolor & 0x000000FC) >> 2) |
((fgcolor & 0x0000FC00) >> (2 + 8 - 6)) |
((fgcolor & 0x00FC0000) >> (2 + 16 - 12));
WRITE_REG32(DC_PAL_DATA, value);
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_set_cursor_position(unsigned long memoffset,
unsigned short xpos, unsigned short ypos,
unsigned short xhotspot, unsigned short yhotspot)
#else
void
gfx_set_cursor_position(unsigned long memoffset,
unsigned short xpos, unsigned short ypos,
unsigned short xhotspot, unsigned short yhotspot)
#endif
{
unsigned long unlock;
short x, y;
short xoffset = 0;
short yoffset = 0;
if (gfx_pixel_double)
xpos <<= 1;
if (gfx_line_double)
ypos <<= 1;
x = (short)xpos - (short)xhotspot;
y = (short)ypos - (short)yhotspot;
if (x < -31)
return;
if (y < -31)
return;
if (x < 0) {
xoffset = -x;
x = 0;
}
if (y < 0) {
yoffset = -y;
y = 0;
}
memoffset += (unsigned long)yoffset << 3;
if (PanelEnable) {
if ((ModeWidth > PanelWidth) || (ModeHeight > PanelHeight)) {
gfx_enable_panning(xpos, ypos);
x = x - (short)panelLeft;
y = y - (short)panelTop;
}
}
unlock = READ_REG32(DC_UNLOCK);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
WRITE_REG32(DC_CURS_ST_OFFSET, memoffset);
WRITE_REG32(DC_CURSOR_X, (unsigned long)x |
(((unsigned long)xoffset) << 11));
WRITE_REG32(DC_CURSOR_Y, (unsigned long)y |
(((unsigned long)yoffset) << 11));
WRITE_REG32(DC_UNLOCK, unlock);
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_set_cursor_shape32(unsigned long memoffset,
unsigned long *andmask, unsigned long *xormask)
#else
void
gfx_set_cursor_shape32(unsigned long memoffset,
unsigned long *andmask, unsigned long *xormask)
#endif
{
int i;
unsigned long value;
for (i = 0; i < 32; i++) {
value = (andmask[i] & 0xFFFF0000) | (xormask[i] >> 16);
WRITE_FB32(memoffset, value);
memoffset += 4;
value = (andmask[i] << 16) | (xormask[i] & 0x0000FFFF);
WRITE_FB32(memoffset, value);
memoffset += 4;
}
}
void
gu1_enable_compression(void)
{
int i;
unsigned long unlock, gcfg, offset;
offset = READ_REG32(DC_FB_ST_OFFSET) & 0x003FFFFF;
if (offset != 0)
return;
if (gfx_line_double || gfx_pixel_double)
return;
gfx_compression_active = 1;
for (i = 0; i < 1024; i++) {
WRITE_REG32(MC_DR_ADD, i);
WRITE_REG32(MC_DR_ACC, 0);
}
unlock = READ_REG32(DC_UNLOCK);
gcfg = READ_REG32(DC_GENERAL_CFG);
gcfg |= DC_GCFG_CMPE | DC_GCFG_DECE;
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
WRITE_REG32(DC_GENERAL_CFG, gcfg);
WRITE_REG32(DC_UNLOCK, unlock);
}
void
gu1_disable_compression(void)
{
unsigned long unlock, gcfg;
gfx_compression_active = 0;
unlock = READ_REG32(DC_UNLOCK);
gcfg = READ_REG32(DC_GENERAL_CFG);
gcfg &= ~(DC_GCFG_CMPE | DC_GCFG_DECE);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
WRITE_REG32(DC_GENERAL_CFG, gcfg);
WRITE_REG32(DC_UNLOCK, unlock);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_compression_enable(int enable)
#else
int
gfx_set_compression_enable(int enable)
#endif
{
gfx_compression_enabled = enable;
if (enable)
gu1_enable_compression();
else
gu1_disable_compression();
return (0);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_compression_offset(unsigned long offset)
#else
int
gfx_set_compression_offset(unsigned long offset)
#endif
{
unsigned long lock;
if (offset & 0x0F)
return (1);
lock = READ_REG32(DC_UNLOCK);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
WRITE_REG32(DC_CB_ST_OFFSET, offset);
WRITE_REG32(DC_UNLOCK, lock);
return (0);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_compression_pitch(unsigned short pitch)
#else
int
gfx_set_compression_pitch(unsigned short pitch)
#endif
{
unsigned long lock, line_delta;
lock = READ_REG32(DC_UNLOCK);
line_delta = READ_REG32(DC_LINE_DELTA) & 0xFF800FFF;
line_delta |= ((unsigned long)pitch << 10l) & 0x007FF000;
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
WRITE_REG32(DC_LINE_DELTA, line_delta);
WRITE_REG32(DC_UNLOCK, lock);
return (0);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_compression_size(unsigned short size)
#else
int
gfx_set_compression_size(unsigned short size)
#endif
{
unsigned long lock, buf_size;
size -= 16;
lock = READ_REG32(DC_UNLOCK);
buf_size = READ_REG32(DC_BUF_SIZE) & 0xFFFF01FF;
buf_size |= (((size >> 2) + 1) & 0x7F) << 9;
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
WRITE_REG32(DC_BUF_SIZE, buf_size);
WRITE_REG32(DC_UNLOCK, lock);
return (0);
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_set_display_video_enable(int enable)
#else
void
gfx_set_display_video_enable(int enable)
#endif
{
unsigned long lock, gcfg, buf_size;
lock = READ_REG32(DC_UNLOCK);
gcfg = READ_REG32(DC_GENERAL_CFG);
buf_size = READ_REG32(DC_BUF_SIZE);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
vid_enabled = enable;
if (enable) {
gcfg |= (DC_GCFG_VIDE | DC_GCFG_VRDY);
WRITE_REG32(DC_GENERAL_CFG, gcfg);
WRITE_REG32(DC_BUF_SIZE, (buf_size & 0x0000FFFFl) | vid_buf_size);
}
else {
gcfg &= ~(DC_GCFG_VIDE);
WRITE_REG32(DC_GENERAL_CFG, gcfg);
vid_buf_size = buf_size & 0xFFFF0000l;
WRITE_REG32(DC_BUF_SIZE, buf_size & 0x0000FFFFl);
}
WRITE_REG32(DC_UNLOCK, lock);
return;
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_set_display_video_size(unsigned short width, unsigned short height)
#else
void
gfx_set_display_video_size(unsigned short width, unsigned short height)
#endif
{
unsigned long lock, size, value;
size = (unsigned long)(width << 1) * (unsigned long)height;
vid_buf_size = ((size + 63) >> 6) << 16;
if (!vid_enabled)
return;
lock = READ_REG32(DC_UNLOCK);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
value = READ_REG32(DC_BUF_SIZE) & 0x0000FFFF;
value |= vid_buf_size;
WRITE_REG32(DC_BUF_SIZE, value);
WRITE_REG32(DC_UNLOCK, lock);
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_set_display_video_offset(unsigned long offset)
#else
void
gfx_set_display_video_offset(unsigned long offset)
#endif
{
unsigned long lock;
lock = READ_REG32(DC_UNLOCK);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
offset &= 0x003FFFFF;
WRITE_REG32(DC_VID_ST_OFFSET, offset);
WRITE_REG32(DC_UNLOCK, lock);
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_set_display_priority_high(int enable)
#else
void
gfx_set_display_priority_high(int enable)
#endif
{
unsigned long lock, control;
lock = READ_REG32(DC_UNLOCK);
control = READ_REG32(MC_MEM_CNTRL1);
WRITE_REG32(DC_UNLOCK, DC_UNLOCK_VALUE);
if (enable)
control |= MC_XBUSARB;
else
control &= ~(MC_XBUSARB);
WRITE_REG32(MC_MEM_CNTRL1, control);
WRITE_REG32(DC_UNLOCK, lock);
return;
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_test_timing_active(void)
#else
int
gfx_test_timing_active(void)
#endif
{
if (READ_REG32(DC_TIMING_CFG) & DC_TCFG_TGEN)
return (1);
else
return (0);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_test_vertical_active(void)
#else
int
gfx_test_vertical_active(void)
#endif
{
if (READ_REG32(DC_TIMING_CFG) & DC_TCFG_VNA)
return (0);
else
return (1);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_wait_vertical_blank(void)
#else
int
gfx_wait_vertical_blank(void)
#endif
{
if (gfx_test_timing_active()) {
while (!gfx_test_vertical_active()) ;
while (gfx_test_vertical_active()) ;
}
return (0);
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_enable_panning(int x, int y)
#else
void
gfx_enable_panning(int x, int y)
#endif
{
unsigned long modeBytesPerPixel;
unsigned long modeBytesPerScanline = 0;
unsigned long startAddress = 0;
modeBytesPerPixel = (gbpp + 7) / 8;
modeBytesPerScanline =
(((ModeWidth + 1023) / 1024) * 1024) * modeBytesPerPixel;
if (x >= DeltaX && (unsigned short)x < (PanelWidth + DeltaX) &&
y >= DeltaY && (unsigned short)y < (PanelHeight + DeltaY))
return;
if (x < DeltaX)
DeltaX = x;
else if ((unsigned short)x >= (DeltaX + PanelWidth))
DeltaX = x - PanelWidth + 1;
if (y < DeltaY)
DeltaY = y;
else if ((unsigned short)y >= (DeltaY + PanelHeight))
DeltaY = y - PanelHeight + 1;
startAddress =
(DeltaX * modeBytesPerPixel) + (DeltaY * modeBytesPerScanline);
gfx_set_display_offset(startAddress);
panelTop = DeltaY;
panelLeft = DeltaX * modeBytesPerPixel;
if (panelLeft & 3)
panelLeft = (panelLeft & 0xFFFFFFFC) + 4;
panelLeft /= modeBytesPerPixel;
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_fixed_timings(int panelResX, int panelResY, unsigned short width,
unsigned short height, unsigned short bpp)
#else
int
gfx_set_fixed_timings(int panelResX, int panelResY, unsigned short width,
unsigned short height, unsigned short bpp)
#endif
{
unsigned int mode;
ModeWidth = width;
ModeHeight = height;
PanelWidth = (unsigned short)panelResX;
PanelHeight = (unsigned short)panelResY;
PanelEnable = 1;
for (mode = 0; mode < NUM_FIXED_TIMINGS_MODES; mode++) {
if ((FixedParams[mode].xres == width) &&
(FixedParams[mode].yres == height) &&
(FixedParams[mode].panelresx == panelResX) &&
(FixedParams[mode].panelresy == panelResY)) {
FIXEDTIMINGS *fmode = &FixedParams[mode];
gfx_set_display_timings(bpp, 3, fmode->hactive, fmode->hblankstart,
fmode->hsyncstart, fmode->hsyncend,
fmode->hblankend, fmode->htotal,
fmode->vactive, fmode->vblankstart,
fmode->vsyncstart, fmode->vsyncend,
fmode->vblankend, fmode->vtotal,
fmode->frequency);
return (1);
}
}
return (-1);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_set_panel_present(int panelResX, int panelResY, unsigned short width,
unsigned short height, unsigned short bpp)
#else
int
gfx_set_panel_present(int panelResX, int panelResY, unsigned short width,
unsigned short height, unsigned short bpp)
#endif
{
if (bpp != 8 && bpp != 15 && bpp != 16)
bpp = 16;
ModeWidth = width;
ModeHeight = height;
PanelWidth = (unsigned short)panelResX;
PanelHeight = (unsigned short)panelResY;
PanelEnable = 1;
gbpp = bpp;
gfx_set_display_bpp(bpp);
return (GFX_STATUS_OK);
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_display_pitch(void)
#else
unsigned short
gfx_get_display_pitch(void)
#endif
{
unsigned long value;
if (gfx_cpu_version == GFX_CPU_PYRAMID) {
value = (READ_REG32(DC_LINE_DELTA) & 0x07FF) << 2;
} else {
value = (READ_REG32(DC_LINE_DELTA) & 0x03FF) << 2;
}
return ((unsigned short)value);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_get_display_details(unsigned int mode, int *xres, int *yres, int *hz)
#else
int
gfx_get_display_details(unsigned int mode, int *xres, int *yres, int *hz)
#endif
{
if (mode < NUM_GX_DISPLAY_MODES) {
if (DisplayParams[mode].flags & GFX_MODE_56HZ)
*hz = 56;
else if (DisplayParams[mode].flags & GFX_MODE_60HZ)
*hz = 60;
else if (DisplayParams[mode].flags & GFX_MODE_70HZ)
*hz = 70;
else if (DisplayParams[mode].flags & GFX_MODE_72HZ)
*hz = 72;
else if (DisplayParams[mode].flags & GFX_MODE_75HZ)
*hz = 75;
else if (DisplayParams[mode].flags & GFX_MODE_85HZ)
*hz = 85;
*xres = DisplayParams[mode].hactive;
*yres = DisplayParams[mode].vactive;
return (1);
}
return (0);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_get_display_mode_count(void)
#else
int
gfx_get_display_mode_count(void)
#endif
{
return (NUM_GX_DISPLAY_MODES);
}
#if GFX_DISPLAY_DYNAMIC
unsigned long
gu1_get_frame_buffer_line_size(void)
#else
unsigned long
gfx_get_frame_buffer_line_size(void)
#endif
{
return ((READ_REG32(DC_BUF_SIZE) & 0x1FF) << 3);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_mode_frequency_supported(int xres, int yres, int bpp,
unsigned long frequency)
#else
int
gfx_mode_frequency_supported(int xres, int yres, int bpp,
unsigned long frequency)
#endif
{
unsigned int index;
unsigned long value;
unsigned long bpp_flag = 0;
bpp_flag = GFX_MODE_8BPP;
if (bpp > 8)
bpp_flag = GFX_MODE_16BPP;
for (index = 0; index < NUM_GX_DISPLAY_MODES; index++) {
if ((DisplayParams[index].hactive == (unsigned short)xres) &&
(DisplayParams[index].vactive == (unsigned short)yres) &&
(DisplayParams[index].flags & bpp_flag) &&
(DisplayParams[index].frequency == frequency)) {
int hz = 0;
value = DisplayParams[index].flags;
if (value & GFX_MODE_60HZ)
hz = 60;
else if (value & GFX_MODE_70HZ)
hz = 70;
else if (value & GFX_MODE_72HZ)
hz = 72;
else if (value & GFX_MODE_75HZ)
hz = 75;
else if (value & GFX_MODE_85HZ)
hz = 85;
return (hz);
}
}
return (-1);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_get_refreshrate_from_frequency(int xres, int yres, int bpp, int *hz,
unsigned long frequency)
#else
int
gfx_get_refreshrate_from_frequency(int xres, int yres, int bpp, int *hz,
unsigned long frequency)
#endif
{
unsigned int index, closematch = 0;
unsigned long value;
unsigned long bpp_flag = 0;
long min, diff;
*hz = 60;
bpp_flag = GFX_MODE_8BPP;
if (bpp > 8)
bpp_flag = GFX_MODE_16BPP;
min = 0x7fffffff;
for (index = 0; index < NUM_GX_DISPLAY_MODES; index++) {
if ((DisplayParams[index].htotal == (unsigned short)xres) &&
(DisplayParams[index].vtotal == (unsigned short)yres) &&
(DisplayParams[index].flags & bpp_flag)) {
diff = (long)frequency - (long)DisplayParams[index].frequency;
if (diff < 0)
diff = -diff;
if (diff < min) {
min = diff;
closematch = index;
}
}
}
value = DisplayParams[closematch].flags;
if (value & GFX_MODE_60HZ)
*hz = 60;
else if (value & GFX_MODE_70HZ)
*hz = 70;
else if (value & GFX_MODE_72HZ)
*hz = 72;
else if (value & GFX_MODE_75HZ)
*hz = 75;
else if (value & GFX_MODE_85HZ)
*hz = 85;
return (1);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_get_refreshrate_from_mode(int xres, int yres, int bpp, int *hz,
unsigned long frequency)
#else
int
gfx_get_refreshrate_from_mode(int xres, int yres, int bpp, int *hz,
unsigned long frequency)
#endif
{
unsigned int index, closematch = 0;
unsigned long value;
unsigned long bpp_flag = 0;
long min, diff;
*hz = 60;
bpp_flag = GFX_MODE_8BPP;
if (bpp > 8)
bpp_flag = GFX_MODE_16BPP;
min = 0x7fffffff;
for (index = 0; index < NUM_GX_DISPLAY_MODES; index++) {
if ((DisplayParams[index].hactive == (unsigned short)xres) &&
(DisplayParams[index].vactive == (unsigned short)yres) &&
(DisplayParams[index].flags & bpp_flag)) {
diff = (long)frequency - (long)DisplayParams[index].frequency;
if (diff < 0)
diff = -diff;
if (diff < min) {
min = diff;
closematch = index;
}
}
}
value = DisplayParams[closematch].flags;
if (value & GFX_MODE_60HZ)
*hz = 60;
else if (value & GFX_MODE_70HZ)
*hz = 70;
else if (value & GFX_MODE_72HZ)
*hz = 72;
else if (value & GFX_MODE_75HZ)
*hz = 75;
else if (value & GFX_MODE_85HZ)
*hz = 85;
return (1);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_get_frequency_from_refreshrate(int xres, int yres, int bpp, int hz,
int *frequency)
#else
int
gfx_get_frequency_from_refreshrate(int xres, int yres, int bpp, int hz,
int *frequency)
#endif
{
int retval = -1;
unsigned long hz_flag = 0;
unsigned long index, bpp_flag = 0;
*frequency = 0;
if (hz == 60)
hz_flag = GFX_MODE_60HZ;
else if (hz == 70)
hz_flag = GFX_MODE_70HZ;
else if (hz == 72)
hz_flag = GFX_MODE_72HZ;
else if (hz == 75)
hz_flag = GFX_MODE_75HZ;
else if (hz == 85)
hz_flag = GFX_MODE_85HZ;
bpp_flag = GFX_MODE_8BPP;
if (bpp > 8)
bpp_flag = GFX_MODE_16BPP;
for (index = 0; index < NUM_GX_DISPLAY_MODES; index++) {
if ((DisplayParams[index].hactive == (unsigned short)xres) &&
(DisplayParams[index].vactive == (unsigned short)yres) &&
(DisplayParams[index].flags & bpp_flag) &&
(DisplayParams[index].flags & hz_flag)) {
*frequency = DisplayParams[index].frequency;
retval = 1;
}
}
return retval;
}
#if GFX_DISPLAY_DYNAMIC
unsigned long
gu1_get_max_supported_pixel_clock(void)
#else
unsigned long
gfx_get_max_supported_pixel_clock(void)
#endif
{
return 157500;
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_get_display_mode(int *xres, int *yres, int *bpp, int *hz)
#else
int
gfx_get_display_mode(int *xres, int *yres, int *bpp, int *hz)
#endif
{
unsigned int mode = 0;
unsigned long pll_freq = 0, bpp_flag = 0;
*xres = gfx_get_hactive();
*yres = gfx_get_vactive();
*bpp = gfx_get_display_bpp();
pll_freq = gfx_get_clock_frequency();
if (gfx_pixel_double)
*xres >>= 1;
if (gfx_line_double)
*yres >>= 1;
bpp_flag = GFX_MODE_8BPP;
if (*bpp > 8)
bpp_flag = GFX_MODE_16BPP;
for (mode = 0; mode < NUM_GX_DISPLAY_MODES; mode++) {
if ((DisplayParams[mode].hactive == (unsigned short)*xres) &&
(DisplayParams[mode].vactive == (unsigned short)*yres) &&
(DisplayParams[mode].frequency == pll_freq) &&
(DisplayParams[mode].flags & bpp_flag)) {
pll_freq = DisplayParams[mode].flags;
if (pll_freq & GFX_MODE_56HZ)
*hz = 56;
else if (pll_freq & GFX_MODE_60HZ)
*hz = 60;
else if (pll_freq & GFX_MODE_70HZ)
*hz = 70;
else if (pll_freq & GFX_MODE_72HZ)
*hz = 72;
else if (pll_freq & GFX_MODE_75HZ)
*hz = 75;
else if (pll_freq & GFX_MODE_85HZ)
*hz = 85;
return (1);
}
}
return (-1);
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_hactive(void)
#else
unsigned short
gfx_get_hactive(void)
#endif
{
return ((unsigned short)((READ_REG32(DC_H_TIMING_1) & 0x07F8) + 8));
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_hsync_start(void)
#else
unsigned short
gfx_get_hsync_start(void)
#endif
{
return ((unsigned short)((READ_REG32(DC_H_TIMING_3) & 0x07F8) + 8));
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_hsync_end(void)
#else
unsigned short
gfx_get_hsync_end(void)
#endif
{
return ((unsigned short)(((READ_REG32(DC_H_TIMING_3) >> 16) & 0x07F8) +
8));
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_htotal(void)
#else
unsigned short
gfx_get_htotal(void)
#endif
{
return ((unsigned short)(((READ_REG32(DC_H_TIMING_1) >> 16) & 0x07F8) +
8));
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_vactive(void)
#else
unsigned short
gfx_get_vactive(void)
#endif
{
return ((unsigned short)((READ_REG32(DC_V_TIMING_1) & 0x07FF) + 1));
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_vsync_end(void)
#else
unsigned short
gfx_get_vsync_end(void)
#endif
{
return ((unsigned short)(((READ_REG32(DC_V_TIMING_3) >> 16) & 0x07FF) +
1));
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_vtotal(void)
#else
unsigned short
gfx_get_vtotal(void)
#endif
{
return ((unsigned short)(((READ_REG32(DC_V_TIMING_1) >> 16) & 0x07FF) +
1));
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_display_bpp(void)
#else
unsigned short
gfx_get_display_bpp(void)
#endif
{
switch (READ_REG32(DC_OUTPUT_CFG) & 3) {
case 0:
return (16);
case 2:
return (15);
}
return (8);
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_vline(void)
#else
unsigned short
gfx_get_vline(void)
#endif
{
unsigned short current_scan_line;
do
current_scan_line = (unsigned short)READ_REG32(DC_V_LINE_CNT) & 0x07FF;
while (current_scan_line !=
(unsigned short)(READ_REG32(DC_V_LINE_CNT) & 0x07FF));
return (current_scan_line);
}
#if GFX_DISPLAY_DYNAMIC
unsigned long
gu1_get_display_offset(void)
#else
unsigned long
gfx_get_display_offset(void)
#endif
{
return (READ_REG32(DC_FB_ST_OFFSET) & 0x003FFFFF);
}
#if GFX_DISPLAY_DYNAMIC
unsigned long
gu1_get_cursor_offset(void)
#else
unsigned long
gfx_get_cursor_offset(void)
#endif
{
return (READ_REG32(DC_CURS_ST_OFFSET) & 0x003FFFFF);
}
#if GFX_READ_ROUTINES
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_hblank_start(void)
#else
unsigned short
gfx_get_hblank_start(void)
#endif
{
return ((unsigned short)((READ_REG32(DC_H_TIMING_2) & 0x07F8) + 8));
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_hblank_end(void)
#else
unsigned short
gfx_get_hblank_end(void)
#endif
{
return ((unsigned short)(((READ_REG32(DC_H_TIMING_2) >> 16) & 0x07F8) +
8));
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_vblank_start(void)
#else
unsigned short
gfx_get_vblank_start(void)
#endif
{
return ((unsigned short)((READ_REG32(DC_V_TIMING_2) & 0x07FF) + 1));
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_vsync_start(void)
#else
unsigned short
gfx_get_vsync_start(void)
#endif
{
return ((unsigned short)((READ_REG32(DC_V_TIMING_3) & 0x07FF) + 1));
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_vblank_end(void)
#else
unsigned short
gfx_get_vblank_end(void)
#endif
{
return ((unsigned short)(((READ_REG32(DC_V_TIMING_2) >> 16) & 0x07FF) +
1));
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_get_display_palette_entry(unsigned long index, unsigned long *palette)
#else
int
gfx_get_display_palette_entry(unsigned long index, unsigned long *palette)
#endif
{
unsigned long data;
if (index > 0xFF)
return GFX_STATUS_BAD_PARAMETER;
WRITE_REG32(DC_PAL_ADDRESS, index);
data = READ_REG32(DC_PAL_DATA);
data = ((data << 2) & 0x000000FC) |
((data << 4) & 0x0000FC00) | ((data << 6) & 0x00FC0000);
*palette = data;
return 0;
}
#if GFX_DISPLAY_DYNAMIC
void
gu1_get_display_palette(unsigned long *palette)
#else
void
gfx_get_display_palette(unsigned long *palette)
#endif
{
unsigned long i, data;
WRITE_REG32(DC_PAL_ADDRESS, 0);
for (i = 0; i < 256; i++) {
data = READ_REG32(DC_PAL_DATA);
data = ((data << 2) & 0x000000FC) |
((data << 4) & 0x0000FC00) | ((data << 6) & 0x00FC0000);
palette[i] = data;
}
}
#if GFX_DISPLAY_DYNAMIC
unsigned long
gu1_get_cursor_enable(void)
#else
unsigned long
gfx_get_cursor_enable(void)
#endif
{
return (READ_REG32(DC_GENERAL_CFG) & DC_GCFG_CURE);
}
#if GFX_DISPLAY_DYNAMIC
unsigned long
gu1_get_cursor_position(void)
#else
unsigned long
gfx_get_cursor_position(void)
#endif
{
return ((READ_REG32(DC_CURSOR_X) & 0x07FF) |
((READ_REG32(DC_CURSOR_Y) << 16) & 0x03FF0000));
}
#if GFX_DISPLAY_DYNAMIC
unsigned long
gu1_get_cursor_clip(void)
#else
unsigned long
gfx_get_cursor_clip(void)
#endif
{
return (((READ_REG32(DC_CURSOR_X) >> 11) & 0x01F) |
((READ_REG32(DC_CURSOR_Y) << 5) & 0x1F0000));
}
#if GFX_DISPLAY_DYNAMIC
unsigned long
gu1_get_cursor_color(int color)
#else
unsigned long
gfx_get_cursor_color(int color)
#endif
{
unsigned long data;
if (color) {
WRITE_REG32(DC_PAL_ADDRESS, 0x101);
} else {
WRITE_REG32(DC_PAL_ADDRESS, 0x100);
}
data = READ_REG32(DC_PAL_DATA);
data = ((data << 6) & 0x00FC0000) |
((data << 4) & 0x0000FC00) | ((data << 2) & 0x000000FC);
return (data);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_get_compression_enable(void)
#else
int
gfx_get_compression_enable(void)
#endif
{
unsigned long gcfg;
gcfg = READ_REG32(DC_GENERAL_CFG);
if (gcfg & DC_GCFG_CMPE)
return (1);
else
return (0);
}
#if GFX_DISPLAY_DYNAMIC
unsigned long
gu1_get_compression_offset(void)
#else
unsigned long
gfx_get_compression_offset(void)
#endif
{
unsigned long offset;
offset = READ_REG32(DC_CB_ST_OFFSET) & 0x003FFFFF;
return (offset);
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_compression_pitch(void)
#else
unsigned short
gfx_get_compression_pitch(void)
#endif
{
unsigned short pitch;
pitch = (unsigned short)(READ_REG32(DC_LINE_DELTA) >> 12) & 0x07FF;
return (pitch << 2);
}
#if GFX_DISPLAY_DYNAMIC
unsigned short
gu1_get_compression_size(void)
#else
unsigned short
gfx_get_compression_size(void)
#endif
{
unsigned short size;
size = (unsigned short)((READ_REG32(DC_BUF_SIZE) >> 9) & 0x7F) - 1;
return ((size << 2) + 16);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_get_valid_bit(int line)
#else
int
gfx_get_valid_bit(int line)
#endif
{
int valid;
WRITE_REG32(MC_DR_ADD, line);
valid = (int)READ_REG32(MC_DR_ACC) & 1;
return (valid);
}
#if GFX_DISPLAY_DYNAMIC
unsigned long
gu1_get_display_video_offset(void)
#else
unsigned long
gfx_get_display_video_offset(void)
#endif
{
return (READ_REG32(DC_VID_ST_OFFSET) & 0x003FFFFF);
}
#if GFX_DISPLAY_DYNAMIC
unsigned long
gu1_get_display_video_size(void)
#else
unsigned long
gfx_get_display_video_size(void)
#endif
{
return ((READ_REG32(DC_BUF_SIZE) >> 10) & 0x000FFFC0);
}
#if GFX_DISPLAY_DYNAMIC
int
gu1_get_display_priority_high(void)
#else
int
gfx_get_display_priority_high(void)
#endif
{
if (READ_REG32(MC_MEM_CNTRL1) & MC_XBUSARB)
return (1);
else
return (0);
}
#endif