cy2239x.c

Go to the documentation of this file.

/*
 * Copyright (C) 2005 by egnite Software GmbH. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH 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 EGNITE
 * SOFTWARE GMBH 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 OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 *
 */

#include <sys/event.h>
#include <dev/twif.h>
#include <dev/cy2239x.h>


#ifndef I2C_SLA_PLL
#define I2C_SLA_PLL     0x69
#endif

#ifndef NUT_PLL_FREF
#define NUT_PLL_FREF   25000000UL
#endif

static uint32_t PllFreq(uint8_t * reg)
{
    uint32_t p;
    uint32_t pt;
    uint32_t qt;

    /* The 11-bit P value is stored in two registers. */
    p = (uint32_t) (reg[2] & 0x03) << 8 | reg[1];
    /* Calculate Pt = (2 x (P + 3)) + PO. */
    pt = 2 * (p + 3) + ((reg[2] >> 2) & 1);
    /* Calculate Qt = Q + 2. */
    qt = reg[0] + 2;
    /* Calculate Fpll = Fref x (Pt / Qt) */
    return (((NUT_PLL_FREF * 10UL + 5UL) / qt) * pt) / 10UL;
}

int Cy2239xGetPll(int clk)
{
    int rc = -1;
    uint8_t loc = 0x0E;
    uint8_t reg;

    /* ClkE is fixed to PLL1. */
    if (clk == CY2239X_CLKE) {
        rc = 1;
    } 
    /* Register 0x0E contains the PLL index for ClkA-ClkD. */
    else if (TwMasterTransact(I2C_SLA_PLL, &loc, 1, &reg, 1, NUT_WAIT_INFINITE) == 1) {
        rc = (reg >> (2 * clk)) & 0x03;
    }
    return rc;
}

int Cy2239xSetPll(int clk, int pll)
{
    uint8_t reg[2];
    uint8_t msk = 0x03;

    /* ClkE is fixed to PLL1. */
    if (clk >= CY2239X_CLKE) {
        if (pll != CY2239X_PLL1) {
            return -1;
        }
        return 0;
    }

    if ((pll | msk) == msk) {

        /* Register 0x0E contains the PLL index for ClkA-ClkD. */
        reg[0] = 0x0E;
        if (TwMasterTransact(I2C_SLA_PLL, reg, 1, &reg[1], 1, NUT_WAIT_INFINITE) == 1) {
            clk <<= 1;
            reg[1] &= ~(msk << clk);
            reg[1] |= pll << clk;
            TwMasterTransact(I2C_SLA_PLL, reg, 2, 0, 0, NUT_WAIT_INFINITE);
            return 0;
        }
    }
    return -1;
}

int Cy2239xGetDivider(int clk, int fctrl)
{
    int rc = -1;
    int idx;
    uint8_t loc;
    uint8_t reg;

    /*
     * Clock E has a simple divider only.
     */
    if (clk == CY2239X_CLKE) {
        /* The two lower bits of register 0x0F define the Clock E divider. */
        loc = 0x0F;
        if (TwMasterTransact(I2C_SLA_PLL, &loc, 1, &reg, 1, NUT_WAIT_INFINITE) == 1) {
            rc = reg & 3;
            if (rc == 1) {
                rc = 4;
            }
        }
    }
    else {
        /*
         * Clock A and B have two dividers, which are indirectly selected 
         * by the frequency control inputs.
         */
        if (clk <= CY2239X_CLKB) {
            /* Read the DivSel bit. */
            loc = 0x42 + fctrl * 3;
            if (TwMasterTransact(I2C_SLA_PLL, &loc, 1, &reg, 1, NUT_WAIT_INFINITE) != 1) {
                return -1;
            }
            idx = clk * 2 + (reg >> 7);
        }
        else {
            idx = clk + 2;
        }
        loc = 0x08 + idx;
        if (TwMasterTransact(I2C_SLA_PLL, &loc, 1, &reg, 1, NUT_WAIT_INFINITE) == 1) {
            rc = reg & 0x7F;
        }
    }
    return rc;
}

int Cy2239xSetDivider(int clk, int sel, int val)
{
    uint8_t reg[2];

    /* Clock E has a simple divider only. */
    if (clk == CY2239X_CLKE) {
        if (val == 0 || (val >= 2 && val <= 4)) {
            if (val == 4) {
                val = 1;
            }
            /* The two lower bits of register 0x0F define the Clock E divider. */
            reg[0] = 0x0F;
            if (TwMasterTransact(I2C_SLA_PLL, reg, 1, &reg[1], 1, NUT_WAIT_INFINITE) == 1) {
                reg[1] &= ~0x03;
                reg[1] |= (uint8_t) val;
                TwMasterTransact(I2C_SLA_PLL, reg, 2, 0, 0, NUT_WAIT_INFINITE);
                return 0;
            }
        }
        return -1;
    }

    if (val > 0 && val < 128) {
        /* Clock A and B have two selectable dividers. */
        if (clk <= CY2239X_CLKB) {
            reg[0] = 0x08 + clk * 2 + sel;
        }
        else {
            reg[0] = 0x08 + clk + 2;
        }
        if (TwMasterTransact(I2C_SLA_PLL, reg, 1, &reg[1], 1, NUT_WAIT_INFINITE) == 1) {
            reg[1] &= ~0x7F;
            reg[1] |= (uint8_t) val;
            TwMasterTransact(I2C_SLA_PLL, reg, 2, 0, 0, NUT_WAIT_INFINITE);
            return 0;
        }
    }
    return -1;
}

int Cy2239xPllEnable(int pll, int fctrl, int ena)
{
    int rc = -1;
    uint8_t reg[2];

    if (pll) {
        if (pll == CY2239X_PLL1) {
            /* PLL1 can be switched by the external control inputs. */
            reg[0] = 0x42 + fctrl * 3;
        }
        else if (pll == CY2239X_PLL2) {
            reg[0] = 0x13;
        }
        else if (pll == CY2239X_PLL3) {
            reg[0] = 0x16;
        }

        /* Set bit 6 of the third PLL register. */
        if (TwMasterTransact(I2C_SLA_PLL, reg, 1, &reg[1], 1, NUT_WAIT_INFINITE) == 1) {
            rc = (reg[1] & 0x40) != 0;
            if (ena == 1) {
                reg[1] |= 0x40;
            }
            else if (ena == 0) {
                reg[1] &= ~0x40;
            }
            else {
                return rc;
            }
            TwMasterTransact(I2C_SLA_PLL, reg, 2, 0, 0, NUT_WAIT_INFINITE);
        }
    }
    return rc;
}

uint32_t Cy2239xPllGetFreq(int pll, int fctrl)
{
    uint32_t rc = NUT_PLL_FREF;
    uint8_t loc;
    uint8_t reg[3];

    if (pll) {
        if (pll == CY2239X_PLL1) {
            /* PLL1 can be switched by the external control inputs. */
            loc = 0x40 + fctrl * 3;
        }
        else if (pll == CY2239X_PLL2) {
            loc = 0x11;
        }
        else if (pll == CY2239X_PLL3) {
            loc = 0x14;
        }
        /* Read the three PLL specific registers. */
        if (TwMasterTransact(I2C_SLA_PLL, &loc, 1, reg, 3, NUT_WAIT_INFINITE) != 3) {
            rc = 0;
        }
        else {
            rc = PllFreq(reg);
        }
    }
    return rc;
}

int Cy2239xPllSetFreq(int pll, int fctrl, unsigned int pval, unsigned int poff, unsigned int qval, unsigned int fval)
{
    uint8_t reg[4];
    int ena;

    if (pll) {
        /* Determine the location of the PLL specific registers. */
        if (pll == CY2239X_PLL1) {
            reg[0] = 0x40 + fctrl * 3;
        }
        else if (pll == CY2239X_PLL2) {
            reg[0] = 0x11;
        }
        else if (pll == CY2239X_PLL3) {
            reg[0] = 0x14;
        }

        /* Read the three PLL specific registers. */
        if (TwMasterTransact(I2C_SLA_PLL, reg, 1, &reg[1], 3, NUT_WAIT_INFINITE) == 3) {
            /* The register is updated immediately. Disable the PLL to avoid
             * out of bounds settings. */
            if ((ena = Cy2239xPllEnable(pll, fctrl, 0)) >= 0) {
                reg[1] = (uint8_t) qval;
                reg[2] = (uint8_t) pval;
                reg[3] &= 0x80; /* Clear all except the divider select. */
                reg[3] |= (uint8_t)(pval >> 8) & 0x03;
                reg[3] |= (poff & 1) << 2;
                reg[3] |= (fval & 7) << 3;
                TwMasterTransact(I2C_SLA_PLL, reg, 4, 0, 0, NUT_WAIT_INFINITE);
                Cy2239xPllEnable(pll, fctrl, ena);
            }
            return 0;
        }
    }
    return -1;
}

uint32_t Cy2239xGetFreq(int clk, int fctrl)
{
    uint32_t rc;
    uint32_t d;
    uint8_t loc;
    uint8_t reg;
    uint8_t clk_reg[8];
    uint8_t pll_reg[3];
    int pll;

    /* Read clock registers 0x08 - 0x0F. */
    loc = 0x08;
    if (TwMasterTransact(I2C_SLA_PLL, &loc, 1, clk_reg, 8, NUT_WAIT_INFINITE) != 8) {
        return 0;
    }

    /* 
     * Get the PLL index for the specified output divider. Index 0 
     * specifies the reference clock, while 1 to 3 specify PLL1 to 
     * PLL3 resp.
     */
    if (clk == CY2239X_CLKE) {
        /* ClkE is fixed to PLL1. */
        pll = CY2239X_PLL1;
    } else {
        /* Register 0x0E contains the PLL index for ClkA-ClkD. */
        pll = (clk_reg[6] >> (2 * clk)) & 0x03;
    }

    /*
     * We got the PLL index. Now let's determine the PLL frequency.
     */
    if (pll == CY2239X_REF) {
        /* Index 0 means reference clock. */
        rc = NUT_PLL_FREF;
    } else {
        if (pll == CY2239X_PLL1) {
            /* PLL1 can be switched by the external control inputs. */
            loc = 0x40 + fctrl * 3;
        }
        else if (pll == CY2239X_PLL2) {
            loc = 0x11;
        }
        else if (pll == CY2239X_PLL3) {
            loc = 0x14;
        }
        /* Read the three PLL specific registers. */
        if (TwMasterTransact(I2C_SLA_PLL, &loc, 1, pll_reg, 3, NUT_WAIT_INFINITE) != 3) {
            return 0;
        }
        rc = PllFreq(pll_reg);
    }

    /*
     * At this point we got the divider input frequency. Now we retrieve 
     * the divider value.
     */
    if (clk <= CY2239X_CLKB) {
        /* Clock A and B provide two dividers, selected by the frequency
         * control input. */
        if (pll == CY2239X_PLL1) {
            /* For PLL1 we already read the register. */
            reg = pll_reg[2];
        }
        else {
            /* For PLL2 and PLL3 we read the register now. */
            loc = 0x42 + fctrl * 3;
            if (TwMasterTransact(I2C_SLA_PLL, &loc, 1, &reg, 1, NUT_WAIT_INFINITE) != 1) {
                return 0;
            }
        }
        d = clk_reg[clk * 2 + (reg >> 7)] & 0x7F;
    }
    else if (clk == CY2239X_CLKE) {
        /* Get divider for Clock E. */
        d = clk_reg[7] & 3;
        if (d == 1) {
            d = 4;
        }
    }
    else {
        /* Get divider for Clock C and D. */
        d = clk_reg[clk + 2] & 0x7F;
    }

    /*
     * Finally divide the input frequency. A divider value of zero means
     * that the output is switched off.
     */
    if (d) {
        rc /= d;
    } else {
        rc = 0;
    }
    return rc;
}