Logo Search packages:      
Sourcecode: qemu version File versions  Download package

omap1_clk.c

/*
 * OMAP clocks.
 *
 * Copyright (C) 2006-2007 Andrzej Zaborowski  <balrog@zabor.org>
 *
 * Clocks data comes in part from arch/arm/mach-omap1/clock.h in Linux.
 *
 * This program is free software; you can redistribute it and/or
 * modify it 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */
#include "hw.h"
#include "omap.h"

struct clk {
    const char *name;
    const char *alias;
    struct clk *parent;
    struct clk *child1;
    struct clk *sibling;
#define ALWAYS_ENABLED        (1 << 0)
#define CLOCK_IN_OMAP310      (1 << 10)
#define CLOCK_IN_OMAP730      (1 << 11)
#define CLOCK_IN_OMAP1510     (1 << 12)
#define CLOCK_IN_OMAP16XX     (1 << 13)
    uint32_t flags;
    int id;

    int running;        /* Is currently ticking */
    int enabled;        /* Is enabled, regardless of its input clk */
    unsigned long rate;       /* Current rate (if .running) */
    unsigned int divisor;     /* Rate relative to input (if .enabled) */
    unsigned int multiplier;  /* Rate relative to input (if .enabled) */
    qemu_irq users[16];       /* Who to notify on change */
    int usecount;       /* Automatically idle when unused */
};

static struct clk xtal_osc12m = {
    .name   = "xtal_osc_12m",
    .rate   = 12000000,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
};

static struct clk xtal_osc32k = {
    .name   = "xtal_osc_32k",
    .rate   = 32768,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
};

static struct clk ck_ref = {
    .name   = "ck_ref",
    .alias  = "clkin",
    .parent = &xtal_osc12m,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
            ALWAYS_ENABLED,
};

/* If a dpll is disabled it becomes a bypass, child clocks don't stop */
static struct clk dpll1 = {
    .name   = "dpll1",
    .parent = &ck_ref,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
            ALWAYS_ENABLED,
};

static struct clk dpll2 = {
    .name   = "dpll2",
    .parent = &ck_ref,
    .flags  = CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
};

static struct clk dpll3 = {
    .name   = "dpll3",
    .parent = &ck_ref,
    .flags  = CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
};

static struct clk dpll4 = {
    .name   = "dpll4",
    .parent = &ck_ref,
    .multiplier   = 4,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
};

static struct clk apll = {
    .name   = "apll",
    .parent = &ck_ref,
    .multiplier   = 48,
    .divisor      = 12,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
};

static struct clk ck_48m = {
    .name   = "ck_48m",
    .parent = &dpll4,   /* either dpll4 or apll */
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
};

static struct clk ck_dpll1out = {
    .name   = "ck_dpll1out",
    .parent = &dpll1,
    .flags  = CLOCK_IN_OMAP16XX,
};

static struct clk sossi_ck = {
    .name   = "ck_sossi",
    .parent = &ck_dpll1out,
    .flags  = CLOCK_IN_OMAP16XX,
};

static struct clk clkm1 = {
    .name   = "clkm1",
    .alias  = "ck_gen1",
    .parent = &dpll1,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
            ALWAYS_ENABLED,
};

static struct clk clkm2 = {
    .name   = "clkm2",
    .alias  = "ck_gen2",
    .parent = &dpll1,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
            ALWAYS_ENABLED,
};

static struct clk clkm3 = {
    .name   = "clkm3",
    .alias  = "ck_gen3",
    .parent = &dpll1,   /* either dpll1 or ck_ref */
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
            ALWAYS_ENABLED,
};

static struct clk arm_ck = {
    .name   = "arm_ck",
    .alias  = "mpu_ck",
    .parent = &clkm1,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
            ALWAYS_ENABLED,
};

static struct clk armper_ck = {
    .name   = "armper_ck",
    .alias  = "mpuper_ck",
    .parent = &clkm1,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
};

static struct clk arm_gpio_ck = {
    .name   = "arm_gpio_ck",
    .alias  = "mpu_gpio_ck",
    .parent = &clkm1,
    .divisor      = 1,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
};

static struct clk armxor_ck = {
    .name   = "armxor_ck",
    .alias  = "mpuxor_ck",
    .parent = &ck_ref,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
};

static struct clk armtim_ck = {
    .name   = "armtim_ck",
    .alias  = "mputim_ck",
    .parent = &ck_ref,  /* either CLKIN or DPLL1 */
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
};

static struct clk armwdt_ck = {
    .name   = "armwdt_ck",
    .alias  = "mpuwd_ck",
    .parent = &clkm1,
    .divisor      = 14,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
            ALWAYS_ENABLED,
};

static struct clk arminth_ck16xx = {
    .name   = "arminth_ck",
    .parent = &arm_ck,
    .flags  = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
    /* Note: On 16xx the frequency can be divided by 2 by programming
     * ARM_CKCTL:ARM_INTHCK_SEL(14) to 1
     *
     * 1510 version is in TC clocks.
     */
};

static struct clk dsp_ck = {
    .name   = "dsp_ck",
    .parent = &clkm2,
    .flags  = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
};

static struct clk dspmmu_ck = {
    .name   = "dspmmu_ck",
    .parent = &clkm2,
    .flags  = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX |
            ALWAYS_ENABLED,
};

static struct clk dspper_ck = {
    .name   = "dspper_ck",
    .parent = &clkm2,
    .flags  = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
};

static struct clk dspxor_ck = {
    .name   = "dspxor_ck",
    .parent = &ck_ref,
    .flags  = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
};

static struct clk dsptim_ck = {
    .name   = "dsptim_ck",
    .parent = &ck_ref,
    .flags  = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
};

static struct clk tc_ck = {
    .name   = "tc_ck",
    .parent = &clkm3,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX |
            CLOCK_IN_OMAP730 | CLOCK_IN_OMAP310 |
            ALWAYS_ENABLED,
};

static struct clk arminth_ck15xx = {
    .name   = "arminth_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
    /* Note: On 1510 the frequency follows TC_CK
     *
     * 16xx version is in MPU clocks.
     */
};

static struct clk tipb_ck = {
    /* No-idle controlled by "tc_ck" */
    .name   = "tipb_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
};

static struct clk l3_ocpi_ck = {
    /* No-idle controlled by "tc_ck" */
    .name   = "l3_ocpi_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP16XX,
};

static struct clk tc1_ck = {
    .name   = "tc1_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP16XX,
};

static struct clk tc2_ck = {
    .name   = "tc2_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP16XX,
};

static struct clk dma_ck = {
    /* No-idle controlled by "tc_ck" */
    .name   = "dma_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
            ALWAYS_ENABLED,
};

static struct clk dma_lcdfree_ck = {
    .name   = "dma_lcdfree_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
};

static struct clk api_ck = {
    .name   = "api_ck",
    .alias  = "mpui_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
};

static struct clk lb_ck = {
    .name   = "lb_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
};

static struct clk lbfree_ck = {
    .name   = "lbfree_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
};

static struct clk hsab_ck = {
    .name   = "hsab_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
};

static struct clk rhea1_ck = {
    .name   = "rhea1_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
};

static struct clk rhea2_ck = {
    .name   = "rhea2_ck",
    .parent = &tc_ck,
    .flags  = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
};

static struct clk lcd_ck_16xx = {
    .name   = "lcd_ck",
    .parent = &clkm3,
    .flags  = CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP730,
};

static struct clk lcd_ck_1510 = {
    .name   = "lcd_ck",
    .parent = &clkm3,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
};

static struct clk uart1_1510 = {
    .name   = "uart1_ck",
    /* Direct from ULPD, no real parent */
    .parent = &armper_ck,     /* either armper_ck or dpll4 */
    .rate   = 12000000,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
};

static struct clk uart1_16xx = {
    .name   = "uart1_ck",
    /* Direct from ULPD, no real parent */
    .parent = &armper_ck,
    .rate   = 48000000,
    .flags  = CLOCK_IN_OMAP16XX,
};

static struct clk uart2_ck = {
    .name   = "uart2_ck",
    /* Direct from ULPD, no real parent */
    .parent = &armper_ck,     /* either armper_ck or dpll4 */
    .rate   = 12000000,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
            ALWAYS_ENABLED,
};

static struct clk uart3_1510 = {
    .name   = "uart3_ck",
    /* Direct from ULPD, no real parent */
    .parent = &armper_ck,     /* either armper_ck or dpll4 */
    .rate   = 12000000,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
};

static struct clk uart3_16xx = {
    .name   = "uart3_ck",
    /* Direct from ULPD, no real parent */
    .parent = &armper_ck,
    .rate   = 48000000,
    .flags  = CLOCK_IN_OMAP16XX,
};

static struct clk usb_clk0 = {      /* 6 MHz output on W4_USB_CLK0 */
    .name   = "usb_clk0",
    .alias  = "usb.clko",
    /* Direct from ULPD, no parent */
    .rate   = 6000000,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
};

static struct clk usb_hhc_ck1510 = {
    .name   = "usb_hhc_ck",
    /* Direct from ULPD, no parent */
    .rate   = 48000000, /* Actually 2 clocks, 12MHz and 48MHz */
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
};

static struct clk usb_hhc_ck16xx = {
    .name   = "usb_hhc_ck",
    /* Direct from ULPD, no parent */
    .rate   = 48000000,
    /* OTG_SYSCON_2.OTG_PADEN == 0 (not 1510-compatible) */
    .flags  = CLOCK_IN_OMAP16XX,
};

static struct clk usb_w2fc_mclk = {
    .name   = "usb_w2fc_mclk",
    .alias  = "usb_w2fc_ck",
    .parent = &ck_48m,
    .rate   = 48000000,
    .flags  = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
};

static struct clk mclk_1510 = {
    .name   = "mclk",
    /* Direct from ULPD, no parent. May be enabled by ext hardware. */
    .rate   = 12000000,
    .flags  = CLOCK_IN_OMAP1510,
};

static struct clk bclk_310 = {
    .name   = "bt_mclk_out",  /* Alias midi_mclk_out? */
    .parent = &armper_ck,
    .flags  = CLOCK_IN_OMAP310,
};

static struct clk mclk_310 = {
    .name   = "com_mclk_out",
    .parent = &armper_ck,
    .flags  = CLOCK_IN_OMAP310,
};

static struct clk mclk_16xx = {
    .name   = "mclk",
    /* Direct from ULPD, no parent. May be enabled by ext hardware. */
    .flags  = CLOCK_IN_OMAP16XX,
};

static struct clk bclk_1510 = {
    .name   = "bclk",
    /* Direct from ULPD, no parent. May be enabled by ext hardware. */
    .rate   = 12000000,
    .flags  = CLOCK_IN_OMAP1510,
};

static struct clk bclk_16xx = {
    .name   = "bclk",
    /* Direct from ULPD, no parent. May be enabled by ext hardware. */
    .flags  = CLOCK_IN_OMAP16XX,
};

static struct clk mmc1_ck = {
    .name   = "mmc_ck",
    .id           = 1,
    /* Functional clock is direct from ULPD, interface clock is ARMPER */
    .parent = &armper_ck,     /* either armper_ck or dpll4 */
    .rate   = 48000000,
    .flags  = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
};

static struct clk mmc2_ck = {
    .name   = "mmc_ck",
    .id           = 2,
    /* Functional clock is direct from ULPD, interface clock is ARMPER */
    .parent = &armper_ck,
    .rate   = 48000000,
    .flags  = CLOCK_IN_OMAP16XX,
};

static struct clk cam_mclk = {
    .name   = "cam.mclk",
    .flags  = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
    .rate   = 12000000,
};

static struct clk cam_exclk = {
    .name   = "cam.exclk",
    .flags  = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
    /* Either 12M from cam.mclk or 48M from dpll4 */
    .parent = &cam_mclk,
};

static struct clk cam_lclk = {
    .name   = "cam.lclk",
    .flags  = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
};

static struct clk i2c_fck = {
    .name   = "i2c_fck",
    .id           = 1,
    .flags  = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX |
            ALWAYS_ENABLED,
    .parent = &armxor_ck,
};

static struct clk i2c_ick = {
    .name   = "i2c_ick",
    .id           = 1,
    .flags  = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
    .parent = &armper_ck,
};

static struct clk clk32k = {
    .name   = "clk32-kHz",
    .flags  = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX |
            ALWAYS_ENABLED,
    .parent     = &xtal_osc32k,
};

static struct clk *onchip_clks[] = {
    /* non-ULPD clocks */
    &xtal_osc12m,
    &xtal_osc32k,
    &ck_ref,
    &dpll1,
    &dpll2,
    &dpll3,
    &dpll4,
    &apll,
    &ck_48m,
    /* CK_GEN1 clocks */
    &clkm1,
    &ck_dpll1out,
    &sossi_ck,
    &arm_ck,
    &armper_ck,
    &arm_gpio_ck,
    &armxor_ck,
    &armtim_ck,
    &armwdt_ck,
    &arminth_ck15xx,  &arminth_ck16xx,
    /* CK_GEN2 clocks */
    &clkm2,
    &dsp_ck,
    &dspmmu_ck,
    &dspper_ck,
    &dspxor_ck,
    &dsptim_ck,
    /* CK_GEN3 clocks */
    &clkm3,
    &tc_ck,
    &tipb_ck,
    &l3_ocpi_ck,
    &tc1_ck,
    &tc2_ck,
    &dma_ck,
    &dma_lcdfree_ck,
    &api_ck,
    &lb_ck,
    &lbfree_ck,
    &hsab_ck,
    &rhea1_ck,
    &rhea2_ck,
    &lcd_ck_16xx,
    &lcd_ck_1510,
    /* ULPD clocks */
    &uart1_1510,
    &uart1_16xx,
    &uart2_ck,
    &uart3_1510,
    &uart3_16xx,
    &usb_clk0,
    &usb_hhc_ck1510, &usb_hhc_ck16xx,
    &mclk_1510,  &mclk_16xx, &mclk_310,
    &bclk_1510,  &bclk_16xx, &bclk_310,
    &mmc1_ck,
    &mmc2_ck,
    &cam_mclk,
    &cam_exclk,
    &cam_lclk,
    &clk32k,
    &usb_w2fc_mclk,
    /* Virtual clocks */
    &i2c_fck,
    &i2c_ick,
    0
};

void omap_clk_adduser(struct clk *clk, qemu_irq user)
{
    qemu_irq *i;

    for (i = clk->users; *i; i ++);
    *i = user;
}

/* If a clock is allowed to idle, it is disabled automatically when
 * all of clock domains using it are disabled.  */
int omap_clk_is_idle(struct clk *clk)
{
    struct clk *chld;

    if (!clk->enabled && (!clk->usecount || !(clk->flags && ALWAYS_ENABLED)))
        return 1;
    if (clk->usecount)
        return 0;

    for (chld = clk->child1; chld; chld = chld->sibling)
        if (!omap_clk_is_idle(chld))
            return 0;
    return 1;
}

struct clk *omap_findclk(struct omap_mpu_state_s *mpu, const char *name)
{
    struct clk *i;

    for (i = mpu->clks; i->name; i ++)
        if (!strcmp(i->name, name) || (i->alias && !strcmp(i->alias, name)))
            return i;
    cpu_abort(mpu->env, "%s: %s not found\n", __FUNCTION__, name);
}

void omap_clk_get(struct clk *clk)
{
    clk->usecount ++;
}

void omap_clk_put(struct clk *clk)
{
    if (!(clk->usecount --))
        cpu_abort(cpu_single_env, "%s: %s is not in use\n",
                        __FUNCTION__, clk->name);
}

static void omap_clk_update(struct clk *clk)
{
    int parent, running;
    qemu_irq *user;
    struct clk *i;

    if (clk->parent)
        parent = clk->parent->running;
    else
        parent = 1;

    running = parent && (clk->enabled ||
                    ((clk->flags & ALWAYS_ENABLED) && clk->usecount));
    if (clk->running != running) {
        clk->running = running;
        for (user = clk->users; *user; user ++)
            qemu_set_irq(*user, running);
        for (i = clk->child1; i; i = i->sibling)
            omap_clk_update(i);
    }
}

static void omap_clk_rate_update_full(struct clk *clk, unsigned long int rate,
                unsigned long int div, unsigned long int mult)
{
    struct clk *i;
    qemu_irq *user;

    clk->rate = muldiv64(rate, mult, div);
    if (clk->running)
        for (user = clk->users; *user; user ++)
            qemu_irq_raise(*user);
    for (i = clk->child1; i; i = i->sibling)
        omap_clk_rate_update_full(i, rate,
                        div * i->divisor, mult * i->multiplier);
}

static void omap_clk_rate_update(struct clk *clk)
{
    struct clk *i;
    unsigned long int div, mult = div = 1;

    for (i = clk; i->parent; i = i->parent) {
        div *= i->divisor;
        mult *= i->multiplier;
    }

    omap_clk_rate_update_full(clk, i->rate, div, mult);
}

void omap_clk_reparent(struct clk *clk, struct clk *parent)
{
    struct clk **p;

    if (clk->parent) {
        for (p = &clk->parent->child1; *p != clk; p = &(*p)->sibling);
        *p = clk->sibling;
    }

    clk->parent = parent;
    if (parent) {
        clk->sibling = parent->child1;
        parent->child1 = clk;
        omap_clk_update(clk);
        omap_clk_rate_update(clk);
    } else
        clk->sibling = 0;
}

void omap_clk_onoff(struct clk *clk, int on)
{
    clk->enabled = on;
    omap_clk_update(clk);
}

void omap_clk_canidle(struct clk *clk, int can)
{
    if (can)
        omap_clk_put(clk);
    else
        omap_clk_get(clk);
}

void omap_clk_setrate(struct clk *clk, int divide, int multiply)
{
    clk->divisor = divide;
    clk->multiplier = multiply;
    omap_clk_rate_update(clk);
}

int64_t omap_clk_getrate(omap_clk clk)
{
    return clk->rate;
}

void omap_clk_init(struct omap_mpu_state_s *mpu)
{
    struct clk **i, *j, *k;
    int count;
    int flag;

    if (cpu_is_omap310(mpu))
        flag = CLOCK_IN_OMAP310;
    else if (cpu_is_omap1510(mpu))
        flag = CLOCK_IN_OMAP1510;
    else
        return;

    for (i = onchip_clks, count = 0; *i; i ++)
        if ((*i)->flags & flag)
            count ++;
    mpu->clks = (struct clk *) qemu_mallocz(sizeof(struct clk) * (count + 1));
    for (i = onchip_clks, j = mpu->clks; *i; i ++)
        if ((*i)->flags & flag) {
            memcpy(j, *i, sizeof(struct clk));
            for (k = mpu->clks; k < j; k ++)
                if (j->parent && !strcmp(j->parent->name, k->name)) {
                    j->parent = k;
                    j->sibling = k->child1;
                    k->child1 = j;
                } else if (k->parent && !strcmp(k->parent->name, j->name)) {
                    k->parent = j;
                    k->sibling = j->child1;
                    j->child1 = k;
                }
            j->divisor = j->divisor ?: 1;
            j->multiplier = j->multiplier ?: 1;
            j ++;
        }
    for (j = mpu->clks; count --; j ++) {
        omap_clk_update(j);
        omap_clk_rate_update(j);
    }
}

Generated by  Doxygen 1.6.0   Back to index