kolibrios/programs/system/drivers/rhd/rhd_mc.c

/*
 * Copyright 2007  Luc Verhaegen <lverhaegen@novell.com>
 * Copyright 2007  Matthias Hopf <mhopf@novell.com>
 * Copyright 2007  Egbert Eich   <eich@novell.com>
 * Copyright 2007  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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#if HAVE_XF86_ANSIC_H
# include "xf86_ansic.h"
#else
# include <unistd.h>
#endif

#include "xf86.h"

#include "rhd.h"
#include "rhd_regs.h"

Bool RHDMCIdle(RHDPtr rhdPtr, CARD32 count);

Bool RHDMCIdle(RHDPtr rhdPtr, CARD32 count);

struct rhdMC {
    CARD32 FbLocation;
    CARD32 HdpFbBase;
    CARD32 MiscLatencyTimer;
    Bool Stored;
    void (*SaveMC)(RHDPtr rhdPtr);
    void (*RestoreMC)(RHDPtr rhdPtr);
    void (*SetupMC)(RHDPtr rhdPtr);
    Bool (*MCIdle)(RHDPtr rhdPtr);
    CARD32 (*GetFBLocation)(RHDPtr rhdPtr, CARD32 *size);
    void (*TuneMCAccessForDisplay)(RHDPtr rhdPtr, int crtc,
				   DisplayModePtr Mode, DisplayModePtr ScaledToMode);
    Bool RV515Variant;
};

/*
 * Save MC_VM state.
 */
static void
rs600SaveMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    MC->FbLocation = RHDReadMC(rhdPtr, RS60_NB_FB_LOCATION);
    MC->HdpFbBase = RHDRegRead(rhdPtr, HDP_FB_LOCATION);
}

/*
 *
 */
static void
rs690SaveMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    MC->FbLocation = RHDReadMC(rhdPtr, RS69_MCCFG_FB_LOCATION);
    MC->HdpFbBase = RHDRegRead(rhdPtr, HDP_FB_LOCATION);
    MC->MiscLatencyTimer = RHDReadMC(rhdPtr, RS69_MC_INIT_MISC_LAT_TIMER);
}

/*
 *
 */
static void
r6xxSaveMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    MC->FbLocation = RHDRegRead(rhdPtr, R6XX_MC_VM_FB_LOCATION);
    MC->HdpFbBase = RHDRegRead(rhdPtr, R6XX_HDP_NONSURFACE_BASE);
}

/*
 *
 */
#ifdef NOTYET
static void
rs780SaveMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    MC->FbLocation = RHDReadMC(rhdPtr, RS78_MC_FB_LOCATION);
    /* RS780 uses the same register as R6xx */
    MC->HdpFbBase = RHDRegRead(rhdPtr, R6XX_HDP_NONSURFACE_BASE);
}
#endif

/*
 *
 */
static void
r7xxSaveMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    MC->FbLocation = RHDRegRead(rhdPtr, R7XX_MC_VM_FB_LOCATION);
    MC->HdpFbBase = RHDRegRead(rhdPtr, R6XX_HDP_NONSURFACE_BASE);
}

/*
 *
 */
static void
r5xxRestoreMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    if (MC->RV515Variant) {
	RHDWriteMC(rhdPtr, MC_IND_ALL |  RV515_MC_FB_LOCATION,
		   MC->FbLocation);
	RHDWriteMC(rhdPtr, MC_IND_ALL |  RV515_MC_MISC_LAT_TIMER,
		   MC->MiscLatencyTimer);
    } else
	RHDWriteMC(rhdPtr, MC_IND_ALL | R5XX_MC_FB_LOCATION,
		   MC->FbLocation);
    RHDRegWrite(rhdPtr, HDP_FB_LOCATION, MC->HdpFbBase);
}

/*
 *
 */
static void
rs600RestoreMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    RHDWriteMC(rhdPtr, RS60_NB_FB_LOCATION, MC->FbLocation);
    RHDRegWrite(rhdPtr, HDP_FB_LOCATION, MC->HdpFbBase);
}

/*
 *
 */
static void
rs690RestoreMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    RHDWriteMC(rhdPtr,  RS69_MCCFG_FB_LOCATION, MC->FbLocation);
    RHDRegWrite(rhdPtr, HDP_FB_LOCATION, MC->HdpFbBase);
    RHDWriteMC(rhdPtr,  RS69_MC_INIT_MISC_LAT_TIMER, MC->MiscLatencyTimer);
}

/*
 *
 */
static void
r6xxRestoreMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    RHDRegWrite(rhdPtr, R6XX_MC_VM_FB_LOCATION, MC->FbLocation);
    RHDRegWrite(rhdPtr, R6XX_HDP_NONSURFACE_BASE, MC->HdpFbBase);
}

/*
 *
 */
#ifdef NOTYET
static void
rs780RestoreMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    RHDWriteMC(rhdPtr, RS78_MC_FB_LOCATION, MC->FbLocation);
    /* RS780 uses the same register as R6xx */
    RHDRegWrite(rhdPtr, R6XX_HDP_NONSURFACE_BASE, MC->HdpFbBase);
}
#endif

/*
 *
 */
static void
r7xxRestoreMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    RHDRegWrite(rhdPtr, R7XX_MC_VM_FB_LOCATION, MC->FbLocation);
    RHDRegWrite(rhdPtr, R6XX_HDP_NONSURFACE_BASE, MC->HdpFbBase);
}

/*
 * Setup the MC
 */

/*
 *
 */
static void
r5xxSetupMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;
    CARD32 fb_location, fb_location_tmp;
    CARD16 fb_size;
    unsigned int reg;

    RHDFUNC(rhdPtr);


    if (MC->RV515Variant)
	reg = RV515_MC_FB_LOCATION | MC_IND_ALL;
    else
	reg = R5XX_MC_FB_LOCATION | MC_IND_ALL;

    fb_location = RHDReadMC(rhdPtr, reg);
    fb_size = (fb_location >> 16) - (fb_location & 0xFFFF);
    fb_location_tmp = rhdPtr->FbIntAddress >> 16;
    fb_location_tmp |= (fb_location_tmp + fb_size) << 16;

    RHDDebug(rhdPtr->scrnIndex, "%s: fb_location: 0x%08X "
	     "[fb_size: 0x%04X] -> fb_location: 0x%08X\n",
	     __func__, (unsigned int)fb_location,
	     fb_size,(unsigned int)fb_location_tmp);
    RHDWriteMC(rhdPtr, reg, fb_location_tmp);
    RHDRegWrite(rhdPtr, HDP_FB_LOCATION, fb_location_tmp & 0xFFFF);
}

/*
 *
 */
static void
rs600SetupMC(RHDPtr rhdPtr)
{
    CARD32 fb_location, fb_location_tmp;
    CARD16 fb_size;

    RHDFUNC(rhdPtr);

    fb_location = RHDReadMC(rhdPtr, RS60_NB_FB_LOCATION);
    fb_size = (fb_location >> 16) - (fb_location & 0xFFFF);
    fb_location_tmp = rhdPtr->FbIntAddress >> 16;
    fb_location_tmp |= (fb_location_tmp + fb_size) << 16;

    RHDDebug(rhdPtr->scrnIndex, "%s: fb_location: 0x%08X "
	     "[fb_size: 0x%04X] -> fb_location: 0x%08X\n",
	     __func__, (unsigned int)fb_location,
	     fb_size,(unsigned int)fb_location_tmp);
    RHDWriteMC(rhdPtr, RS60_NB_FB_LOCATION, fb_location_tmp);
    RHDRegWrite(rhdPtr, HDP_FB_LOCATION, fb_location_tmp & 0xFFFF); /* same ;) */
}

/*
 *
 */
static void
rs690SetupMC(RHDPtr rhdPtr)
{
    CARD32 fb_location, fb_location_tmp;
    CARD16 fb_size;

    RHDFUNC(rhdPtr);

    fb_location = RHDReadMC(rhdPtr, RS69_MCCFG_FB_LOCATION);
    fb_size = (fb_location >> 16) - (fb_location & 0xFFFF);
    fb_location_tmp = rhdPtr->FbIntAddress >> 16;
    fb_location_tmp |= (fb_location_tmp + fb_size) << 16;

    RHDDebug(rhdPtr->scrnIndex, "%s: fb_location: 0x%08X "
	     "[fb_size: 0x%04X] -> fb_location: 0x%08X\n",
	     __func__, (unsigned int)fb_location,
	     fb_size,(unsigned int)fb_location_tmp);
    RHDWriteMC(rhdPtr, RS69_MCCFG_FB_LOCATION, fb_location_tmp);
    RHDRegWrite(rhdPtr, HDP_FB_LOCATION, fb_location_tmp & 0xFFFF);
}

/*
 *
 */
static void
r6xxSetupMC(RHDPtr rhdPtr)
{
    CARD32 fb_location, fb_location_tmp, hdp_fbbase_tmp;
    CARD16 fb_size;

    RHDFUNC(rhdPtr);

    fb_location = RHDRegRead(rhdPtr, R6XX_MC_VM_FB_LOCATION);
    fb_size = (fb_location >> 16) - (fb_location & 0xFFFF);
    fb_location_tmp = rhdPtr->FbIntAddress >> 24;
    fb_location_tmp |= (fb_location_tmp + fb_size) << 16;
    hdp_fbbase_tmp = (rhdPtr->FbIntAddress >> 8) & 0xff0000;

    RHDDebug(rhdPtr->scrnIndex, "%s: fb_location: 0x%08X "
	     "fb_offset: 0x%08X [fb_size: 0x%04X] -> fb_location: 0x%08X "
	     "fb_offset: 0x%08X\n",
	     __func__, (unsigned int)fb_location,
	     RHDRegRead(rhdPtr,R6XX_HDP_NONSURFACE_BASE), fb_size,
	     (unsigned int)fb_location_tmp, (unsigned int)hdp_fbbase_tmp);

    RHDRegWrite(rhdPtr, R6XX_MC_VM_FB_LOCATION, fb_location_tmp);
    RHDRegWrite(rhdPtr, R6XX_HDP_NONSURFACE_BASE, hdp_fbbase_tmp);
}

/*
 *
 */
#ifdef NOTYET
static void
rs780SetupMC(RHDPtr rhdPtr)
{
    CARD32 fb_location, fb_location_tmp, hdp_fbbase_tmp;
    CARD16 fb_size;

    RHDFUNC(rhdPtr);

    fb_location = RHDReadMC(rhdPtr, RS78_MC_FB_LOCATION);
    fb_size = (fb_location >> 16) - (fb_location & 0xFFFF);
    fb_location_tmp = rhdPtr->FbIntAddress >> 16;
    fb_location_tmp |= (fb_location_tmp + fb_size) << 16;
    hdp_fbbase_tmp = (rhdPtr->FbIntAddress >> 8) & 0xff0000;

    RHDDebug(rhdPtr->scrnIndex, "%s: fb_location: 0x%08X "
	     "[fb_size: 0x%04X] -> fb_location: 0x%08X\n",
	     __func__, (unsigned int)fb_location,
	     fb_size,(unsigned int)fb_location_tmp);
    RHDWriteMC(rhdPtr, RS78_MC_FB_LOCATION, fb_location_tmp);
    /* RS780 uses the same register as R6xx */
    RHDRegWrite(rhdPtr, R6XX_HDP_NONSURFACE_BASE, hdp_fbbase_tmp);
}
#endif

/*
 *
 */
static void
r7xxSetupMC(RHDPtr rhdPtr)
{
    CARD32 fb_location, fb_location_tmp, hdp_fbbase_tmp;
    CARD16 fb_size;

    RHDFUNC(rhdPtr);

    fb_location = RHDRegRead(rhdPtr, R7XX_MC_VM_FB_LOCATION);
    fb_size = (fb_location >> 16) - (fb_location & 0xFFFF);
    fb_location_tmp = rhdPtr->FbIntAddress >> 24;
    fb_location_tmp |= (fb_location_tmp + fb_size) << 16;
    hdp_fbbase_tmp = (rhdPtr->FbIntAddress >> 8) & 0xff0000;

    RHDDebug(rhdPtr->scrnIndex, "%s: fb_location: 0x%08X "
	     "fb_offset: 0x%08X [fb_size: 0x%04X] -> fb_location: 0x%08X "
	     "fb_offset: 0x%08X\n",
	     __func__, (unsigned int)fb_location,
	     RHDRegRead(rhdPtr,R6XX_HDP_NONSURFACE_BASE), fb_size,
	     (unsigned int)fb_location_tmp, (unsigned int)hdp_fbbase_tmp);

    RHDRegWrite(rhdPtr, R7XX_MC_VM_FB_LOCATION, fb_location_tmp);
    RHDRegWrite(rhdPtr, R6XX_HDP_NONSURFACE_BASE, hdp_fbbase_tmp);
}

/*
 *
 */
void
RHDMCSetup(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;
    RHDFUNC(rhdPtr);

    if (!MC)
	return;
    /*
     * make sure the hw is in a state such that we can update
     * the MC - ie no subsystem is currently accessing memory.
     */
    ASSERT((RHDRegRead(rhdPtr, D1VGA_CONTROL) & D1VGA_MODE_ENABLE) != D1VGA_MODE_ENABLE);
    ASSERT((RHDRegRead(rhdPtr, D2VGA_CONTROL) & D2VGA_MODE_ENABLE) != D2VGA_MODE_ENABLE);
    ASSERT((RHDRegRead(rhdPtr, D1CRTC_CONTROL) & 0x1) != 0x1);
    ASSERT((RHDRegRead(rhdPtr, D2CRTC_CONTROL) & 0x1) != 0x1);
    ASSERT(RHDMCIdle(rhdPtr, 1));

    MC->SetupMC(rhdPtr);
}

/*
 * Get FB location and size.
 */
static CARD32
r5xxGetFBLocation(RHDPtr rhdPtr, CARD32 *size)
{
    struct rhdMC *MC = rhdPtr->MC;
    CARD32 val;
    CARD32 reg;

    if (MC->RV515Variant)
	reg = RV515_MC_FB_LOCATION | MC_IND_ALL;
    else
	reg = R5XX_MC_FB_LOCATION | MC_IND_ALL;

	val = RHDReadMC(rhdPtr, reg);

    if (size) *size = ((val >> 16) - (val & 0xFFFF)) << 16;

    return (val & 0xFFFF) << 16;
}

/*
 *
 */
static CARD32
rs600GetFBLocation(RHDPtr rhdPtr, CARD32 *size)
{
    CARD32 val = RHDReadMC(rhdPtr, RS60_NB_FB_LOCATION);

    if (size) *size = ((val >> 16) - (val & 0xFFFF)) << 16;

    return (val & 0xFFFF) << 16;
}

/*
 *
 */
static CARD32
rs690GetFBLocation(RHDPtr rhdPtr, CARD32 *size)
{
    CARD32 val = RHDReadMC(rhdPtr, RS69_MCCFG_FB_LOCATION);

    if (size) *size = ((val >> 16) - (val & 0xFFFF)) << 16;

    return (val & 0xFFFF) << 16;
}

/*
 *
 */
static CARD32
r6xxGetFBLocation(RHDPtr rhdPtr, CARD32 *size)
{
    CARD32 val = RHDRegRead(rhdPtr, R6XX_MC_VM_FB_LOCATION);

    if (size) *size = ((val >> 16) - (val & 0xFFFF)) << 24;

    return (val & 0xFFFF) << 24;
}

/*
 *
 */
#ifdef NOTYET
static CARD32
rs780GetFBLocation(RHDPtr rhdPtr, CARD32 *size)
{
    CARD32 val = RHDReadMC(rhdPtr, RS78_MC_FB_LOCATION);
    if (size) *size = ((val >> 16) - (val & 0xFFFF)) << 16;

    return (val & 0xFFFF) << 16;
}
#endif

/*
 *
 */
static CARD32
r7xxGetFBLocation(RHDPtr rhdPtr, CARD32 *size)
{
    CARD32 val = RHDRegRead(rhdPtr, R7XX_MC_VM_FB_LOCATION);

    if (size) *size = ((val >> 16) - (val & 0xFFFF)) << 24;

    return (val & 0xFFFF) << 24;
}

/*
 *
 */
CARD32
RHDGetFBLocation(RHDPtr rhdPtr, CARD32 *size)
{
    struct rhdMC *MC = rhdPtr->MC;
    RHDFUNC(rhdPtr);

    if (!MC) {
	if (size) *size = 0;
	return 0;
    }

    return MC->GetFBLocation(rhdPtr, size);
}

/*
 *
 */
static Bool
rv515MCIdle(RHDPtr rhdPtr)
{
    RHDFUNC(rhdPtr);

    if (RHDReadMC(rhdPtr, MC_IND_ALL | RV515_MC_STATUS) & RV515_MC_IDLE)
	return TRUE;
    return FALSE;
}


/*
 *
 */
static Bool
r5xxMCIdle(RHDPtr rhdPtr)
{
    RHDFUNC(rhdPtr);

    if (RHDReadMC(rhdPtr, MC_IND_ALL | R5XX_MC_STATUS) & R5XX_MC_IDLE)
	return TRUE;
    return FALSE;
}

/*
 *
 */
static Bool
rs600MCIdle(RHDPtr rhdPtr)
{
    RHDFUNC(rhdPtr);

    if (RHDReadMC(rhdPtr, RS60_MC_SYSTEM_STATUS) & RS6X_MC_SEQUENCER_IDLE)
	return TRUE;
    return FALSE;
}

/*
 *
 */
static Bool
rs690MCIdle(RHDPtr rhdPtr)
{
    RHDFUNC(rhdPtr);

    if (RHDReadMC(rhdPtr, RS69_MC_SYSTEM_STATUS) & RS6X_MC_SEQUENCER_IDLE)
	return TRUE;
    return FALSE;
}

/*
 *
 */
static Bool
r6xxMCIdle(RHDPtr rhdPtr)
{
    RHDFUNC(rhdPtr);

    if (!(RHDRegRead(rhdPtr, SRBM_STATUS) & 0x3f00))
	return TRUE;
    return FALSE;
}

/*
 *
 */
#ifdef NOTYET
static Bool
rs780MCIdle(RHDPtr rhdPtr)
{
    RHDFUNC(rhdPtr);

    if (RHDReadMC(rhdPtr, RS78_MC_SYSTEM_STATUS) & RS78_MC_SEQUENCER_IDLE)
	return TRUE;
    return FALSE;
}
#endif

/*
 *
 */
Bool
RHDMCIdle(RHDPtr rhdPtr, CARD32 count)
{
    struct rhdMC *MC = rhdPtr->MC;
    RHDFUNC(rhdPtr);

    if (!MC)
	return TRUE;

    do {
	if (MC->MCIdle(rhdPtr))
	    return TRUE;
	usleep(10);
    } while (count--);

    RHDDebug(rhdPtr->scrnIndex, "%s: MC not idle\n",__func__);

    return FALSE;
}

/*
 *
 */
void
RHDSaveMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;
    RHDFUNC(rhdPtr);

    if (!MC)
	return;

    MC->SaveMC(rhdPtr);

    MC->Stored = TRUE;
}

/*
 * Restore MC VM state.
 */
void
RHDRestoreMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;
    RHDFUNC(rhdPtr);

    if (!MC)
	return;

    if (!MC->Stored) {
	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR,
		   "%s: trying to restore uninitialized values.\n",__func__);
	return;
    }
    /*
     * make sure the hw is in a state such that we can update
     * the MC - ie no subsystem is currently accessing memory.
     */
    ASSERT((RHDRegRead(rhdPtr, D1VGA_CONTROL) & D1VGA_MODE_ENABLE) != D1VGA_MODE_ENABLE);
    ASSERT((RHDRegRead(rhdPtr, D2VGA_CONTROL) & D2VGA_MODE_ENABLE) != D2VGA_MODE_ENABLE);
    ASSERT((RHDRegRead(rhdPtr, D1CRTC_CONTROL) & 0x1) != 0x1);
    ASSERT((RHDRegRead(rhdPtr, D2CRTC_CONTROL) & 0x1) != 0x1);
    ASSERT(RHDMCIdle(rhdPtr, 1));

    MC->RestoreMC(rhdPtr);
}

/*
 *
 */
static void
r5xxSaveMC(RHDPtr rhdPtr)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    if (MC->RV515Variant) {
	MC->FbLocation = RHDReadMC(rhdPtr, MC_IND_ALL | RV515_MC_FB_LOCATION);
	MC->MiscLatencyTimer = RHDReadMC(rhdPtr, MC_IND_ALL | RV515_MC_MISC_LAT_TIMER);
    } else
	MC->FbLocation = RHDReadMC(rhdPtr, MC_IND_ALL | R5XX_MC_FB_LOCATION);
    MC->HdpFbBase = RHDRegRead(rhdPtr, HDP_FB_LOCATION);
}

/*
 *
 */
static void
rv515TuneMCAccessForDisplay(RHDPtr rhdPtr, int crtc,
				   DisplayModePtr Mode, DisplayModePtr ScaledToMode)
{
    CARD32 value, setting = 0x1;

    RHDFUNC(rhdPtr);

    value = RHDReadMC(rhdPtr,  RV515_MC_MISC_LAT_TIMER);

    value |= (setting << (crtc ? MC_DISP1R_INIT_LAT_SHIFT : MC_DISP0R_INIT_LAT_SHIFT));
    RHDWriteMC(rhdPtr,  RV515_MC_MISC_LAT_TIMER, value);
}

/*
 *
 */
static void
rs690TuneMCAccessForDisplay(RHDPtr rhdPtr, int crtc,
				   DisplayModePtr Mode, DisplayModePtr ScaledToMode)
{
    CARD32 value, setting = 0x1;

    RHDFUNC(rhdPtr);

    value = RHDReadMC(rhdPtr,  RS69_MC_INIT_MISC_LAT_TIMER);
    value |= setting << (crtc ? MC_DISP1R_INIT_LAT_SHIFT : MC_DISP0R_INIT_LAT_SHIFT);
    RHDWriteMC(rhdPtr,  RS69_MC_INIT_MISC_LAT_TIMER, value);
}

/*
 *
 */
void
RHDTuneMCAccessForDisplay(RHDPtr rhdPtr, int crtc,
				   DisplayModePtr Mode, DisplayModePtr ScaledToMode)
{
    struct rhdMC *MC = rhdPtr->MC;

    RHDFUNC(rhdPtr);

    if (MC->TuneMCAccessForDisplay)
	MC->TuneMCAccessForDisplay(rhdPtr, crtc, Mode, ScaledToMode);
}

/*
 *
 */
void
RHDMCInit(RHDPtr rhdPtr)
{
    struct rhdMC *MC;

    RHDFUNC(rhdPtr);

    /* These devices have an internal address reference, which some other
     * address registers in there also use. This can be different from the
     * address in the BAR.
     *
     * We read out the address here from some known location. This address
     * is as good a guess as any, we just need to pick one, but then make
     * sure that it is made consistent in MCSetup and the various MC
     * accessing subsystems.
     */
    if (rhdPtr->ChipSet < RHD_R600)
	rhdPtr->FbIntAddress = RHDRegRead(rhdPtr, HDP_FB_LOCATION) << 16;
    else
	rhdPtr->FbIntAddress = RHDRegRead(rhdPtr, R6XX_CONFIG_FB_BASE);

    RHDDebug(rhdPtr->scrnIndex, "MC FB Address: 0x%08X.\n",
	     rhdPtr->FbIntAddress);

    MC = xnfcalloc(1, sizeof(struct rhdMC));
    MC->Stored = FALSE;

    if (rhdPtr->ChipSet < RHD_RS600) {
	MC->SaveMC = r5xxSaveMC;
	MC->RestoreMC = r5xxRestoreMC;
	MC->SetupMC = r5xxSetupMC;
	MC->GetFBLocation = r5xxGetFBLocation;

	if (rhdPtr->ChipSet == RHD_RV515
	    || rhdPtr->ChipSet == RHD_RV505
	    || rhdPtr->ChipSet == RHD_RV516
	    || rhdPtr->ChipSet == RHD_RV550
	    || rhdPtr->ChipSet == RHD_M52
	    || rhdPtr->ChipSet == RHD_M54
	    || rhdPtr->ChipSet == RHD_M62
	    || rhdPtr->ChipSet == RHD_M64
	    || rhdPtr->ChipSet == RHD_M71) {

	    MC->RV515Variant = TRUE;
	    MC->MCIdle = rv515MCIdle;
	    MC->TuneMCAccessForDisplay = rv515TuneMCAccessForDisplay;
	} else {

	    MC->RV515Variant = FALSE;
	    MC->MCIdle = r5xxMCIdle;

	}

    } else if (rhdPtr->ChipSet == RHD_RS600) {
	MC->SaveMC = rs600SaveMC;
	MC->RestoreMC = rs600RestoreMC;
	MC->SetupMC = rs600SetupMC;
	MC->MCIdle = rs600MCIdle;
	MC->GetFBLocation = rs600GetFBLocation;
    } else if (rhdPtr->ChipSet < RHD_R600) {
	MC->SaveMC = rs690SaveMC;
	MC->RestoreMC = rs690RestoreMC;
	MC->SetupMC = rs690SetupMC;
	MC->MCIdle = rs690MCIdle;
	MC->GetFBLocation = rs690GetFBLocation;
	MC->TuneMCAccessForDisplay = rs690TuneMCAccessForDisplay;
    } else if (rhdPtr->ChipSet <= RHD_RS780) {
	MC->SaveMC = r6xxSaveMC;
	MC->RestoreMC = r6xxRestoreMC;
	MC->SetupMC = r6xxSetupMC;
	MC->MCIdle = r6xxMCIdle;
	MC->GetFBLocation = r6xxGetFBLocation;
    }
#if 0
    else if (rhdPtr->ChipSet == RHD_RS780) {
	MC->SaveMC = rs780SaveMC;
	MC->RestoreMC = rs780RestoreMC;
	MC->SetupMC = rs780SetupMC;
	MC->MCIdle = rs780MCIdle;
	MC->GetFBLocation = rs780GetFBLocation;
    }
#endif
    else if (rhdPtr->ChipSet >= RHD_RV770) {
	MC->SaveMC = r7xxSaveMC;
	MC->RestoreMC = r7xxRestoreMC;
	MC->SetupMC = r7xxSetupMC;
	MC->MCIdle = r6xxMCIdle;
	MC->GetFBLocation = r7xxGetFBLocation;
    } else {
	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR, "I don't know anything about MC on this chipset\n");
	xfree(MC);
	return;
    }
    rhdPtr->MC = MC;

}

/*
 * Free structure.
 */
void
RHDMCDestroy(RHDPtr rhdPtr)
{
    RHDFUNC(rhdPtr);

    if (!rhdPtr->MC)
	return;

    xfree(rhdPtr->MC);
    rhdPtr->MC = NULL;
}

/*
 *
 */
Bool
RHD_MC_IGP_SideportMemoryPresent(RHDPtr rhdPtr)
{
    Bool Present = FALSE;

    RHDFUNC(rhdPtr);

    switch (rhdPtr->ChipSet) {
	case RHD_RS690:
	case RHD_RS740:
	    Present = (RHDReadMC(rhdPtr, RS69_MC_MISC_UMA_CNTL) & RS69_SIDE_PORT_PRESENT_R) != 0;
	    break;
	case RHD_RS780:
	    Present = (RHDReadMC(rhdPtr, RS78_MC_MISC_UMA_CNTL) & RS78_SIDE_PORT_PRESENT_R) != 0;
	    break;
	default:
	    break;
    }
    xf86DrvMsg(rhdPtr->scrnIndex, X_INFO, "IPG sideport memory %s present.\n", Present ? "" : "not");

    return Present;
}