xref: /xsrc/external/mit/xf86-video-geode/dist/src/gfx/tv_1200.c

/* Copyright (c) 2005 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 * Neither the name of the Advanced Micro Devices, Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from this
 * software without specific prior written permission.
 * */

/*
 * This file contains routines to control the SC1200 TVOUT and TV encoder.
 * */

/*----------------------------------------------------------------------------
 * gfx_set_tv_format
 *
 * This routine sets the TV encoder registers to the specified format
 * and resolution.
 *----------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_format(TVStandardType format, GfxOnTVType resolution)
#else
int
gfx_set_tv_format(TVStandardType format, GfxOnTVType resolution)
#endif
{
    unsigned long ctrl2, mode;

    /* Save TV output mode */
    ctrl2 =
        READ_VID32(SC1200_TVENC_TIM_CTRL_2) & (SC1200_TVENC_OUTPUT_YCBCR |
                                               SC1200_TVENC_CFS_MASK);
    /* Save flicker filter setting */
    mode =
        READ_VID32(SC1200_TVOUT_HORZ_SCALING) &
        SC1200_TVOUT_FLICKER_FILTER_MASK;

    switch (format) {
    case TV_STANDARD_NTSC:
        /* Horizontal Sync Start is 848 */
        /* Horizontal Sync End is 856 */
        WRITE_VID32(SC1200_TVOUT_HORZ_SYNC, 0x03580350);
        /* Vertical Sync Start is 0 */
        /* Vertical Sync End is 1 */
        /* Vertical Display Start Skew is 1 */
        /* Vertical Display End Skew is 1 */
        WRITE_VID32(SC1200_TVOUT_VERT_SYNC, 0x05001000);
        /* Disable vertical down scaling, take all lines */
        if (gfx_chip_revision <= SC1200_REV_B3)
            WRITE_VID32(SC1200_TVOUT_VERT_DOWNSCALE, 0xffffffff);
        /* Enable video timing */
        /* Reset sub carrier every two frames */
        /* Disable BLANK */
        /* Enable color burst */
        /* Add the IRE offset */
        /* NTSC color encoding */
        /* Video generator timing is 525 lines / 60Hz */
        /* Horizontal and Vertical counters are initialized to HPHASE &
         * VPHASE */
        /* VPHASE is 2, HPHASE is 0x50 */
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_1, 0xa2a01050);
        /* Increase horizontal blanking interval */
        /* Low Water Mark for Y is 0x1F */
        /* Low Water Mark for Cb is 0xF */
        /* HUE is 0 */
        /* SCPHASE is 0xF9 */
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_2, 0x9ff000f9 | ctrl2);
        /* Subcarrier Frequency is 3.579545 MHz */
        WRITE_VID32(SC1200_TVENC_SUB_FREQ, 0x21f07c1f);
        /* VSTART is 18, HSTART is 113 */
        WRITE_VID32(SC1200_TVENC_DISP_POS, 0x00120071);
        /* Display size: HEIGHT is 239, WIDTH is 719 */
        WRITE_VID32(SC1200_TVENC_DISP_SIZE, 0x00ef02cf);
        switch (resolution) {
        case GFX_ON_TV_SQUARE_PIXELS:
            if (gfx_chip_revision <= SC1200_REV_B3) {
                /* Horizontal Display start is 116 */
                /* Total number of pixels per line is 857 */
                WRITE_VID32(SC1200_TVOUT_HORZ_TIM, 0x00740359);
                /* HSYNC generated in the TV Encoder module */
                /* Interval between resets of TV Encoder is once every odd
                 * field */
                /* Enable Horizontal interpolation */
                /* Enable Horizontal up scaling 9/8 */
                /* Disable Horizontal downscale */
                WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x10020700 | mode);
                /* Horizontal display end is 919, i.e. 720 active pixels */
                /* Total number of display lines per field is 240 */
                WRITE_VID32(SC1200_TVOUT_LINE_END, 0x039700f0);
            }
            else {              /* Use new scaler available in Rev. C */
                /* Horizontal Display start is 111 */
                /* Total number of pixels per line is 857 */
                WRITE_VID32(SC1200_TVOUT_HORZ_TIM, 0x006f0359);
                /* HSYNC generated in the TV Encoder module */
                /* Interval between resets of TV Encoder is once every odd
                 * field */
                /* Enable Horizontal interpolation */
                /* Disable Horizontal up scaling 9/8 */
                /* Disable Horizontal downscale */
                WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x10020500 | mode);
                /* Set Horizontal upscaling to 64/58 (~ 11/10) */
                WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE, 0x3A000000);
                /* Horizontal display end is 900, i.e. 706 active pixels */
                /* Total number of display lines per field is 240 */
                WRITE_VID32(SC1200_TVOUT_LINE_END, 0x038400f0);
            }
            break;
        case GFX_ON_TV_NO_SCALING:
            /* Horizontal Display start is 116 */
            /* Total number of pixels per line is 857 */
            WRITE_VID32(SC1200_TVOUT_HORZ_TIM, 0x00740359);
            /* HSYNC generated in the TV Encoder module */
            /* Interval between resets of TV Encoder is once every odd field */
            /* Enable Horizontal interpolation */
            /* Disable Horizontal up scaling 9/8 */
            /* Disable Horizontal downscale */
            WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x10020500 | mode);
            /* Disable Horizontal scaling (set to 64/64) */
            if (gfx_chip_revision >= SC1200_REV_C1)
                WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE, 0x40000000);
            /* Horizontal display end is 919, i.e. 720 active pixels */
            /* Total number of display lines per field is 240 */
            WRITE_VID32(SC1200_TVOUT_LINE_END, 0x039700f0);
            break;
        default:
            return (GFX_STATUS_BAD_PARAMETER);
        }
        break;
    case TV_STANDARD_PAL:
        /* Horizontal Sync Start is 854 */
        /* Horizontal Sync End is 862 */
        WRITE_VID32(SC1200_TVOUT_HORZ_SYNC, 0x035e0356);
        /* Vertical Sync Start is 0 */
        /* Vertical Sync End is 1 */
        /* Vertical Display Start Skew is 1 */
        /* Vertical Display End Skew is 1 */
        WRITE_VID32(SC1200_TVOUT_VERT_SYNC, 0x05001000);
        /* Disable vertical down scaling, take all lines */
        if (gfx_chip_revision <= SC1200_REV_B3)
            WRITE_VID32(SC1200_TVOUT_VERT_DOWNSCALE, 0xffffffff);
        /* Enable video timing */
        /* Never reset sub carrier (should be every 4 frames but doesn't work
         * with genlock) */
        /* Disable BLANK */
        /* Enable color burst */
        /* Do not add the IRE offset */
        /* NTSC color encoding */
        /* Video generator timing is 625 lines / 50Hz */
        /* Horizontal and Vertical counters are initialized to HPHASE & VPHASE
         * */
        /* VPHASE is 2, HPHASE is 50 */
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_1, 0xB1201050);
        /* Increase horizontal blanking interval */
        /* Low Water Mark for Y is 0x1F */
        /* Low Water Mark for Cb is 0xF */
        /* HUE is 0 */
        /* SCPHASE is 0xD9 */
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_2, 0x9ff000d9 | ctrl2);
        /* Subcarrier Frequency is 4.43361875 MHz */
        WRITE_VID32(SC1200_TVENC_SUB_FREQ, 0x2a098acb);
        /* VSTART is 22, HSTART is 123 */
        WRITE_VID32(SC1200_TVENC_DISP_POS, 0x0016007b);
        /* Display size: HEIGHT is 287, WIDTH is 719 */
        WRITE_VID32(SC1200_TVENC_DISP_SIZE, 0x011f02cf);
        switch (resolution) {
        case GFX_ON_TV_NO_SCALING:
            /* Horizontal Display start is 124 */
            /* Total number of pixels per line is 863 */
            WRITE_VID32(SC1200_TVOUT_HORZ_TIM, 0x007c035f);
            /* HSYNC generated in the TV Encoder module */
            /* Interval between resets of TV Encoder is once every odd field */
            /* Enable Horizontal interpolation */
            /* Disable Horizontal up scaling 9/8 */
            /* Disable Horizontal downscale */
            WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x10020500 | mode);
            /* Disable Horizontal scaling (set to 64/64) */
            if (gfx_chip_revision >= SC1200_REV_C1)
                WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE, 0x40000000);
            /* Horizontal display end is 924, i.e. 720 active pixels */
            /* Total number of display lines per field is 288 */
            WRITE_VID32(SC1200_TVOUT_LINE_END, 0x039c0120);
            break;
        case GFX_ON_TV_SQUARE_PIXELS:
            /* Horizontal Display start is 122 */
            /* Total number of pixels per line is 863 */
            WRITE_VID32(SC1200_TVOUT_HORZ_TIM, 0x007a035f);
            if (gfx_chip_revision <= SC1200_REV_B3) {
                /* HSYNC generated in the TV Encoder module */
                /* Interval between resets of TV Encoder is once every odd
                 * field */
                /* Enable Horizontal interpolation */
                /* Disable Horizontal up scaling 9/8 */
                /* Horizontal downscale m/(m+1), m = 11, (i.e. 11/12 - closest
                 * possible to 54/59) */
                WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x1002040b | mode);
                /* Horizontal display end is 906, i.e. 704 active pixels */
                /* Total number of display lines per field is 288 */
                WRITE_VID32(SC1200_TVOUT_LINE_END, 0x038a0120);
            }
            else {
                /* HSYNC generated in the TV Encoder module */
                /* Interval between resets of TV Encoder is once every odd
                 * field */
                /* Enable Horizontal interpolation */
                /* Disable Horizontal up scaling 9/8 */
                /* Disable Horizontal downscale */
                WRITE_VID32(SC1200_TVOUT_HORZ_SCALING, 0x10020500 | mode);
                /* Set Horizontal down scaling to 64/70 (closest possible to
                 * 54/59) */
                WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE, 0x46000000);
                /* Horizontal display end is 904, i.e. 702 active pixels */
                /* Total number of display lines per field is 288 */
                WRITE_VID32(SC1200_TVOUT_LINE_END, 0x03880120);
            }
            break;
        default:
            return (GFX_STATUS_BAD_PARAMETER);
        }
        break;
    default:
        return (GFX_STATUS_BAD_PARAMETER);
    }
    return (GFX_STATUS_OK);
}

/*----------------------------------------------------------------------------
 * gfx_set_tv_output
 *
 * This routine sets the TV encoder registers to the specified output type.
 * Supported output types are : S-VIDEO, Composite, YUV and SCART.
 *----------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_output(int output)
#else
int
gfx_set_tv_output(int output)
#endif
{
    unsigned long ctrl2, ctrl3;

    ctrl2 = READ_VID32(SC1200_TVENC_TIM_CTRL_2);
    ctrl3 = READ_VID32(SC1200_TVENC_TIM_CTRL_3);
    ctrl2 &= ~(SC1200_TVENC_OUTPUT_YCBCR | SC1200_TVENC_CFS_MASK);
    ctrl3 &= ~(SC1200_TVENC_CM | SC1200_TVENC_SYNCMODE_MASK | SC1200_TVENC_CS);
    switch (output) {
    case TV_OUTPUT_COMPOSITE:
        /* Analog outputs provide Y, C and CVBS */
        /* Chrominance Lowpass filter is 1.3MHz (for composite video output) */
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_2, ctrl2 | SC1200_TVENC_CFS_CVBS);
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_3, ctrl3);
        break;
    case TV_OUTPUT_S_VIDEO:
        /* Analog outputs provide Y, C and CVBS */
        /* Chrominance Lowpass filter is 1.8MHz (for S-video output) */
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_2, ctrl2 | SC1200_TVENC_CFS_SVIDEO);
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_3, ctrl3);
        break;
    case TV_OUTPUT_YUV:
        /* Analog outputs provide Y, Cb and Cr */
        /* A 7.5 IRE setup is applied to the output */
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_2,
                    ctrl2 | SC1200_TVENC_OUTPUT_YCBCR |
                    SC1200_TVENC_CFS_BYPASS);
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_3,
                    ctrl3 | SC1200_TVENC_CM | SC1200_TVENC_CS);
        break;
    case TV_OUTPUT_SCART:
        /* Analog outputs provide SCART (RGB and CVBS) */
        /* Sync is added to green signal */
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_2, ctrl2 | SC1200_TVENC_CFS_CVBS);
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_3,
                    ctrl3 | SC1200_TVENC_CM | SC1200_TVENC_SYNC_ON_GREEN);
        break;
    default:
        return (GFX_STATUS_BAD_PARAMETER);
    }

    /* Adjusts the internal voltage reference */
    ctrl2 = READ_VID32(SC1200_TVENC_DAC_CONTROL);
    ctrl2 &= ~SC1200_TVENC_TRIM_MASK;

    /* Bypass for issue #926 : Inadequate chroma level of S-Video output */
    if ((gfx_chip_revision == SC1200_REV_B3) && (output == TV_OUTPUT_S_VIDEO))
        ctrl2 |= 0x7;
    else
        ctrl2 |= 0x5;

    WRITE_VID32(SC1200_TVENC_DAC_CONTROL, ctrl2);

    /* Disable 4:2:2 to 4:4:4 converter interpolation */
    WRITE_VID32(SC1200_TVOUT_DEBUG, SC1200_TVOUT_CONVERTER_INTERPOLATION);

    return (GFX_STATUS_OK);
}

/*----------------------------------------------------------------------------
 * gfx_set_tv_enable
 *
 * This routine enables or disables the TV output.
 *----------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_enable(int enable)
#else
int
gfx_set_tv_enable(int enable)
#endif
{
    unsigned long value_tim, value_dac;

    value_tim = READ_VID32(SC1200_TVENC_TIM_CTRL_1);
    value_dac = READ_VID32(SC1200_TVENC_DAC_CONTROL);

    if (enable) {
        value_tim |= SC1200_TVENC_VIDEO_TIMING_ENABLE;
        value_dac &= ~SC1200_TVENC_POWER_DOWN;
        /* ENABLE GRAPHICS DISPLAY LOGIC IN VIDEO PROCESSOR */
        gfx_set_screen_enable(1);
    }
    else {
        value_tim &= ~SC1200_TVENC_VIDEO_TIMING_ENABLE;
        value_dac |= SC1200_TVENC_POWER_DOWN;
        /* Do not disable the graphics display logic because it might be
         * needed for CRT */
    }

    WRITE_VID32(SC1200_TVENC_TIM_CTRL_1, value_tim);
    WRITE_VID32(SC1200_TVENC_DAC_CONTROL, value_dac);

    return (GFX_STATUS_OK);
}

/*----------------------------------------------------------------------------
 * gfx_set_tv_flicker_filter
 *
 * This routine configures the TV out flicker filter.
 *----------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_flicker_filter(int ff)
#else
int
gfx_set_tv_flicker_filter(int ff)
#endif
{
    unsigned long mode;

    mode = READ_VID32(SC1200_TVOUT_HORZ_SCALING);
    mode &= ~SC1200_TVOUT_FLICKER_FILTER_MASK;
    switch (ff) {
    case TV_FLICKER_FILTER_NONE:
        WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
                    mode | SC1200_TVOUT_FLICKER_FILTER_DISABLED);
        break;
    case TV_FLICKER_FILTER_NORMAL:
        WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
                    mode | SC1200_TVOUT_FLICKER_FILTER_FOURTH_HALF_FOURTH);
        break;
    case TV_FLICKER_FILTER_INTERLACED:
        WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
                    mode | SC1200_TVOUT_FLICKER_FILTER_HALF_ONE_HALF);
        break;
    default:
        return GFX_STATUS_BAD_PARAMETER;
    }
    return (GFX_STATUS_OK);
}

/*----------------------------------------------------------------------------
 * gfx_set_tv_sub_carrier_reset
 *
 * This routine configures the TV encoder sub carrier reset interval.
 *----------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_sub_carrier_reset(int screset)
#else
int
gfx_set_tv_sub_carrier_reset(int screset)
#endif
{
    unsigned long mode;

    mode = READ_VID32(SC1200_TVENC_TIM_CTRL_1);
    mode &= ~SC1200_TVENC_SUB_CARRIER_RESET_MASK;
    switch (screset) {
    case TV_SUB_CARRIER_RESET_NEVER:
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_1,
                    mode | SC1200_TVENC_SUB_CARRIER_RESET_NEVER);
        break;
    case TV_SUB_CARRIER_RESET_EVERY_TWO_LINES:
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_1,
                    mode | SC1200_TVENC_SUB_CARRIER_RESET_EVERY_TWO_LINES);
        break;
    case TV_SUB_CARRIER_RESET_EVERY_TWO_FRAMES:
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_1,
                    mode | SC1200_TVENC_SUB_CARRIER_RESET_EVERY_TWO_FRAMES);
        break;
    case TV_SUB_CARRIER_RESET_EVERY_FOUR_FRAMES:
        WRITE_VID32(SC1200_TVENC_TIM_CTRL_1,
                    mode | SC1200_TVENC_SUB_CARRIER_RESET_EVERY_FOUR_FRAMES);
        break;
    default:
        return GFX_STATUS_BAD_PARAMETER;
    }
    return (GFX_STATUS_OK);
}

/*----------------------------------------------------------------------------
 * gfx_set_tv_vphase
 *
 * This routine sets the tv encoder VPHASE value.
 *----------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_vphase(int vphase)
#else
int
gfx_set_tv_vphase(int vphase)
#endif
{
    unsigned long mode = READ_VID32(SC1200_TVENC_TIM_CTRL_1);

    mode &= ~SC1200_TVENC_VPHASE_MASK;
    mode |= (vphase << SC1200_TVENC_VPHASE_POS) & SC1200_TVENC_VPHASE_MASK;
    WRITE_VID32(SC1200_TVENC_TIM_CTRL_1, mode);
    return (GFX_STATUS_OK);
}

/*----------------------------------------------------------------------------
 * gfx_set_tv_YC_delay
 *
 * This routine configures the TV out Y/C delay.
 *----------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_YC_delay(int delay)
#else
int
gfx_set_tv_YC_delay(int delay)
#endif
{
    unsigned long mode;

    /* This feature is implemented in Rev C1 */
    if (gfx_chip_revision < SC1200_REV_C1)
        return (GFX_STATUS_OK);

    mode = READ_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE);
    mode &= ~SC1200_TVOUT_YC_DELAY_MASK;
    switch (delay) {
    case TV_YC_DELAY_NONE:
        WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE,
                    mode | SC1200_TVOUT_YC_DELAY_NONE);
        break;
    case TV_Y_DELAY_ONE_PIXEL:
        WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE,
                    mode | SC1200_TVOUT_Y_DELAY_ONE_PIXEL);
        break;
    case TV_C_DELAY_ONE_PIXEL:
        WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE,
                    mode | SC1200_TVOUT_C_DELAY_ONE_PIXEL);
        break;
    case TV_C_DELAY_TWO_PIXELS:
        WRITE_VID32(SC1200_TVOUT_HORZ_PRE_ENCODER_SCALE,
                    mode | SC1200_TVOUT_C_DELAY_TWO_PIXELS);
        break;
    default:
        return GFX_STATUS_BAD_PARAMETER;
    }
    return (GFX_STATUS_OK);
}

/*----------------------------------------------------------------------------
 * gfx_set_tvenc_reset_interval
 *
 * This routine sets the interval between external resets of the TV encoder
 * timing generator by the TV out.
 *----------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tvenc_reset_interval(int interval)
#else
int
gfx_set_tvenc_reset_interval(int interval)
#endif
{
    unsigned long value;

    value = READ_VID32(SC1200_TVOUT_HORZ_SCALING);
    value &= ~SC1200_TVENC_EXTERNAL_RESET_INTERVAL_MASK;
    switch (interval) {
    case TVENC_RESET_EVERY_ODD_FIELD:
        WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
                    value | SC1200_TVENC_EXTERNAL_RESET_EVERY_ODD_FIELD);
        break;
    case TVENC_RESET_EVERY_EVEN_FIELD:
        WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
                    value | SC1200_TVENC_EXTERNAL_RESET_EVERY_EVEN_FIELD);
        break;
    case TVENC_RESET_NEXT_ODD_FIELD:
        WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
                    value | SC1200_TVENC_EXTERNAL_RESET_NEXT_ODD_FIELD);
        break;
    case TVENC_RESET_NEXT_EVEN_FIELD:
        WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
                    value | SC1200_TVENC_EXTERNAL_RESET_NEXT_EVEN_FIELD);
        break;
    case TVENC_RESET_EVERY_FIELD:
        WRITE_VID32(SC1200_TVOUT_HORZ_SCALING,
                    value | SC1200_TVENC_EXTERNAL_RESET_EVERY_FIELD);
        break;
    case TVENC_RESET_EVERY_X_ODD_FIELDS:
    case TVENC_RESET_EVERY_X_EVEN_FIELDS:
        return GFX_STATUS_UNSUPPORTED;
    default:
        return GFX_STATUS_BAD_PARAMETER;
    }
    return (GFX_STATUS_OK);
}

/*----------------------------------------------------------------------------
 * gfx_set_tv_cc_enable
 *
 * This routine enables or disables the use of the hardware CC registers
 * in the TV encoder.
 *----------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_cc_enable(int enable)
#else
int
gfx_set_tv_cc_enable(int enable)
#endif
{
    unsigned long value;

    value = READ_VID32(SC1200_TVENC_CC_CONTROL);
    value &= ~(0x0005F);
    if (enable)
        value |= 0x51;
    WRITE_VID32(SC1200_TVENC_CC_CONTROL, value);
    return (0);
}

/*---------------------------------------------------------------------------
 * gfx_set_tv_display
 *
 * This routine sets the timings in the display controller to support a
 * TV resolution.
 *---------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_display(int width, int height)
#else
int
gfx_set_tv_display(int width, int height)
#endif
{
    DISPLAYMODE *pMode;
    unsigned int i;

    for (i = 0; i < NUM_TV_MODES; i++) {
        pMode = &TVTimings[i];
        if ((unsigned) width == pMode->hactive
            && (unsigned) height == pMode->vactive)
            break;
    }

    if (i == NUM_TV_MODES)
        return 0;

    gfx_set_display_timings(gfx_get_display_bpp(),
                            (unsigned short) pMode->flags, pMode->hactive,
                            pMode->hblankstart, pMode->hsyncstart,
                            pMode->hsyncend, pMode->hblankend, pMode->htotal,
                            pMode->vactive, pMode->vblankstart,
                            pMode->vsyncstart, pMode->vsyncend,
                            pMode->vblankend, pMode->vtotal, pMode->frequency);

    return 1;
}

/*----------------------------------------------------------------------------
 * cc_add_parity_bit
 *
 * This routine adds the (odd) parity bit to the data character.
 *----------------------------------------------------------------------------
 */
unsigned char
cc_add_parity_bit(unsigned char data)
{
    int i, num = 0;
    unsigned char d = data;

    for (i = 0; i < 7; i++) {
        if (d & 0x1)
            num++;
        d >>= 1;
    }
    if (num & 0x1)
        return (data & ~0x80);
    else
        return (data | 0x80);
}

/*----------------------------------------------------------------------------
 * gfx_set_tv_cc_data
 *
 * This routine writes the two specified characters to the CC data register
 * of the TV encoder.
 *----------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_cc_data(unsigned char data1, unsigned char data2)
#else
int
gfx_set_tv_cc_data(unsigned char data1, unsigned char data2)
#endif
{
    unsigned long value;

    value = cc_add_parity_bit(data1) | (cc_add_parity_bit(data2) << 8);
    WRITE_VID32(SC1200_TVENC_CC_DATA, value);
    return (0);
}

/*---------------------------------------------------------------------------
 * gfx_test_tvout_odd_field
 *
 * This routine returns 1 if the current TVout field is odd. Otherwise returns
 * 0.
 *---------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_test_tvout_odd_field(void)
#else
int
gfx_test_tvout_odd_field(void)
#endif
{
    unsigned long debug = READ_VID32(SC1200_TVOUT_DEBUG);

    WRITE_VID32(SC1200_TVOUT_DEBUG, debug | SC1200_TVOUT_FIELD_STATUS_TV);
    if (READ_VID32(SC1200_TVOUT_DEBUG) & SC1200_TVOUT_FIELD_STATUS_EVEN)
        return (0);
    else
        return (1);
}

/*---------------------------------------------------------------------------
 * gfx_test_tvenc_odd_field
 *
 * This routine returns 1 if the current TV encoder field is odd. Otherwise
 * returns 0.
 *---------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_test_tvenc_odd_field(void)
#else
int
gfx_test_tvenc_odd_field(void)
#endif
{
    unsigned long debug = READ_VID32(SC1200_TVOUT_DEBUG);

    WRITE_VID32(SC1200_TVOUT_DEBUG, debug & ~SC1200_TVOUT_FIELD_STATUS_TV);
    if (READ_VID32(SC1200_TVOUT_DEBUG) & SC1200_TVOUT_FIELD_STATUS_EVEN)
        return (0);
    else
        return (1);
}

/*----------------------------------------------------------------------------
 * gfx_set_tv_field_status_invert
 *
 * This routines determines whether the tvout/tvencoder field status bit is
 * inverted (enable = 1) or not (enable = 0).
 *----------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_set_tv_field_status_invert(int enable)
#else
int
gfx_set_tv_field_status_invert(int enable)
#endif
{
    unsigned long value;

    value = READ_VID32(SC1200_TVOUT_DEBUG);

    if (enable) {
        value |= SC1200_TVOUT_FIELD_STATUS_INVERT;
    }
    else {
        value &= ~(SC1200_TVOUT_FIELD_STATUS_INVERT);
    }

    WRITE_VID32(SC1200_TVOUT_DEBUG, value);

    return (GFX_STATUS_OK);
}

/*---------------------------------------------------------------------------
 * gfx_get_tv_vphase
 *
 * This routine returns the tv encoder vertical phase.
 *---------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_vphase(void)
#else
int
gfx_get_tv_vphase(void)
#endif
{
    unsigned long mode = READ_VID32(SC1200_TVENC_TIM_CTRL_1);

    return (int) ((mode & SC1200_TVENC_VPHASE_MASK) >> SC1200_TVENC_VPHASE_POS);
}

/*---------------------------------------------------------------------------
 * gfx_get_tv_enable
 *
 * This routine returns the current tv enable status
 *---------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_enable(unsigned int *p_on)
#else
int
gfx_get_tv_enable(unsigned int *p_on)
#endif
{
    unsigned long control = READ_VID32(SC1200_TVENC_DAC_CONTROL);

    *p_on = (unsigned int) (!(control & SC1200_TVENC_POWER_DOWN));

    return GFX_STATUS_OK;
}

/*---------------------------------------------------------------------------
 * gfx_get_tv_output
 *
 * This routine returns the current programmed TV output type.  It does not
 * detect invalid configurations.
 *---------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_output(void)
#else
int
gfx_get_tv_output(void)
#endif
{
    unsigned long ctrl2, ctrl3;
    int format = 0;

    ctrl2 = READ_VID32(SC1200_TVENC_TIM_CTRL_2);
    ctrl3 = READ_VID32(SC1200_TVENC_TIM_CTRL_3);

    if ((ctrl2 & SC1200_TVENC_CFS_MASK) == SC1200_TVENC_CFS_SVIDEO)
        format = TV_OUTPUT_S_VIDEO;
    else if (ctrl2 & SC1200_TVENC_OUTPUT_YCBCR)
        format = TV_OUTPUT_YUV;
    else if ((ctrl2 & SC1200_TVENC_CFS_MASK) == SC1200_TVENC_CFS_CVBS) {
        if (ctrl3 & SC1200_TVENC_CM)
            format = TV_OUTPUT_SCART;
        else
            format = TV_OUTPUT_COMPOSITE;
    }

    return format;
}

/*---------------------------------------------------------------------------
 * gfx_get_tv_mode_count
 *
 * This routine returns the number of valid TV out resolutions.
 *---------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_mode_count(TVStandardType format)
#else
int
gfx_get_tv_mode_count(TVStandardType format)
#endif
{
    unsigned int mode, count = 0;
    unsigned long flag;

    switch (format) {
    case TV_STANDARD_NTSC:
        flag = GFX_MODE_TV_NTSC;
        break;
    case TV_STANDARD_PAL:
        flag = GFX_MODE_TV_PAL;
        break;
    default:
        return 0;
    }

    for (mode = 0; mode < NUM_TV_MODES; mode++) {
        if (TVTimings[mode].flags & flag)
            count++;
    }

    return count;
}

/*---------------------------------------------------------------------------
 * gfx_get_tv_display_mode
 *
 * This routine returns the current TV display parameters.
 *---------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_display_mode(int *width, int *height, int *bpp, int *hz)
#else
int
gfx_get_tv_display_mode(int *width, int *height, int *bpp, int *hz)
#endif
{
    unsigned long frequency;
    unsigned long mode, flags;

    *width = gfx_get_hactive();
    *height = gfx_get_vactive();
    *bpp = gfx_get_display_bpp();
    frequency = gfx_get_clock_frequency();

    for (mode = 0; mode < NUM_TV_MODES; mode++) {
        if (TVTimings[mode].hactive == (unsigned short) (*width) &&
            TVTimings[mode].vactive == (unsigned short) (*height) &&
            TVTimings[mode].frequency == frequency) {
            flags = TVTimings[mode].flags;

            if (flags & GFX_MODE_TV_NTSC)
                *hz = 60;
            else if (flags & GFX_MODE_TV_PAL)
                *hz = 50;
            else
                *hz = 0;
            return (1);
        }
    }

    return -1;
}

/*---------------------------------------------------------------------------
 * gfx_get_tv_display_mode_frequency
 *
 * This routine returns the PLL frequency of a given TV mode.
 *---------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_get_tv_display_mode_frequency(unsigned short width,
                                     unsigned short height,
                                     TVStandardType format, int *frequency)
#else
int
gfx_get_tv_display_mode_frequency(unsigned short width, unsigned short height,
                                  TVStandardType format, int *frequency)
#endif
{
    unsigned long mode, flag;
    int retval = -1;

    *frequency = 0;

    switch (format) {
    case TV_STANDARD_NTSC:
        flag = GFX_MODE_TV_NTSC;
        break;
    case TV_STANDARD_PAL:
        flag = GFX_MODE_TV_PAL;
        break;
    default:
        return -1;
    }

    for (mode = 0; mode < NUM_TV_MODES; mode++) {
        if ((TVTimings[mode].hactive == width) &&
            (TVTimings[mode].vactive == height) &&
            (TVTimings[mode].flags & flag)) {
            *frequency = TVTimings[mode].frequency;
            retval = 1;
        }
    }
    return retval;
}

/*---------------------------------------------------------------------------
 * gfx_is_tv_display_mode_supported
 *
 * Returns >= 0 if the mode is available, -1 if the mode could not be found
 *---------------------------------------------------------------------------
 */
#if GFX_TV_DYNAMIC
int
sc1200_is_tv_display_mode_supported(unsigned short width,
                                    unsigned short height,
                                    TVStandardType format)
#else
int
gfx_is_tv_display_mode_supported(unsigned short width, unsigned short height,
                                 TVStandardType format)
#endif
{
    unsigned long mode, flag;

    switch (format) {
    case TV_STANDARD_NTSC:
        flag = GFX_MODE_TV_NTSC;
        break;
    case TV_STANDARD_PAL:
        flag = GFX_MODE_TV_PAL;
        break;
    default:
        return -1;
    }

    for (mode = 0; mode < NUM_TV_MODES; mode++) {
        if (TVTimings[mode].hactive == width &&
            TVTimings[mode].vactive == height &&
            (TVTimings[mode].flags & flag)) {
            return ((int) mode);
        }
    }

    return -1;
}

/* END OF FILE */