disp_gu1.c

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

#else
int gfx_test_vertical_active(void)
#endif
{
    if (READ_REG32(DC_TIMING_CFG) & DC_TCFG_VNA)
        return(0);
    else return(1);
}

/*---------------------------------------------------------------------------
 * gfx_wait_vertical_blank
 *---------------------------------------------------------------------------
 */
#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);
}

/* THE FOLLOWING READ ROUTINES ARE ALWAYS INCLUDED: */
/* gfx_get_hsync_end, gfx_get_htotal, gfx_get_vsync_end, gfx_get_vtotal.
/* This is because they are used by the video overlay routines. */

/*---------------------------------------------------------------------------
 * gfx_get_hactive
 *---------------------------------------------------------------------------
 */
#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));
}

/*---------------------------------------------------------------------------
 * gfx_get_hsync_end
 *---------------------------------------------------------------------------
 */
#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));
}

/*---------------------------------------------------------------------------
 * gfx_get_htotal
 *---------------------------------------------------------------------------
 */
#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));
}

/*---------------------------------------------------------------------------
 * gfx_get_vactive
 *---------------------------------------------------------------------------
 */
#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));
}

/*---------------------------------------------------------------------------
 * gfx_get_vsync_end
 *---------------------------------------------------------------------------
 */
#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));
}

/*---------------------------------------------------------------------------
 * gfx_get_vtotal
 *---------------------------------------------------------------------------
 */
#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));
}

/*-----------------------------------------------------------------------------
 * gfx_get_display_bpp
 *
 * This routine returns the current color depth of the active display.
 *-----------------------------------------------------------------------------
 */
#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_READ_ROUTINES

/*************************************************************/
/*  READ ROUTINES  |  INCLUDED FOR DIAGNOSTIC PURPOSES ONLY  */
/*************************************************************/

/*---------------------------------------------------------------------------
 * gfx_get_hblank_start
 *---------------------------------------------------------------------------
 */
#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));
}

/*---------------------------------------------------------------------------
 * gfx_get_hsync_start
 *---------------------------------------------------------------------------
 */
#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));
}

/*---------------------------------------------------------------------------
 * gfx_get_hblank_end
 *---------------------------------------------------------------------------
 */
#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));
}

/*---------------------------------------------------------------------------
 * gfx_get_vblank_start
 *---------------------------------------------------------------------------
 */
#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));
}

/*---------------------------------------------------------------------------
 * gfx_get_vsync_start
 *---------------------------------------------------------------------------
 */
#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));
}

/*---------------------------------------------------------------------------
 * gfx_get_vblank_end
 *---------------------------------------------------------------------------
 */
#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));
}

/*-----------------------------------------------------------------------------
 * gfx_get_display_offset
 *-----------------------------------------------------------------------------
 */
#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);
}

/*-----------------------------------------------------------------------------
 * gfx_get_display_palette
 *-----------------------------------------------------------------------------
 */
#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;
    }
}

/*-----------------------------------------------------------------------------
 * gfx_get_cursor_enable
 *-----------------------------------------------------------------------------
 */
#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);
}

/*-----------------------------------------------------------------------------
 * gfx_get_cursor_offset
 *-----------------------------------------------------------------------------
 */
#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);
}

/*-----------------------------------------------------------------------------
 * gfx_get_cursor_position
 *-----------------------------------------------------------------------------
 */
#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));
}

/*-----------------------------------------------------------------------------
 * gfx_get_cursor_clip
 *-----------------------------------------------------------------------------
 */
#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));
}

/*-----------------------------------------------------------------------------
 * gfx_get_cursor_color
 *-----------------------------------------------------------------------------
 */
#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);
}

/*-----------------------------------------------------------------------------
 * gfx_get_compression_enable
 *-----------------------------------------------------------------------------
 */
#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);
}

/*-----------------------------------------------------------------------------
 * gfx_get_compression_offset
 *-----------------------------------------------------------------------------
 */
#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);
}

/*-----------------------------------------------------------------------------
 * gfx_get_compression_pitch
 *-----------------------------------------------------------------------------
 */
#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);
}

/*-----------------------------------------------------------------------------
 * gfx_get_compression_size
 *-----------------------------------------------------------------------------
 */
#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);
}

/*-----------------------------------------------------------------------------
 * gfx_get_valid_bit
 *-----------------------------------------------------------------------------
 */
#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 = READ_REG32(MC_DR_ACC) & 1;
    return(valid);
}

/*---------------------------------------------------------------------------
 * gfx_get_display_video_offset (PRIVATE ROUTINE - NOT PART OF API)
 *
 * This routine is called by "gfx_get_video_offset".  It abstracts the 
 * version of the display controller from the video overlay routines.
 *---------------------------------------------------------------------------
 */
#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) & 0x001FFFFF);
}

/*---------------------------------------------------------------------------
 * gfx_get_display_video_size (PRIVATE ROUTINE - NOT PART OF API)
 *
 * This routine is called by "gfx_get_video_size".  It abstracts the 
 * version of the display controller from the video overlay routines.
 *---------------------------------------------------------------------------
 */
#if GFX_DISPLAY_DYNAMIC
unsigned long gu1_get_display_video_size(void)
#else
unsigned long gfx_get_display_video_size(void)
#endif
{
    /* RETURN TOTAL SIZE, IN BYTES */

    return((READ_REG32(DC_BUF_SIZE) >> 10) & 0x000FFFC0);
}

#endif /* GFX_READ_ROUTINES */

/* END OF FILE */