path: root/src/cim/cim_msr.c

/*
 * Copyright (c) 2006 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.
 */

 /*
  * Cimarron MSR access routines.  These routines allow the user to query the
  * state of the GeodeLink Bus and read and write model-specfic registers.
  */

/*--------------------------------------------------------------*/
/* MSR GLOBALS                                                  */
/* These variables hold a local copy of the GeodeLink mapping   */
/* as well as a lookup table for easy device addressing.        */
/*--------------------------------------------------------------*/

GEODELINK_NODE gliu_nodes[24];
GEODELINK_NODE msr_dev_lookup[MSR_DEVICE_EMPTY];

#define GET_DEVICE_ID(macrohigh, macrolow) ((macrolow >> 12) & 0xFF)

/*---------------------------------------------------------------------------
 * msr_init_table
 *
 * This routine intializes the internal MSR table in Cimarron.  This table is
 * used for any MSR device accesses.
 *--------------------------------------------------------------------------*/

int
msr_init_table(void)
{
    Q_WORD msr_value = { 0, 0 };
    unsigned int i, j;
    int return_value = CIM_STATUS_OK;

    /* CHECK FOR VALID GEODELINK CONFIGURATION
     * The CPU and the three GLIUs are assumed to be at known static
     * addresses, so we will check the device IDs at these addresses as proof
     * of a valid GeodeLink configuration 
     */

    MSR_READ(MSR_GEODELINK_CAP, MSR_ADDRESS_VAIL, &msr_value);
    if (GET_DEVICE_ID(msr_value.high, msr_value.low) != MSR_CLASS_CODE_VAIL)
        return_value = CIM_STATUS_ERROR;

    MSR_READ(MSR_GEODELINK_CAP, MSR_ADDRESS_GLIU0, &msr_value);
    if (GET_DEVICE_ID(msr_value.high, msr_value.low) != MSR_CLASS_CODE_GLIU)
        return_value = CIM_STATUS_ERROR;

    MSR_READ(MSR_GEODELINK_CAP, MSR_ADDRESS_GLIU1, &msr_value);
    if (GET_DEVICE_ID(msr_value.high, msr_value.low) != MSR_CLASS_CODE_GLIU)
        return_value = CIM_STATUS_ERROR;

    MSR_READ(MSR_GEODELINK_CAP, MSR_ADDRESS_GLIU2, &msr_value);
    if (GET_DEVICE_ID(msr_value.high, msr_value.low) != MSR_CLASS_CODE_GLIU)
        return_value = CIM_STATUS_ERROR;

    if (return_value == CIM_STATUS_OK) {
        /* BUILD LOCAL COPY OF THE GEODELINK BUS */

        msr_create_geodelink_table(gliu_nodes);

        /* CLEAR TABLE STATUS */

        for (i = 0; i < MSR_DEVICE_EMPTY; i++)
            msr_dev_lookup[i].device_id = MSR_DEVICE_NOTFOUND;

        /* CREATE EASY LOOKUP TABLE FOR FUTURE HARDWARE ACCESS    */
        /* Note that MSR_DEVICE_EMPTY is the index after the last */
        /* available device.  Also note that we fill in known     */
        /* devices before filling in the rest of the table.       */

        msr_dev_lookup[MSR_DEVICE_GEODELX_GLIU0].address_from_cpu =
            MSR_ADDRESS_GLIU0;
        msr_dev_lookup[MSR_DEVICE_GEODELX_GLIU0].device_id = MSR_DEVICE_PRESENT;
        msr_dev_lookup[MSR_DEVICE_GEODELX_GLIU1].address_from_cpu =
            MSR_ADDRESS_GLIU1;
        msr_dev_lookup[MSR_DEVICE_GEODELX_GLIU1].device_id = MSR_DEVICE_PRESENT;
        msr_dev_lookup[MSR_DEVICE_5535_GLIU].address_from_cpu =
            MSR_ADDRESS_GLIU2;
        msr_dev_lookup[MSR_DEVICE_5535_GLIU].device_id = MSR_DEVICE_PRESENT;
        msr_dev_lookup[MSR_DEVICE_GEODELX_VAIL].address_from_cpu =
            MSR_ADDRESS_VAIL;
        msr_dev_lookup[MSR_DEVICE_GEODELX_VAIL].device_id = MSR_DEVICE_PRESENT;

        for (i = 0; i < MSR_DEVICE_EMPTY; i++) {
            if (msr_dev_lookup[i].device_id == MSR_DEVICE_NOTFOUND) {
                for (j = 0; j < 24; j++) {
                    if (gliu_nodes[j].device_id == i)
                        break;
                }

                if (j == 24)
                    msr_dev_lookup[i].device_id = MSR_DEVICE_NOTFOUND;
                else {
                    msr_dev_lookup[i].device_id = MSR_DEVICE_PRESENT;
                    msr_dev_lookup[i].address_from_cpu =
                        gliu_nodes[j].address_from_cpu;
                }
            }
        }
    }
    else {
        /* ERROR OUT THE GEODELINK TABLES */

        for (i = 0; i < 24; i++) {
            gliu_nodes[i].address_from_cpu = 0xFFFFFFFF;
            gliu_nodes[i].device_id = MSR_DEVICE_EMPTY;
        }

        for (i = 0; i < MSR_DEVICE_EMPTY; i++) {
            msr_dev_lookup[i].address_from_cpu = 0xFFFFFFFF;
            msr_dev_lookup[i].device_id = MSR_DEVICE_NOTFOUND;
        }
    }
    return return_value;
}

/*---------------------------------------------------------------------------
 * msr_create_geodelink_table
 *
 * This routine dumps the contents of the GeodeLink bus into an array of
 * 24 GEODELINK_NODE structures.  Indexes 0-7 represent ports 0-7 of GLIU0,
 * indexes 8-15 represent ports 0-7 of GLIU1 and indexes 16-23 represent
 * ports 0-7 of GLIU2 (5535).
 *--------------------------------------------------------------------------*/

int
msr_create_geodelink_table(GEODELINK_NODE * gliu_nodes)
{
    unsigned long mbiu_port_count, reflective;
    unsigned long port, index;
    unsigned long gliu_count = 0;
    int glcp_count = 0;
    int usb_count = 0;
    int mpci_count = 0;
    Q_WORD msr_value = { 0, 0 };

    /* ALL THREE GLIUS ARE IN ONE ARRAY                               */
    /* Entries 0-7 contain the port information for GLIU0, entries    */
    /* 8-15 contain GLIU1 and 15-23 contain GLIU2.  We perform the    */
    /* enumeration in two passes.  The first simply fills in the      */
    /* addresses and class codes at each node.  The second pass       */
    /* translates the class codes into indexes into Cimarron's device */
    /* lookup table.                                                  */

    /* COUNT GLIU0 PORTS */

    MSR_READ(MSR_GLIU_CAP, MSR_ADDRESS_GLIU0, &msr_value);
    mbiu_port_count = (msr_value.high >> NUM_PORTS_SHIFT) & 7;

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

    MSR_READ(MSR_GLIU_WHOAMI, MSR_ADDRESS_GLIU0, &msr_value);
    reflective = msr_value.low & WHOAMI_MASK;

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

    gliu_nodes[0].address_from_cpu = MSR_ADDRESS_GLIU0;
    gliu_nodes[0].device_id = MSR_CLASS_CODE_GLIU;

    /* ENUMERATE ALL PORTS */

    for (port = 1; port < 8; port++) {
        /* FILL IN ADDRESS */

        gliu_nodes[port].address_from_cpu = port << 29;

        if (port == reflective)
            gliu_nodes[port].device_id = MSR_CLASS_CODE_REFLECTIVE;
        else if (port > mbiu_port_count)
            gliu_nodes[port].device_id = MSR_CLASS_CODE_UNPOPULATED;
        else {
            MSR_READ(MSR_GEODELINK_CAP, gliu_nodes[port].address_from_cpu,
                     &msr_value);
            gliu_nodes[port].device_id =
                GET_DEVICE_ID(msr_value.high, msr_value.low);
        }
    }

    /* COUNT GLIU1 PORTS */

    MSR_READ(MSR_GLIU_CAP, MSR_ADDRESS_GLIU1, &msr_value);
    mbiu_port_count = (msr_value.high >> NUM_PORTS_SHIFT) & 7;

    /* FIND REFLECTIVE PORT */

    MSR_READ(MSR_GLIU_WHOAMI, MSR_ADDRESS_GLIU1, &msr_value);
    reflective = msr_value.low & WHOAMI_MASK;

    /* ENUMERATE ALL PORTS */

    for (port = 0; port < 8; port++) {
        index = port + 8;

        /* FILL IN ADDRESS */

        gliu_nodes[index].address_from_cpu = (0x02l << 29) + (port << 26);

        if (port == reflective)
            gliu_nodes[index].device_id = MSR_CLASS_CODE_REFLECTIVE;
        else if (port > mbiu_port_count)
            gliu_nodes[index].device_id = MSR_CLASS_CODE_UNPOPULATED;
        else {
            MSR_READ(MSR_GEODELINK_CAP, gliu_nodes[index].address_from_cpu,
                     &msr_value);
            gliu_nodes[index].device_id =
                GET_DEVICE_ID(msr_value.high, msr_value.low);
        }
    }

    /* COUNT GLIU2 PORTS */

    MSR_READ(MSR_GLIU_CAP, MSR_ADDRESS_GLIU2, &msr_value);
    mbiu_port_count = (msr_value.high >> NUM_PORTS_SHIFT) & 7;

    /* FIND REFLECTIVE PORT */

    MSR_READ(MSR_GLIU_WHOAMI, MSR_ADDRESS_GLIU2, &msr_value);
    reflective = msr_value.low & WHOAMI_MASK;

    /* FILL IN PORT 0 AND 1 */
    /* Port 0 on 5535 is MBIU2.  Port 1 is MPCI, but it is referenced at */
    /* a special address.                                                */

    gliu_nodes[16].address_from_cpu = MSR_ADDRESS_GLIU2;
    gliu_nodes[16].device_id = MSR_CLASS_CODE_GLIU;

    gliu_nodes[17].address_from_cpu = MSR_ADDRESS_5535MPCI;
    gliu_nodes[17].device_id = MSR_CLASS_CODE_MPCI;

    /* ENUMERATE ALL PORTS */

    for (port = 2; port < 8; port++) {
        index = port + 16;

        /* FILL IN ADDRESS */

        gliu_nodes[index].address_from_cpu =
            (0x02l << 29) + (0x04l << 26) + (0x02l << 23) + (port << 20);

        if (port == reflective)
            gliu_nodes[index].device_id = MSR_CLASS_CODE_REFLECTIVE;
        else if (port > mbiu_port_count)
            gliu_nodes[index].device_id = MSR_CLASS_CODE_UNPOPULATED;
        else {
            MSR_READ(MSR_GEODELINK_CAP, gliu_nodes[index].address_from_cpu,
                     &msr_value);
            gliu_nodes[index].device_id =
                GET_DEVICE_ID(msr_value.high, msr_value.low);
        }
    }

    /* SECOND PASS - TRANSLATION */
    /* Now that the class codes for each device are stored in the  */
    /* array, we walk through the array and translate the class    */
    /* codes to table indexes.  For class codes that have multiple */
    /* instances, the table indexes are sequential.                */

    for (port = 0; port < 24; port++) {
        /* SPECIAL CASE FOR GLIU UNITS */
        /* A GLIU can be both on another port and on its own port.  These  */
        /* end up as the same address, but are shown as duplicate nodes in */
        /* the GeodeLink table.                                            */

        if ((port & 7) == 0)
            gliu_count = port >> 3;

        switch (gliu_nodes[port].device_id) {
            /* UNPOPULATED OR REFLECTIVE NODES */

        case MSR_CLASS_CODE_UNPOPULATED:
            index = MSR_DEVICE_EMPTY;
            break;
        case MSR_CLASS_CODE_REFLECTIVE:
            index = MSR_DEVICE_REFLECTIVE;
            break;

            /* KNOWN CLASS CODES */

        case MSR_CLASS_CODE_GLIU:
            index = MSR_DEVICE_GEODELX_GLIU0 + gliu_count++;
            break;
        case MSR_CLASS_CODE_GLCP:
            index = MSR_DEVICE_GEODELX_GLCP + glcp_count++;
            break;
        case MSR_CLASS_CODE_MPCI:
            index = MSR_DEVICE_GEODELX_MPCI + mpci_count++;
            break;
        case MSR_CLASS_CODE_USB:
            index = MSR_DEVICE_5535_USB2 + usb_count++;
            break;
        case MSR_CLASS_CODE_USB2:
            index = MSR_DEVICE_5536_USB_2_0;
            break;
        case MSR_CLASS_CODE_ATAC:
            index = MSR_DEVICE_5535_ATAC;
            break;
        case MSR_CLASS_CODE_MDD:
            index = MSR_DEVICE_5535_MDD;
            break;
        case MSR_CLASS_CODE_ACC:
            index = MSR_DEVICE_5535_ACC;
            break;
        case MSR_CLASS_CODE_MC:
            index = MSR_DEVICE_GEODELX_MC;
            break;
        case MSR_CLASS_CODE_GP:
            index = MSR_DEVICE_GEODELX_GP;
            break;
        case MSR_CLASS_CODE_VG:
            index = MSR_DEVICE_GEODELX_VG;
            break;
        case MSR_CLASS_CODE_DF:
            index = MSR_DEVICE_GEODELX_DF;
            break;
        case MSR_CLASS_CODE_FG:
            index = MSR_DEVICE_GEODELX_FG;
            break;
        case MSR_CLASS_CODE_VIP:
            index = MSR_DEVICE_GEODELX_VIP;
            break;
        case MSR_CLASS_CODE_AES:
            index = MSR_DEVICE_GEODELX_AES;
            break;
        case MSR_CLASS_CODE_VAIL:
            index = MSR_DEVICE_GEODELX_VAIL;
            break;
        default:
            index = MSR_DEVICE_EMPTY;
            break;
        }

        gliu_nodes[port].device_id = index;
    }

    return CIM_STATUS_OK;
}

/*---------------------------------------------------------------------------
 * msr_create_device_list
 *
 * This routine dumps a list of all known GeodeLX/5535 devices as well as their
 * respective status and address.
 *--------------------------------------------------------------------------*/

int
msr_create_device_list(GEODELINK_NODE * gliu_nodes, int max_devices)
{
    int i, count;

    if (max_devices < MSR_DEVICE_EMPTY)
        count = max_devices;
    else
        count = MSR_DEVICE_EMPTY;

    for (i = 0; i < count; i++) {
        gliu_nodes[i].address_from_cpu = msr_dev_lookup[i].address_from_cpu;
        gliu_nodes[i].device_id = msr_dev_lookup[i].device_id;
    }

    return CIM_STATUS_OK;
}

/*--------------------------------------------------------------------
 * msr_read64
 *
 * Performs a 64-bit read from 'msr_register' in device 'device'.  'device' is
 * an index into Cimarron's table of known GeodeLink devices.
 *-------------------------------------------------------------------*/

int
msr_read64(unsigned long device, unsigned long msr_register, Q_WORD * msr_value)
{
    if (device < MSR_DEVICE_EMPTY) {
        if (msr_dev_lookup[device].device_id == MSR_DEVICE_PRESENT) {
            MSR_READ(msr_register, msr_dev_lookup[device].address_from_cpu,
                     msr_value);
            return CIM_STATUS_OK;
        }
    }

    msr_value->low = msr_value->high = 0;
    return CIM_STATUS_DEVNOTFOUND;
}

/*--------------------------------------------------------------------
 * msr_write64
 *
 * Performs a 64-bit write to 'msr_register' in device 'device'.  'device' is
 * an index into Cimarron's table of known GeodeLink devices.
 *-------------------------------------------------------------------*/

int
msr_write64(unsigned long device, unsigned long msr_register,
            Q_WORD * msr_value)
{
    if (device < MSR_DEVICE_EMPTY) {
        if (msr_dev_lookup[device].device_id == MSR_DEVICE_PRESENT) {
            MSR_WRITE(msr_register, msr_dev_lookup[device].address_from_cpu,
                      msr_value);
            return CIM_STATUS_OK;
        }
    }
    return CIM_STATUS_DEVNOTFOUND;
}