path: root/src/gfx/gfx_init.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 typically used in driver initialization.
  *
  * Routines:
  * 
  *       gfx_pci_config_read
  *       gfx_cpu_config_read
  *       gfx_detect_cpu
  *       gfx_detect_video
  *       gfx_get_cpu_register_base
  *       gfx_get_frame_buffer_base
  *       gfx_get_frame_buffer_size
  *       gfx_get_vid_register_base
  *       gfx_get_vip_register_base
  * */

/* CONSTANTS USED BY THE INITIALIZATION CODE */

#define PCI_CONFIG_ADDR			         0x0CF8
#define PCI_CONFIG_DATA			         0x0CFC
#define PCI_VENDOR_DEVICE_GXM	         0x00011078
#define PCI_VENDOR_DEVICE_REDCLOUD       0x0028100B
#define REDCLOUD_VIDEO_PCI_VENDOR_DEVICE 0x0030100B

#define GXM_CONFIG_GCR			0xB8
#define GXM_CONFIG_CCR3			0xC3
#define GXM_CONFIG_DIR0			0xFE
#define GXM_CONFIG_DIR1			0xFF

/* STATIC VARIABLES FOR THIS FILE */

unsigned long gfx_cpu_version = 0;
unsigned long gfx_cpu_frequency = 0;
unsigned long gfx_vid_version = 0;
unsigned long gfx_gx1_scratch_base = 0;
unsigned long gfx_gx2_scratch_base = 0x7FC000;
unsigned long gfx_pci_speed_khz = 33300;
ChipType gfx_chip_revision = CHIP_NOT_DETECTED;

ChipType gfx_detect_chip(void);

/* INCLUDE SUPPORT FOR FIRST GENERATION, IF SPECIFIED. */

#if GFX_INIT_GU1
#include "init_gu1.c"
#endif

/* INCLUDE SUPPORT FOR SECOND GENERATION, IF SPECIFIED. */

#if GFX_INIT_GU2
#include "init_gu2.c"
#endif

/* THE FOLLOWING ROUTINES ARE NEVER DYNAMIC              */
/* They are used to set the variables for future dynamic */
/* function calls.                                       */

/*----------------------------------------------------------------------------
 * gfx_detect_chip
 *
 * This routine returns the name and revision of the chip. This function is 
 * only relevant to the SC1200.
 *----------------------------------------------------------------------------
 */
ChipType
gfx_detect_chip(void)
{
    unsigned char pid = INB(SC1200_CB_BASE_ADDR + SC1200_CB_PID);
    unsigned char rev = INB(SC1200_CB_BASE_ADDR + SC1200_CB_REV);
    unsigned short clk = INW(SC1200_CB_BASE_ADDR + SC1200_CB_CCFC);

    gfx_chip_revision = CHIP_NOT_DETECTED;

    if (pid == 0x4) {
        switch (rev) {
        case 0:
            gfx_chip_revision = SC1200_REV_A;
            break;
        case 1:
            gfx_chip_revision = SC1200_REV_B1_B2;
            break;
        case 2:
            gfx_chip_revision = SC1200_REV_B3;
            break;
        case 3:
            gfx_chip_revision = SC1200_REV_C1;
            break;
        case 4:
            gfx_chip_revision = SC1200_REV_D1;
            break;
        case 5:
            gfx_chip_revision = SC1200_REV_D1_1;
            break;
        case 6:
            gfx_chip_revision = SC1200_REV_D2_MVD;
            break;
        }
        if (rev > 0x6)
            gfx_chip_revision = SC1200_FUTURE_REV;
    } else if (pid == 0x5) {
        if (rev == 0x6)
            gfx_chip_revision = SC1200_REV_D2_MVE;
        else if (rev > 0x6)
            gfx_chip_revision = SC1200_FUTURE_REV;
    }

    switch ((clk >> 8) & 3) {
    case 0:
    default:
        gfx_pci_speed_khz = 33300;
        break;
    case 1:
        gfx_pci_speed_khz = 48000;
        break;
    case 2:
        gfx_pci_speed_khz = 66600;
        break;
    }

    return (gfx_chip_revision);
}

/*----------------------------------------------------------------------------
 * gfx_detect_cpu
 * 
 * This routine returns the type and revison of the CPU.  If a Geode 
 * processor is not present, the routine returns zero.
 *
 * The return value is as follows:
 *     bits[24:16] = minor version
 *     bits[15:8] = major version 
 *     bits[7:0] = type (1 = GXm, 2 = SC1200, 3 = Redcloud)
 *
 * A return value of 0x00020501, for example, indicates GXm version 5.2.
 *----------------------------------------------------------------------------
 */
unsigned long
gfx_detect_cpu(void)
{

    unsigned long value = 0;
    unsigned long version = 0;

    /* initialize core freq. to 0 */
    gfx_cpu_frequency = 0;

#if	GFX_INIT_GU1

    value = gfx_pci_config_read(0x80000000);

    if (value == PCI_VENDOR_DEVICE_GXM) {
        unsigned char dir0 = gfx_gxm_config_read(GXM_CONFIG_DIR0) & 0xF0;
        unsigned char dir1 = gfx_gxm_config_read(GXM_CONFIG_DIR1);

        if (dir0 == 0x40) {
            /* CHECK FOR GXLV (and GXm) (DIR1 = 0x30 THROUGH 0x82) */

            if ((dir1 >= 0x30) && (dir1 <= 0x82)) {
                /* Major version is one less than what appears in DIR1 */
                if ((dir1 & 0xF0) < 0x70) {

                    version = GFX_CPU_GXLV | (((((unsigned long)dir1 >> 4) - 1) << 8)) |        /* major - 1 */
                        ((((unsigned long)dir1 & 0x0F)) << 16); /* minor */
                } else {
                    version = GFX_CPU_GXLV | ((((unsigned long)dir1 >> 4))
                        << 8) |        /* major */
                        ((((unsigned long)dir1 & 0x0F)) << 16); /* minor */
                }
                /* Currently always CS5530 for video overlay. */

#if GFX_VIDEO_DYNAMIC
                gfx_video_type = GFX_VIDEO_TYPE_CS5530;
#endif

                /* Currently always CS5530 GPIOs for I2C access. */

#if GFX_I2C_DYNAMIC
                gfx_i2c_type = GFX_I2C_TYPE_GPIO;
#endif

#if GFX_TV_DYNAMIC
                gfx_tv_type = GFX_TV_TYPE_FS451;
#endif
            }
        } else if (dir0 == 0xB0) {
            /* CHECK FOR SC1200 */

            if ((dir1 == 0x70) || (dir1 == 0x81)) {
                version = GFX_CPU_SC1200 | ((((unsigned long)dir1 >> 4))
                    << 8) |            /* major */
                    ((((unsigned long)dir1 & 0x0F)) << 16);     /* minor */

                /* Detect SC1200 revision */

                gfx_detect_chip();

                /* SC1200 for video overlay and VIP. */

#if GFX_VIDEO_DYNAMIC
                gfx_video_type = GFX_VIDEO_TYPE_SC1200;
#endif

#if GFX_VIP_DYNAMIC
                gfx_vip_type = GFX_VIP_TYPE_SC1200;
#endif

                /* Currently always SAA7114 decoder. */

#if GFX_DECODER_DYNAMIC
                gfx_decoder_type = GFX_DECODER_TYPE_SAA7114;
#endif

                /* SC1200 for TV encoder */

#if GFX_TV_DYNAMIC
                gfx_tv_type = GFX_TV_TYPE_SC1200;
#endif

                /* Currently always ACCESS.bus for I2C access. */

#if GFX_I2C_DYNAMIC
                gfx_i2c_type = GFX_I2C_TYPE_ACCESS;
#endif
            }
        }

        if (version) {
            /* ALWAYS FIRST GENERATION GRAPHICS UNIT */

#if GFX_DISPLAY_DYNAMIC
            gfx_display_type = GFX_DISPLAY_TYPE_GU1;
#endif
#if GFX_2DACCEL_DYNAMIC
            gfx_2daccel_type = GFX_2DACCEL_TYPE_GU1;
#endif
#if GFX_INIT_DYNAMIC
            gfx_init_type = GFX_INIT_TYPE_GU1;
#endif

            /* READ THE CORE FREQUENCY  */

            gfx_cpu_frequency = gfx_get_core_freq();
        }
    }
#endif

#if GFX_INIT_GU2

    value = gfx_pci_config_read(0x80000800);

    if (value == PCI_VENDOR_DEVICE_REDCLOUD) {
        Q_WORD msr_value;
        int valid, i;

        /* CHECK FOR SOFT VG */
        /* If SoftVG is not present, the base addresses for all devices */
        /* will not be allocated.  Essentially, it is as if no Redcloud */
        /* video hardware is present.                                   */

        value = gfx_pci_config_read(0x80000900);

        if (value == REDCLOUD_VIDEO_PCI_VENDOR_DEVICE) {
            valid = 1;

            /* BAR0 - BAR3 HOLD THE PERIPHERAL BASE ADDRESSES */

            for (i = 0; i < 4; i++) {
                value = gfx_pci_config_read(0x80000910 + (i << 2));
                if (value == 0x00000000 || value == 0xFFFFFFFF) {
                    valid = 0;
                    break;
                }
            }

            if (valid) {
                /* REDCLOUD INTEGRATED VIDEO             */

#if GFX_VIDEO_DYNAMIC
                gfx_video_type = GFX_VIDEO_TYPE_REDCLOUD;
#endif

                /* CURRENTLY, ALWAYS GPIO FOR I2C ACCESS */

#if GFX_I2C_DYNAMIC
                gfx_i2c_type = GFX_I2C_TYPE_GPIO;
#endif

                /* SECOND-GENERATION DISPLAY CONTROLLER  */

#if GFX_DISPLAY_DYNAMIC
                gfx_display_type = GFX_DISPLAY_TYPE_GU2;
#endif

                /* SECOND-GENERATION GRAPHICS UNIT       */

#if GFX_2DACCEL_DYNAMIC
                gfx_2daccel_type = GFX_2DACCEL_TYPE_GU2;
#endif

                /* SECOND-GENERATION INITIALIZATION      */

#if GFX_INIT_DYNAMIC
                gfx_init_type = GFX_INIT_TYPE_GU2;
#endif

                /* MBUS MSR ACCESSES                     */

#if GFX_MSR_DYNAMIC
                gfx_msr_type = GFX_MSR_TYPE_REDCLOUD;
#endif

                /* CS5530 GPIO I2C */

#if GFX_I2C_DYNAMIC
                gfx_i2c_type = GFX_I2C_TYPE_GPIO;
#endif

                /* READ VERSION */

                gfx_msr_init();

                gfx_msr_read(RC_ID_MCP, MCP_RC_REVID, &msr_value);

                /* SUBTRACT 1 FROM REV ID                                */
                /* REDCLOUD 1.X rev id is 1 less than the reported value */

                if ((msr_value.low & 0xF0) == 0x10)
                    msr_value.low--;

                version = GFX_CPU_REDCLOUD | ((msr_value.low & 0xF0) << 4) |    /* MAJOR */
                    ((msr_value.low & 0x0F) << 16);     /* MINOR */

                /* READ THE CORE FREQUENCY  */
				/* I can't find GX implementations that need
				 * this - we're trying to avoid virtual reads
				 * anyway, so bail on it
				 */

				/* gfx_cpu_frequency = gfx_get_core_freq(); */

                /* SET THE GP SCRATCH AREA */
                /* Color bitmap BLTs use the last 16K of frame buffer space */

                gfx_gx2_scratch_base = gfx_get_frame_buffer_size() - 0x4000;
            }
        }
    }

#endif

    if (!version) {
        /* ALWAYS SECOND GENERATION IF SIMULATING */
        /* For now, that is.  This could change.  */

#if GFX_DISPLAY_DYNAMIC
        gfx_display_type = GFX_DISPLAY_TYPE_GU2;
#endif
#if GFX_2DACCEL_DYNAMIC
        gfx_2daccel_type = GFX_2DACCEL_TYPE_GU2;
#endif
#if GFX_INIT_DYNAMIC
        gfx_init_type = GFX_INIT_TYPE_GU2;
#endif
#if GFX_MSR_DYNAMIC
        gfx_msr_type = GFX_MSR_TYPE_REDCLOUD;
#endif
#if GFX_VIDEO_DYNAMIC
        gfx_video_type = GFX_VIDEO_TYPE_REDCLOUD;
#endif
#if GFX_I2C_DYNAMIC
        gfx_i2c_type = GFX_I2C_TYPE_GPIO;
#endif
    }
    gfx_cpu_version = version;

    return (version);
}

/*----------------------------------------------------------------------------
 * gfx_detect_video
 * 
 * This routine returns the type of the video hardware.
 *
 * The return value is as follows:
 *     bits[7:0] = type (1 = CS5530, 2 = SC1200, 3 = Redcloud)
 *
 * Currently this routine does not actually detect any hardware, and bases
 * the video hardware entirely on the detected CPU.
 *----------------------------------------------------------------------------
 */
unsigned long
gfx_detect_video(void)
{
    unsigned long version = 0;

    if ((gfx_cpu_version & 0xFF) == GFX_CPU_GXLV)
        version = GFX_VID_CS5530;
    else if ((gfx_cpu_version & 0xFF) == GFX_CPU_SC1200)
        version = GFX_VID_SC1200;
    else if ((gfx_cpu_version & 0xFF) == GFX_CPU_REDCLOUD)
        version = GFX_VID_REDCLOUD;
    gfx_vid_version = version;
    return (version);
}

/*----------------------------------------------------------------------------
 * gfx_pci_config_read
 * 
 * This routine reads a 32-bit value from the specified location in PCI
 * configuration space.
 *----------------------------------------------------------------------------
 */
unsigned long
gfx_pci_config_read(unsigned long address)
{
    unsigned long value = 0xFFFFFFFF;

    OUTD(PCI_CONFIG_ADDR, address);
    value = IND(PCI_CONFIG_DATA);
    return (value);
}

/*----------------------------------------------------------------------------
 * gfx_pci_config_write
 * 
 * This routine writes a 32-bit value to the specified location in PCI
 * configuration space.
 *----------------------------------------------------------------------------
 */
void
gfx_pci_config_write(unsigned long address, unsigned long data)
{
    OUTD(PCI_CONFIG_ADDR, address);
    OUTD(PCI_CONFIG_DATA, data);
    return;
}

/* WRAPPERS IF DYNAMIC SELECTION */
/* Extra layer to call either first or second generation routines. */

#if GFX_INIT_DYNAMIC

/*----------------------------------------------------------------------------
 * gfx_get_core_freq
 *----------------------------------------------------------------------------
 */
unsigned long
gfx_get_core_freq(void)
{
    unsigned long freq = 0;

#if GFX_INIT_GU1
    if (gfx_init_type & GFX_INIT_TYPE_GU1)
        freq = gu1_get_core_freq();
#endif
#if GFX_INIT_GU2
    if (gfx_init_type & GFX_INIT_TYPE_GU2)
        freq = gu2_get_core_freq();
#endif

    return freq;
}

/*----------------------------------------------------------------------------
 * gfx_get_cpu_register_base
 *----------------------------------------------------------------------------
 */
unsigned long
gfx_get_cpu_register_base(void)
{
    unsigned long base = 0;

#if GFX_INIT_GU1
    if (gfx_init_type & GFX_INIT_TYPE_GU1)
        base = gu1_get_cpu_register_base();
#endif
#if GFX_INIT_GU2
    if (gfx_init_type & GFX_INIT_TYPE_GU2)
        base = gu2_get_cpu_register_base();
#endif

    return (base);
}

/*----------------------------------------------------------------------------
 * gfx_get_graphics_register_base
 *----------------------------------------------------------------------------
 */
unsigned long
gfx_get_graphics_register_base(void)
{
    unsigned long base = 0;

#if GFX_INIT_GU2
    if (gfx_init_type & GFX_INIT_TYPE_GU2)
        base = gu2_get_graphics_register_base();
#endif

    return (base);
}

/*----------------------------------------------------------------------------
 * gfx_get_frame_buffer_base
 *----------------------------------------------------------------------------
 */
unsigned long
gfx_get_frame_buffer_base(void)
{
    unsigned long base = 0;

#if GFX_INIT_GU1
    if (gfx_init_type & GFX_INIT_TYPE_GU1)
        base = gu1_get_frame_buffer_base();
#endif
#if GFX_INIT_GU2
    if (gfx_init_type & GFX_INIT_TYPE_GU2)
        base = gu2_get_frame_buffer_base();
#endif

    return (base);
}

/*----------------------------------------------------------------------------
 * gfx_get_frame_buffer_size
 *----------------------------------------------------------------------------
 */
unsigned long
gfx_get_frame_buffer_size(void)
{
    unsigned long size = 0;

#if GFX_INIT_GU1
    if (gfx_init_type & GFX_INIT_TYPE_GU1)
        size = gu1_get_frame_buffer_size();
#endif
#if GFX_INIT_GU2
    if (gfx_init_type & GFX_INIT_TYPE_GU2)
        size = gu2_get_frame_buffer_size();
#endif

    return size;
}

/*----------------------------------------------------------------------------
 * gfx_get_vid_register_base
 *----------------------------------------------------------------------------
 */
unsigned long
gfx_get_vid_register_base(void)
{
    unsigned long base = 0;

#if GFX_INIT_GU1
    if (gfx_init_type & GFX_INIT_TYPE_GU1)
        base = gu1_get_vid_register_base();
#endif
#if GFX_INIT_GU2
    if (gfx_init_type & GFX_INIT_TYPE_GU2)
        base = gu2_get_vid_register_base();
#endif

    return (base);
}

/*----------------------------------------------------------------------------
 * gfx_get_vip_register_base
 *----------------------------------------------------------------------------
 */
unsigned long
gfx_get_vip_register_base(void)
{
    unsigned long base = 0;

#if GFX_INIT_GU1
    if (gfx_init_type & GFX_INIT_TYPE_GU1)
        base = gu1_get_vip_register_base();
#endif

    return (base);
}

#endif

/* END OF FILE */