|
|
|
|
/*
|
|
|
|
|
* arch/arm/plat-omap/include/mach/clock.h
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2004 - 2005 Nokia corporation
|
|
|
|
|
* Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
|
|
|
|
|
* Based on clocks.h by Tony Lindgren, Gordon McNutt and RidgeRun, Inc
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef __ARCH_ARM_OMAP_CLOCK_H
|
|
|
|
|
#define __ARCH_ARM_OMAP_CLOCK_H
|
|
|
|
|
|
|
|
|
|
struct module;
|
|
|
|
|
struct clk;
|
|
|
|
|
struct clockdomain;
|
|
|
|
|
|
|
|
|
|
struct clkops {
|
|
|
|
|
int (*enable)(struct clk *);
|
|
|
|
|
void (*disable)(struct clk *);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
|
|
|
|
|
|
|
|
|
|
struct clksel_rate {
|
|
|
|
|
u32 val;
|
|
|
|
|
u8 div;
|
|
|
|
|
u8 flags;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct clksel {
|
|
|
|
|
struct clk *parent;
|
|
|
|
|
const struct clksel_rate *rates;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct dpll_data {
|
|
|
|
|
void __iomem *mult_div1_reg;
|
|
|
|
|
u32 mult_mask;
|
|
|
|
|
u32 div1_mask;
|
[ARM] omap: add support for bypassing DPLLs
This roughly corresponds with OMAP commits: 7d06c48, 3241b19,
88b5d9b, 18a5500, 9c909ac, 5c6497b, 8b1f0bd, 2ac1da8.
For both OMAP2 and OMAP3, we note the reference and bypass clocks in
the DPLL data structure. Whenever we modify the DPLL rate, we first
ensure that both the reference and bypass clocks are enabled. Then,
we decide whether to use the reference and DPLL, or the bypass clock
if the desired rate is identical to the bypass rate, and program the
DPLL appropriately. Finally, we update the clock's parent, and then
disable the unused clocks.
This keeps the parents correctly balanced, and more importantly ensures
that the bypass clock is running whenever we reprogram the DPLL. This
is especially important because the procedure for reprogramming the DPLL
involves switching to the bypass clock.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
16 years ago
|
|
|
struct clk *clk_bypass;
|
|
|
|
|
struct clk *clk_ref;
|
|
|
|
|
void __iomem *control_reg;
|
|
|
|
|
u32 enable_mask;
|
|
|
|
|
unsigned int rate_tolerance;
|
|
|
|
|
unsigned long last_rounded_rate;
|
ARM: OMAP2: Clock: New OMAP2/3 DPLL rate rounding algorithm
This patch adds a new rate rounding algorithm for DPLL clocks on the
OMAP2/3 architecture.
For a desired DPLL target rate, there may be several
multiplier/divider (M, N) values which will generate a sufficiently
close rate. Lower N values result in greater power economy. However,
lower N values can cause the difference between the rounded rate and
the target rate ("rate error") to be larger than it would be with a
higher N. This can cause downstream devices to run more slowly than
they otherwise would.
This DPLL rate rounding algorithm:
- attempts to find the lowest possible N (DPLL divider) to reach the
target_rate (since, according to Richard Woodruff <r-woodruff@ti.com>,
lower N values save more power than higher N values).
- allows developers to set an upper bound on the error between the
rounded rate and the desired target rate ("rate tolerance"), so an
appropriate balance between rate fidelity and power savings can be
set. This maximum rate error tolerance is set via
omap2_set_dpll_rate_tolerance().
- never returns a rounded rate higher than the target rate.
The rate rounding algorithm caches the last rounded M, N, and rate
computation to avoid rounding the rate twice for each clk_set_rate()
call. (This patch does not yet implement set_rate for DPLLs; that
follows in a future patch.)
The algorithm trades execution speed for rate accuracy. It will find
the (M, N) set that results in the least rate error, within a
specified rate tolerance. It does this by evaluating each divider
setting - on OMAP3, this involves 128 steps. Another approach to DPLL
rate rounding would be to bail out as soon as a valid rate is found
within the rate tolerance, which would trade rate accuracy for
execution speed. Alternate implementations welcome.
This code is not yet used by the OMAP24XX DPLL clock, since it
is currently defined as a composite clock, fusing the DPLL M,N and the
M2 output divider. This patch also renames the existing OMAP24xx DPLL
programming functions to highlight that they program both the DPLL and
the DPLL's output multiplier.
Signed-off-by: Paul Walmsley <paul@pwsan.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
17 years ago
|
|
|
u16 last_rounded_m;
|
|
|
|
|
u8 last_rounded_n;
|
|
|
|
|
u8 min_divider;
|
ARM: OMAP2: Clock: New OMAP2/3 DPLL rate rounding algorithm
This patch adds a new rate rounding algorithm for DPLL clocks on the
OMAP2/3 architecture.
For a desired DPLL target rate, there may be several
multiplier/divider (M, N) values which will generate a sufficiently
close rate. Lower N values result in greater power economy. However,
lower N values can cause the difference between the rounded rate and
the target rate ("rate error") to be larger than it would be with a
higher N. This can cause downstream devices to run more slowly than
they otherwise would.
This DPLL rate rounding algorithm:
- attempts to find the lowest possible N (DPLL divider) to reach the
target_rate (since, according to Richard Woodruff <r-woodruff@ti.com>,
lower N values save more power than higher N values).
- allows developers to set an upper bound on the error between the
rounded rate and the desired target rate ("rate tolerance"), so an
appropriate balance between rate fidelity and power savings can be
set. This maximum rate error tolerance is set via
omap2_set_dpll_rate_tolerance().
- never returns a rounded rate higher than the target rate.
The rate rounding algorithm caches the last rounded M, N, and rate
computation to avoid rounding the rate twice for each clk_set_rate()
call. (This patch does not yet implement set_rate for DPLLs; that
follows in a future patch.)
The algorithm trades execution speed for rate accuracy. It will find
the (M, N) set that results in the least rate error, within a
specified rate tolerance. It does this by evaluating each divider
setting - on OMAP3, this involves 128 steps. Another approach to DPLL
rate rounding would be to bail out as soon as a valid rate is found
within the rate tolerance, which would trade rate accuracy for
execution speed. Alternate implementations welcome.
This code is not yet used by the OMAP24XX DPLL clock, since it
is currently defined as a composite clock, fusing the DPLL M,N and the
M2 output divider. This patch also renames the existing OMAP24xx DPLL
programming functions to highlight that they program both the DPLL and
the DPLL's output multiplier.
Signed-off-by: Paul Walmsley <paul@pwsan.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
17 years ago
|
|
|
u8 max_divider;
|
|
|
|
|
u32 max_tolerance;
|
|
|
|
|
u16 max_multiplier;
|
|
|
|
|
# if defined(CONFIG_ARCH_OMAP3)
|
|
|
|
|
u8 modes;
|
|
|
|
|
void __iomem *autoidle_reg;
|
|
|
|
|
void __iomem *idlest_reg;
|
|
|
|
|
u32 autoidle_mask;
|
|
|
|
|
u32 freqsel_mask;
|
|
|
|
|
u32 idlest_mask;
|
|
|
|
|
u8 auto_recal_bit;
|
|
|
|
|
u8 recal_en_bit;
|
|
|
|
|
u8 recal_st_bit;
|
|
|
|
|
# endif
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
struct clk {
|
|
|
|
|
struct list_head node;
|
|
|
|
|
const struct clkops *ops;
|
|
|
|
|
const char *name;
|
|
|
|
|
int id;
|
|
|
|
|
struct clk *parent;
|
|
|
|
|
struct list_head children;
|
|
|
|
|
struct list_head sibling; /* node for children */
|
|
|
|
|
unsigned long rate;
|
|
|
|
|
__u32 flags;
|
|
|
|
|
void __iomem *enable_reg;
|
|
|
|
|
unsigned long (*recalc)(struct clk *);
|
|
|
|
|
int (*set_rate)(struct clk *, unsigned long);
|
|
|
|
|
long (*round_rate)(struct clk *, unsigned long);
|
|
|
|
|
void (*init)(struct clk *);
|
|
|
|
|
__u8 enable_bit;
|
|
|
|
|
__s8 usecount;
|
|
|
|
|
#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
|
|
|
|
|
u8 fixed_div;
|
|
|
|
|
void __iomem *clksel_reg;
|
|
|
|
|
u32 clksel_mask;
|
|
|
|
|
const struct clksel *clksel;
|
ARM: OMAP2: Clock: New OMAP2/3 DPLL rate rounding algorithm
This patch adds a new rate rounding algorithm for DPLL clocks on the
OMAP2/3 architecture.
For a desired DPLL target rate, there may be several
multiplier/divider (M, N) values which will generate a sufficiently
close rate. Lower N values result in greater power economy. However,
lower N values can cause the difference between the rounded rate and
the target rate ("rate error") to be larger than it would be with a
higher N. This can cause downstream devices to run more slowly than
they otherwise would.
This DPLL rate rounding algorithm:
- attempts to find the lowest possible N (DPLL divider) to reach the
target_rate (since, according to Richard Woodruff <r-woodruff@ti.com>,
lower N values save more power than higher N values).
- allows developers to set an upper bound on the error between the
rounded rate and the desired target rate ("rate tolerance"), so an
appropriate balance between rate fidelity and power savings can be
set. This maximum rate error tolerance is set via
omap2_set_dpll_rate_tolerance().
- never returns a rounded rate higher than the target rate.
The rate rounding algorithm caches the last rounded M, N, and rate
computation to avoid rounding the rate twice for each clk_set_rate()
call. (This patch does not yet implement set_rate for DPLLs; that
follows in a future patch.)
The algorithm trades execution speed for rate accuracy. It will find
the (M, N) set that results in the least rate error, within a
specified rate tolerance. It does this by evaluating each divider
setting - on OMAP3, this involves 128 steps. Another approach to DPLL
rate rounding would be to bail out as soon as a valid rate is found
within the rate tolerance, which would trade rate accuracy for
execution speed. Alternate implementations welcome.
This code is not yet used by the OMAP24XX DPLL clock, since it
is currently defined as a composite clock, fusing the DPLL M,N and the
M2 output divider. This patch also renames the existing OMAP24xx DPLL
programming functions to highlight that they program both the DPLL and
the DPLL's output multiplier.
Signed-off-by: Paul Walmsley <paul@pwsan.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
17 years ago
|
|
|
struct dpll_data *dpll_data;
|
|
|
|
|
const char *clkdm_name;
|
|
|
|
|
struct clockdomain *clkdm;
|
|
|
|
|
#else
|
|
|
|
|
__u8 rate_offset;
|
|
|
|
|
__u8 src_offset;
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS)
|
|
|
|
|
struct dentry *dent; /* For visible tree hierarchy */
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct cpufreq_frequency_table;
|
|
|
|
|
|
|
|
|
|
struct clk_functions {
|
|
|
|
|
int (*clk_enable)(struct clk *clk);
|
|
|
|
|
void (*clk_disable)(struct clk *clk);
|
|
|
|
|
long (*clk_round_rate)(struct clk *clk, unsigned long rate);
|
|
|
|
|
int (*clk_set_rate)(struct clk *clk, unsigned long rate);
|
|
|
|
|
int (*clk_set_parent)(struct clk *clk, struct clk *parent);
|
|
|
|
|
void (*clk_allow_idle)(struct clk *clk);
|
|
|
|
|
void (*clk_deny_idle)(struct clk *clk);
|
|
|
|
|
void (*clk_disable_unused)(struct clk *clk);
|
|
|
|
|
#ifdef CONFIG_CPU_FREQ
|
|
|
|
|
void (*clk_init_cpufreq_table)(struct cpufreq_frequency_table **);
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
extern unsigned int mpurate;
|
|
|
|
|
|
|
|
|
|
extern int clk_init(struct clk_functions *custom_clocks);
|
|
|
|
|
extern void clk_init_one(struct clk *clk);
|
|
|
|
|
extern int clk_register(struct clk *clk);
|
|
|
|
|
extern void clk_reparent(struct clk *child, struct clk *parent);
|
|
|
|
|
extern void clk_unregister(struct clk *clk);
|
|
|
|
|
extern void propagate_rate(struct clk *clk);
|
|
|
|
|
extern void recalculate_root_clocks(void);
|
|
|
|
|
extern unsigned long followparent_recalc(struct clk *clk);
|
|
|
|
|
extern void clk_enable_init_clocks(void);
|
|
|
|
|
#ifdef CONFIG_CPU_FREQ
|
|
|
|
|
extern void clk_init_cpufreq_table(struct cpufreq_frequency_table **table);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
extern const struct clkops clkops_null;
|
|
|
|
|
|
|
|
|
|
/* Clock flags */
|
|
|
|
|
/* bit 0 is free */
|
|
|
|
|
#define RATE_FIXED (1 << 1) /* Fixed clock rate */
|
|
|
|
|
/* bits 2-4 are free */
|
|
|
|
|
#define ENABLE_REG_32BIT (1 << 5) /* Use 32-bit access */
|
|
|
|
|
#define CLOCK_IDLE_CONTROL (1 << 7)
|
|
|
|
|
#define CLOCK_NO_IDLE_PARENT (1 << 8)
|
|
|
|
|
#define DELAYED_APP (1 << 9) /* Delay application of clock */
|
|
|
|
|
#define CONFIG_PARTICIPANT (1 << 10) /* Fundamental clock */
|
|
|
|
|
#define ENABLE_ON_INIT (1 << 11) /* Enable upon framework init */
|
|
|
|
|
#define INVERT_ENABLE (1 << 12) /* 0 enables, 1 disables */
|
|
|
|
|
/* bits 13-31 are currently free */
|
|
|
|
|
|
|
|
|
|
/* Clksel_rate flags */
|
|
|
|
|
#define DEFAULT_RATE (1 << 0)
|
|
|
|
|
#define RATE_IN_242X (1 << 1)
|
|
|
|
|
#define RATE_IN_243X (1 << 2)
|
|
|
|
|
#define RATE_IN_343X (1 << 3) /* rates common to all 343X */
|
|
|
|
|
#define RATE_IN_3430ES2 (1 << 4) /* 3430ES2 rates only */
|
|
|
|
|
|
|
|
|
|
#define RATE_IN_24XX (RATE_IN_242X | RATE_IN_243X)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#endif
|
