/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/nsc/gfx/msr_rdcl.c,v 1.1 2002/12/10 15:12:27 alanh Exp $ */
/*
 * $Workfile: msr_rdcl.c $
 *
 * This file contains MSR access routines for Redcloud.
 *
 * NSC_LIC_ALTERNATIVE_PREAMBLE
 *
 * Revision 1.0
 *
 * National Semiconductor Alternative GPL-BSD License
 *
 * National Semiconductor Corporation licenses this software 
 * ("Software"):
 *
 *      Durango
 *
 * under one of the two following licenses, depending on how the 
 * Software is received by the Licensee.
 * 
 * If this Software is received as part of the Linux Framebuffer or
 * other GPL licensed software, then the GPL license designated 
 * NSC_LIC_GPL applies to this Software; in all other circumstances 
 * then the BSD-style license designated NSC_LIC_BSD shall apply.
 *
 * END_NSC_LIC_ALTERNATIVE_PREAMBLE */

/* NSC_LIC_BSD
 *
 * National Semiconductor Corporation Open Source License for Durango
 *
 * (BSD License with Export Notice)
 *
 * Copyright (c) 1999-2001
 * National Semiconductor Corporation.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions 
 * are met: 
 *
 *   * Redistributions of source code must retain the above copyright 
 *     notice, this list of conditions and the following disclaimer. 
 *
 *   * Redistributions in binary form must reproduce the above 
 *     copyright notice, this list of conditions and the following 
 *     disclaimer in the documentation and/or other materials provided 
 *     with the distribution. 
 *
 *   * Neither the name of the National Semiconductor Corporation nor 
 *     the names of its contributors may be used to endorse or promote 
 *     products derived from this software without specific prior 
 *     written permission. 
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
 * NATIONAL SEMICONDUCTOR CORPORATION OR CONTRIBUTORS BE LIABLE FOR ANY 
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE,
 * INTELLECTUAL PROPERTY INFRINGEMENT, OR OTHERWISE) ARISING IN ANY WAY 
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
 * OF SUCH DAMAGE.
 *
 * EXPORT LAWS: THIS LICENSE ADDS NO RESTRICTIONS TO THE EXPORT LAWS OF 
 * YOUR JURISDICTION. It is licensee's responsibility to comply with 
 * any export regulations applicable in licensee's jurisdiction. Under 
 * CURRENT (2001) U.S. export regulations this software 
 * is eligible for export from the U.S. and can be downloaded by or 
 * otherwise exported or reexported worldwide EXCEPT to U.S. embargoed 
 * destinations which include Cuba, Iraq, Libya, North Korea, Iran, 
 * Syria, Sudan, Afghanistan and any other country to which the U.S. 
 * has embargoed goods and services. 
 *
 * END_NSC_LIC_BSD */

/* NSC_LIC_GPL
 *
 * National Semiconductor Corporation Gnu General Public License for Durango
 *
 * (GPL License with Export Notice)
 *
 * Copyright (c) 1999-2001
 * National Semiconductor Corporation.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted under the terms of the GNU General 
 * Public License as published by the Free Software Foundation; either 
 * version 2 of the License, or (at your option) any later version  
 *
 * In addition to the terms of the GNU General Public License, neither 
 * the name of the National Semiconductor Corporation nor the names of 
 * its contributors may be used to endorse or promote products derived 
 * from this software without specific prior written permission. 
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
 * NATIONAL SEMICONDUCTOR CORPORATION OR CONTRIBUTORS BE LIABLE FOR ANY 
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE, 
 * INTELLECTUAL PROPERTY INFRINGEMENT, OR OTHERWISE) ARISING IN ANY WAY 
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
 * OF SUCH DAMAGE. See the GNU General Public License for more details. 
 *
 * EXPORT LAWS: THIS LICENSE ADDS NO RESTRICTIONS TO THE EXPORT LAWS OF 
 * YOUR JURISDICTION. It is licensee's responsibility to comply with 
 * any export regulations applicable in licensee's jurisdiction. Under 
 * CURRENT (2001) U.S. export regulations this software 
 * is eligible for export from the U.S. and can be downloaded by or 
 * otherwise exported or reexported worldwide EXCEPT to U.S. embargoed 
 * destinations which include Cuba, Iraq, Libya, North Korea, Iran, 
 * Syria, Sudan, Afghanistan and any other country to which the U.S. 
 * has embargoed goods and services. 
 *
 * You should have received a copy of the GNU General Public License 
 * along with this file; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
 *
 * END_NSC_LIC_GPL */

int redcloud_msr_init(void);
DEV_STATUS redcloud_id_msr_device(MSR * pDev, unsigned long address);
DEV_STATUS redcloud_get_msr_dev_address(unsigned int device,
					unsigned long *address);
DEV_STATUS redcloud_get_glink_id_at_address(unsigned int *device,
					    unsigned long address);
DEV_STATUS redcloud_msr_read(unsigned int device, unsigned int msrRegister,
			     Q_WORD * msrValue);
DEV_STATUS redcloud_msr_write(unsigned int device, unsigned int msrRegister,
			      Q_WORD * msrValue);

void redcloud_build_mbus_tree(void);	/* private routine definition */
int redcloud_init_msr_devices(MSR aDev[], unsigned int array_size);	/* private routine definition */
DEV_STATUS redcloud_find_msr_device(MSR * pDev);	/* private routine definition */

/* REDCLOUD MSR BITMASKS */

#define MBD_MSR_CAP			0x2000
#define MSR_CAP_ID_MASK		0xFF000
#define MSR_CAP_ID_SHIFT  	12
#define MSR_CAP_REV_MASK    0x0F
#define MBIU_CAP			0x86
#define NUM_PORTS_MASK		0x00380000
#define NUM_PORTS_SHIFT  	19
#define MBIU_WHOAMI			0x8B
#define WHOAMI_MASK			0x07

/* REDCLOUD and CS5535 MSR DEVICES */

MSR msrDev[] = {
   {FOUND, RC_CC_MBIU, RC_MB0_MBIU0},
   {FOUND, RC_CC_MBIU, RC_MB0_MBIU1},
   {NOT_KNOWN, RC_CC_MCP, FAKE_ADDRESS},
   {NOT_KNOWN, RC_CC_MPCI, FAKE_ADDRESS},
   {NOT_KNOWN, RC_CC_MC, FAKE_ADDRESS},
   {NOT_KNOWN, RC_CC_GP, FAKE_ADDRESS},
   {NOT_KNOWN, RC_CC_VG, FAKE_ADDRESS},
   {NOT_KNOWN, RC_CC_DF, FAKE_ADDRESS},
   {NOT_KNOWN, RC_CC_FG, FAKE_ADDRESS},
   {FOUND, RC_CC_VA, RC_MB0_CPU},
   {FOUND, CP_CC_MBIU, CP_MB0_MBIU0},
   {NOT_KNOWN, CP_CC_MPCI, FAKE_ADDRESS},
   {NOT_KNOWN, CP_CC_USB2, FAKE_ADDRESS},
   {NOT_KNOWN, CP_CC_ATAC, FAKE_ADDRESS},
   {NOT_KNOWN, CP_CC_MDD, FAKE_ADDRESS},
   {NOT_KNOWN, CP_CC_ACC, FAKE_ADDRESS},
   {NOT_KNOWN, CP_CC_USB1, FAKE_ADDRESS},
   {NOT_KNOWN, CP_CC_MCP, FAKE_ADDRESS},
};

#define NUM_DEVS sizeof(msrDev) / sizeof(struct msr)

/* CAPISTRANO DEVICE INDEX LIMITS */
/* These defines represent the start and stop indexes into the device array  */
/* for all Capistrano devices.  These should be updated whenever a device is */
/* added or removed to the Capistrano list.                                  */

#define CP_INDEX_START CP_ID_MBIU
#define CP_INDEX_STOP  CP_ID_MCP

/* GLOBAL MBUS CACHE STRUCTURES */
/* These structures contain a "cached" copy of the MBUS topology */
/* for easy future lookup.                                       */

MBUS_NODE MBIU0[8], MBIU1[8], MBIU2[8];

/* REGISTER MACROS */

#define GET_DEVICE_ID( CAPABILITIES_HIGH, CAPABILITIES_LOW ) \
					 ((unsigned int)(( (CAPABILITIES_LOW) & MSR_CAP_ID_MASK ) >> MSR_CAP_ID_SHIFT ))

#define GET_NUM_PORTS( MBIU_CAP_HIGH, MBIU_CAP_LOW ) (((MBIU_CAP_HIGH) & NUM_PORTS_MASK ) >> NUM_PORTS_SHIFT)

/*-----------------------------------------------------------------------------
 * gfx_msr_init
 * 
 * This routine initializes the base addresses of all known MBUS devices.  
 *-----------------------------------------------------------------------------
 */
#if GFX_MSR_DYNAMIC
int
redcloud_msr_init(void)
#else
int
gfx_msr_init(void)
#endif
{
   Q_WORD msrValue;
   int return_value = 1;

   /* CHECK FOR VALID MBUS CONFIGURATION */
   /* The CPU and the two MBIUs are assumed to be at known static addresses, so */
   /* we will check the device IDs at these addresses as proof of a valid mbus  */
   /* configuration.                                                            */

   MSR_READ(MBD_MSR_CAP, RC_MB0_CPU, &(msrValue.high), &(msrValue.low));
   if (GET_DEVICE_ID(msrValue.high, msrValue.low) != RC_CC_VA)
      return_value = 0;

   MSR_READ(MBD_MSR_CAP, RC_MB0_MBIU0, &(msrValue.high), &(msrValue.low));
   if (GET_DEVICE_ID(msrValue.high, msrValue.low) != RC_CC_MBIU)
      return_value = 0;

   MSR_READ(MBD_MSR_CAP, RC_MB0_MBIU1, &(msrValue.high), &(msrValue.low));
   if (GET_DEVICE_ID(msrValue.high, msrValue.low) != RC_CC_MBIU)
      return_value = 0;

   /* ENUMERATE VALID BUS */
   /* If all static devices were identified, continue with the enumeration */

   if (return_value) {
      /* OPTIMIZATION */
      /* Build a local copy of the MBUS topology.  This allows us to  */
      /* quickly search the entire MBUS for a given device ID without */
      /* repeated MSR accesses.                                       */

      redcloud_build_mbus_tree();

      /* INITIALIZE MSR DEVICES */

      return_value = redcloud_init_msr_devices(msrDev, NUM_DEVS);

   }

   return return_value;

}

/*--------------------------------------------------------------------------
 * void	redcloud_build_mbus_tree() (PRIVATE ROUTINE - NOT PART OF DURANGO API)
 *
 * This routine walks through the MBUS and records the address value and 
 * device ID found at each node.  If a node (aka port) is not populated, 
 * that node returns '0'.  The deviceID for that node is set to '0' 
 * (NOT_POPULATED) to reflect this. If the node being queried points back to 
 * Vail or MBIU0, the deviceID for that node is set to 'REFLECTIVE'.  Reflective 
 * nodes are nodes that forward the given MBUS address BACK to the initiator.
 *-----------------------------------------------------------------------------
 */
void
redcloud_build_mbus_tree(void)
{
   unsigned long mbiu_port_count, reflective;
   unsigned long port;
   Q_WORD msrValue;

   /*                  */
   /* ENUMERATE MBIU0  */
   /*                  */

   /* COUNT MBIU PORTS */

   MSR_READ(MBIU_CAP, RC_MB0_MBIU0, &(msrValue.high), &(msrValue.low));
   mbiu_port_count = GET_NUM_PORTS(msrValue.high, msrValue.low);

   /* FIND REFLECTIVE PORT */
   /* Query the MBIU for the port through which we are communicating. */
   /* We will avoid accesses to this port to avoid a self-reference.  */

   MSR_READ(MBIU_WHOAMI, RC_MB0_MBIU0, &(msrValue.high), &(msrValue.low));
   reflective = msrValue.low & WHOAMI_MASK;

   /* ENUMERATE ALL PORTS */
   /* For every possible port, set the MBIU.deviceId to something. */

   for (port = 0; port < 8; port++) {
      /* FILL IN CLAIMED FIELD */
      /* All MBIU ports can only be assigned to one device from the */
      /* Durango table                                              */

      MBIU0[port].claimed = 0;

      /* MBIU0 PORT NUMBERS ARE IN ADDRESS BITS 31:29 */

      MBIU0[port].address = port << 29;

      /* SPECIAL CASE FOR MBIU0 */
      /* MBIU0 port 0 is a special case, as it points back to MBIU0.  MBIU0 */
      /* responds at address 0x40000xxx, which does not equal 0 << 29.      */

      if (port == 0)
	 MBIU0[port].deviceId = RC_CC_MBIU;
      else if (port == reflective)
	 MBIU0[port].deviceId = REFLECTIVE;
      else if (port > mbiu_port_count)
	 MBIU0[port].deviceId = NOT_POPULATED;
      else {
	 MSR_READ(MBD_MSR_CAP, MBIU0[port].address, &(msrValue.high),
		  &(msrValue.low));
	 MBIU0[port].deviceId = GET_DEVICE_ID(msrValue.high, msrValue.low);
      }
   }

   /*                  */
   /* ENUMERATE MBIU1  */
   /*                  */

   /* COUNT MBIU PORTS */

   MSR_READ(MBIU_CAP, RC_MB0_MBIU1, &(msrValue.high), &(msrValue.low));
   mbiu_port_count = GET_NUM_PORTS(msrValue.high, msrValue.low);

   /* FIND REFLECTIVE PORT */
   /* Query the MBIU for the port through which we are communicating. */
   /* We will avoid accesses to this port to avoid a self-reference.  */

   MSR_READ(MBIU_WHOAMI, RC_MB0_MBIU1, &(msrValue.high), &(msrValue.low));
   reflective = msrValue.low & WHOAMI_MASK;

   /* ENUMERATE ALL PORTS */
   /* For every possible port, set the MBIU.deviceId to something. */

   for (port = 0; port < 8; port++) {
      /* FILL IN CLAIMED FIELD */
      /* All MBIU ports can only be assigned to one device from the */
      /* Durango table                                              */

      MBIU1[port].claimed = 0;

      /* MBIU1 PORT NUMBERS ARE IN 28:26 AND 31:29 = 010B */

      MBIU1[port].address = (0x02l << 29) + (port << 26);

      if (port == reflective)
	 MBIU1[port].deviceId = REFLECTIVE;
      else if (port > mbiu_port_count)
	 MBIU1[port].deviceId = NOT_POPULATED;
      else {
	 MSR_READ(MBD_MSR_CAP, MBIU1[port].address, &(msrValue.high),
		  &(msrValue.low));
	 MBIU1[port].deviceId = GET_DEVICE_ID(msrValue.high, msrValue.low);
      }
   }

   /*                          */
   /* ENUMERATE MBIU2 (CS5535) */
   /*  (if present)            */

   MSR_READ(MBD_MSR_CAP, CP_MB0_MBIU0, &(msrValue.high), &(msrValue.low));
   if (GET_DEVICE_ID(msrValue.high, msrValue.low) == CP_CC_MBIU) {
      /* COUNT MBIU PORTS */

      MSR_READ(MBIU_CAP, CP_MB0_MBIU0, &(msrValue.high), &(msrValue.low));
      mbiu_port_count = GET_NUM_PORTS(msrValue.high, msrValue.low);

      /* FIND REFLECTIVE PORT */
      /* Query the MBIU for the port through which we are communicating. */
      /* We will avoid accesses to this port to avoid a self-reference.  */

      MSR_READ(MBIU_WHOAMI, CP_MB0_MBIU0, &(msrValue.high), &(msrValue.low));
      reflective = msrValue.low & WHOAMI_MASK;

      /* ENUMERATE ALL PORTS */
      /* For every possible port, set the MBIU.deviceId to something. */

      for (port = 0; port < 8; port++) {
	 /* FILL IN CLAIMED FIELD */
	 /* All MBIU ports can only be assigned to one device from the */
	 /* Durango table                                              */

	 MBIU2[port].claimed = 0;

	 /* MBIU2 PORT NUMBERS ARE IN 22:20 AND 31:23 = 010100010B */

	 MBIU2[port].address =
	       (0x02l << 29) + (0x04l << 26) + (0x02l << 23) + (port << 20);

	 if (port == reflective)
	    MBIU2[port].deviceId = REFLECTIVE;
	 else if (port > mbiu_port_count)
	    MBIU2[port].deviceId = NOT_POPULATED;
	 else {
	    MSR_READ(MBD_MSR_CAP, MBIU2[port].address, &(msrValue.high),
		     &(msrValue.low));
	    MBIU2[port].deviceId = GET_DEVICE_ID(msrValue.high, msrValue.low);
	 }
      }
   } else {
      /* NO 5535                                                  */
      /* If the CS5535 is not installed, fill in the cached table */
      /* with the 'NOT_INSTALLED' flag.  Also, fill in the device */
      /* status from NOT_KNOWN to REQ_NOT_INSTALLED.              */

      for (port = 0; port < 8; port++) {
	 MBIU2[port].claimed = 0;
	 MBIU2[port].deviceId = NOT_INSTALLED;
	 MBIU2[port].address =
	       (0x02l << 29) + (0x04l << 26) + (0x02l << 23) + (port << 20);
      }
      for (port = CP_INDEX_START; port <= CP_INDEX_STOP; port++) {
	 msrDev[port].Present = REQ_NOT_INSTALLED;
      }
   }
}

/*------------------------------------------------------------------
 * redcloud_init_msr_devices (PRIVATE ROUTINE - NOT PART OF DURANGO API)

 * Handles the details of finding each possible device on the MBUS.
 * If a given device is not found, its structure is left uninitialized.
 * If a given device is found, its structure is updated.
 *
 * This init routine only checks for devices in aDev[].
 *
 *  Passed:
 *		aDev - is a pointer to the array of MBUS devices.
 *		arraySize - number of elements in aDev.
 *
 *	Returns:
 *		1 - If, for every device, its address was found.
 *		0 - If, for any device, an error was encountered.
 *------------------------------------------------------------------
 */
int
redcloud_init_msr_devices(MSR aDev[], unsigned int array_size)
{
   unsigned int i, issues = 0;

   /* TRY TO FIND EACH ITEM IN THE ARRAY */

   for (i = 0; i < array_size; i++) {
      /* IGNORE DEVICES THAT ARE ALREADY FOUND                */
      /* The addresses for "found" devices are already known. */

      if (aDev[i].Present == FOUND || aDev[i].Present == REQ_NOT_INSTALLED)
	 continue;

      /* TRY TO FIND THE DEVICE ON THE MBUS */

      aDev[i].Present = redcloud_find_msr_device(&aDev[i]);

      /* INCREMENT ERROR COUNT IF DEVICE NOT FOUND */

      if (aDev[i].Present != FOUND)
	 issues++;
   }

   return (issues == 0);
}

/*------------------------------------------------------------------
 *  redcloud_find_msr_device (PRIVATE ROUTINE - NOT PART OF DURANGO API)
 *
 *  Passed:
 *	    pDev - is a pointer to one element in the array of MBUS devices
 *
 *  Returns:
 *	    FOUND - Device was found and pDev->Address has been updated.
 *
 *		REQ_NOT_FOUND - Device was not found and pDev->Address has not
 *						been updated.
 *
 *------------------------------------------------------------------
*/
DEV_STATUS
redcloud_find_msr_device(MSR * pDev)
{
   unsigned int i;

   /* SEARCH DURANGO'S CACHED MBUS TOPOLOGY */
   /* This gets a little tricky.  As the only identifier we have for each   */
   /* device is the device ID and we have multiple devices of the same type */
   /* MCP, MPCI, USB, etc. we need to make some assumptions based on table  */
   /* order.  These are as follows:                                         */
   /* 1. All Redcloud nodes are searched first, as we assume that they      */
   /*    are first in the table.                                            */
   /* 2. If two devices have the same device ID and are found on the same   */
   /*    device (GX2, CS5535, etc.) we assume that they are listed such     */
   /*    that the first device in the table with this device ID has a lower */
   /*    port address.                                                      */
   /* 3. After a device ID has been matched, the port is marked as          */
   /*    'claimed', such that future enumerations continue searching the    */
   /*    GeodeLink topology.                                                */

   /* SEARCH MBIU0 */

   for (i = 0; i < 8; i++) {
      if (MBIU0[i].deviceId == pDev->Id && !(MBIU0[i].claimed)) {
	 MBIU0[i].claimed = 1;
	 pDev->Address = MBIU0[i].address;
	 return FOUND;
      }
   }

   /* SEARCH MBIU1 */

   for (i = 0; i < 8; i++) {
      if (MBIU1[i].deviceId == pDev->Id && !(MBIU1[i].claimed)) {
	 MBIU1[i].claimed = 1;
	 pDev->Address = MBIU1[i].address;
	 return FOUND;
      }
   }

   /* SEARCH MBIU2 */

   for (i = 0; i < 8; i++) {
      if (MBIU2[i].deviceId == pDev->Id && !(MBIU2[i].claimed)) {
	 MBIU2[i].claimed = 1;
	 pDev->Address = MBIU2[i].address;
	 return FOUND;
      }
   }

   return REQ_NOT_FOUND;
}

/*--------------------------------------------------------------------
 * gfx_id_msr_device 
 *
 *	This routine handles reading the capabilities MSR register (typically 0x2000)
 *	and checking if the 'id' field matchs  pDev.Id.  This routine is
 *  used by applications/drivers that need to extend the list of known
 *  MBUS devices beyond those known by Durango.
 *
 *		Passed:
 *			pDev - Pointer to MSR structure containing the device's ID.
 *		    address - device address.
 *
 *		Returns:
 *			FOUND - The IDs do match.
 *			REQ_NOT_FOUND - There was not a match.
 *
 *--------------------------------------------------------------------
 */
#if GFX_MSR_DYNAMIC
DEV_STATUS
redcloud_id_msr_device(MSR * pDev, unsigned long address)
#else
DEV_STATUS
gfx_id_msr_device(MSR * pDev, unsigned long address)
#endif
{
   Q_WORD msrValue;

   MSR_READ(MBD_MSR_CAP, address, &(msrValue.high), &(msrValue.low));

   if (GET_DEVICE_ID(msrValue.high, msrValue.low) == pDev->Id)
      return FOUND;
   else
      return REQ_NOT_FOUND;
}

/*--------------------------------------------------------------------
 * gfx_get_msr_dev_address
 * 
 * This function returns the 32-bit address of the requested device.
 * The device must be a known MBUS device.  (It must be in Durango's 
 * device table.)  DEV_STATUS should be checked to verify that the address 
 * was updated.
 *
 *
 * Passed:
 *     device - device index of the device in question.
 *	   *address - ptr to location where address should be stored.
 *         
 * Returns:
 *	   DEV_STATUS of device in question.  (NOT_KNOWN if device is out of range.)
 *     *address - updated if 'device' is within range
 *   
 *	Notes:
 *     This function should only be called after gfx_msr_init
 *
 *--------------------------------------------------------------------
 */
#if GFX_MSR_DYNAMIC
DEV_STATUS
redcloud_get_msr_dev_address(unsigned int device, unsigned long *address)
#else
DEV_STATUS
gfx_get_msr_dev_address(unsigned int device, unsigned long *address)
#endif
{
   if (device < NUM_DEVS) {
      if (msrDev[device].Present == FOUND)
	 *address = msrDev[device].Address;

      return msrDev[device].Present;
   }
   return NOT_KNOWN;

}

/*--------------------------------------------------------------------
 *  gfx_get_glink_id_at_address
 *   
 *	This function returns the 16-bit deviceId at the requested address.
 *  DEV_STATUS should be checked to make sure that device was updated.
 *
 *	Passed:
 *	    device - ptr to location where device ID should be stored.
 *		address - address of desired device ID.
 *         
 *  Returns:
 *	    FOUND if address is a valid address, NOT_KNOWN if address cannot be found 
 *      on the mbus.
 *      *device - updated with device Id info.
 *
 *	Notes:
 *      This function should be called after gfx_msr_init 
 *
 *--------------------------------------------------------------------
 */
#if GFX_MSR_DYNAMIC
DEV_STATUS
redcloud_get_glink_id_at_address(unsigned int *device, unsigned long address)
#else
DEV_STATUS
gfx_get_glink_id_at_address(unsigned int *device, unsigned long address)
#endif
{
   int port;

   for (port = 0; port < 8; port++) {
      if (MBIU0[port].address == address) {
	 *device = MBIU0[port].deviceId;
	 return FOUND;
      } else if (MBIU1[port].address == address) {
	 *device = MBIU1[port].deviceId;
	 return FOUND;
      } else if (MBIU2[port].address == address) {
	 *device = MBIU2[port].deviceId;
	 return FOUND;
      }
   }

   return NOT_KNOWN;

}

/*--------------------------------------------------------------------
 * gfx_msr_read
 *
 * Performs a 64-bit read from 'msrRegister' in device 'device'.  'device' is 
 * an index into Durango's table of known MBUS devices.
 *
 * Returns:
 *     FOUND - if no errors were detected and msrValue has been updated.
 *	   NOT_KNOWN	- an error was detected.  msrValue is not updated.
 *	   REQ_NOT_FOUND - 'msrAddress' for 'devID' is unknown.  Caller
 *						should call msrInit() first.  msrValue is not updated.
 *	   Notes:
 *         This function should be called after gfx_msr_init
 *--------------------------------------------------------------------
 */
#if GFX_MSR_DYNAMIC
DEV_STATUS
redcloud_msr_read(unsigned int device, unsigned int msrRegister,
		  Q_WORD * msrValue)
#else
DEV_STATUS
gfx_msr_read(unsigned int device, unsigned int msrRegister, Q_WORD * msrValue)
#endif
{
   if (device < NUM_DEVS) {
      if (msrDev[device].Present == FOUND)
	 MSR_READ(msrRegister, msrDev[device].Address, &(msrValue->high),
		  &(msrValue->low));

      return msrDev[device].Present;
   }
   return NOT_KNOWN;
}

/*--------------------------------------------------------------------
 * gfx_msr_write
 *
 *		Performs a 64-bit write to 'msrRegister' in device 'devID'.
 *
 *		Returns:
 *			FOUND - if no errors were detected and msrValue has been updated.
 *			NOT_KNOWN	- an error was detected.  msrValue is not updated.
 *			REQ_NOT_FOUND - 'msrAddress' for 'devID' is unknown.  Caller
 *						should call msrInit() first.  msrValue is not updated.
 *
 *		Notes:
 *      	This function is valid to call after initMSR_API() 
 *
 *--------------------------------------------------------------------
 */
#if GFX_MSR_DYNAMIC
DEV_STATUS
redcloud_msr_write(unsigned int device, unsigned int msrRegister,
		   Q_WORD * msrValue)
#else
DEV_STATUS
gfx_msr_write(unsigned int device, unsigned int msrRegister,
	      Q_WORD * msrValue)
#endif
{
   if (device < NUM_DEVS) {
      if (msrDev[device].Present == FOUND)
	 MSR_WRITE(msrRegister, msrDev[device].Address, &(msrValue->high),
		   &(msrValue->low));

      return msrDev[device].Present;
   }
   return NOT_KNOWN;
}
