clock.c 9.7 KB
Newer Older
1 2 3
/*
 *  linux/arch/arm/mach-omap2/clock.c
 *
4
 *  Copyright (C) 2005-2008 Texas Instruments, Inc.
5
 *  Copyright (C) 2004-2010 Nokia Corporation
6
 *
7 8
 *  Contacts:
 *  Richard Woodruff <r-woodruff2@ti.com>
9 10 11 12 13 14 15 16 17 18 19 20
 *  Paul Walmsley
 *
 * 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.
 */
#undef DEBUG

#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/errno.h>
#include <linux/clk.h>
21
#include <linux/io.h>
22
#include <linux/bitops.h>
23

24 25 26 27
#include <plat/clock.h>
#include <plat/clockdomain.h>
#include <plat/cpu.h>
#include <plat/prcm.h>
28 29 30 31 32 33 34 35 36 37 38

#include "clock.h"
#include "prm.h"
#include "prm-regbits-24xx.h"
#include "cm.h"
#include "cm-regbits-24xx.h"
#include "cm-regbits-34xx.h"

u8 cpu_mask;

/*-------------------------------------------------------------------------
39
 * OMAP2/3/4 specific clock functions
40 41
 *-------------------------------------------------------------------------*/

42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
/* Private functions */

/**
 * _omap2_module_wait_ready - wait for an OMAP module to leave IDLE
 * @clk: struct clk * belonging to the module
 *
 * If the necessary clocks for the OMAP hardware IP block that
 * corresponds to clock @clk are enabled, then wait for the module to
 * indicate readiness (i.e., to leave IDLE).  This code does not
 * belong in the clock code and will be moved in the medium term to
 * module-dependent code.  No return value.
 */
static void _omap2_module_wait_ready(struct clk *clk)
{
	void __iomem *companion_reg, *idlest_reg;
57
	u8 other_bit, idlest_bit, idlest_val;
58 59 60 61 62 63 64 65

	/* Not all modules have multiple clocks that their IDLEST depends on */
	if (clk->ops->find_companion) {
		clk->ops->find_companion(clk, &companion_reg, &other_bit);
		if (!(__raw_readl(companion_reg) & (1 << other_bit)))
			return;
	}

66
	clk->ops->find_idlest(clk, &idlest_reg, &idlest_bit, &idlest_val);
67

68 69
	omap2_cm_wait_idlest(idlest_reg, (1 << idlest_bit), idlest_val,
			     clk->name);
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
}

/* Enables clock without considering parent dependencies or use count
 * REVISIT: Maybe change this to use clk->enable like on omap1?
 */
static int _omap2_clk_enable(struct clk *clk)
{
	return clk->ops->enable(clk);
}

/* Disables clock without considering parent dependencies or use count */
static void _omap2_clk_disable(struct clk *clk)
{
	clk->ops->disable(clk);
}

/* Public functions */

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
/**
 * omap2_init_clk_clkdm - look up a clockdomain name, store pointer in clk
 * @clk: OMAP clock struct ptr to use
 *
 * Convert a clockdomain name stored in a struct clk 'clk' into a
 * clockdomain pointer, and save it into the struct clk.  Intended to be
 * called during clk_register().  No return value.
 */
void omap2_init_clk_clkdm(struct clk *clk)
{
	struct clockdomain *clkdm;

	if (!clk->clkdm_name)
		return;

	clkdm = clkdm_lookup(clk->clkdm_name);
	if (clkdm) {
		pr_debug("clock: associated clk %s to clkdm %s\n",
			 clk->name, clk->clkdm_name);
		clk->clkdm = clkdm;
	} else {
		pr_debug("clock: could not associate clk %s to "
			 "clkdm %s\n", clk->name, clk->clkdm_name);
	}
}

114
/**
115 116 117 118 119 120 121 122
 * omap2_clk_dflt_find_companion - find companion clock to @clk
 * @clk: struct clk * to find the companion clock of
 * @other_reg: void __iomem ** to return the companion clock CM_*CLKEN va in
 * @other_bit: u8 ** to return the companion clock bit shift in
 *
 * Note: We don't need special code here for INVERT_ENABLE for the
 * time being since INVERT_ENABLE only applies to clocks enabled by
 * CM_CLKEN_PLL
123
 *
124 125 126 127 128 129 130 131 132 133
 * Convert CM_ICLKEN* <-> CM_FCLKEN*.  This conversion assumes it's
 * just a matter of XORing the bits.
 *
 * Some clocks don't have companion clocks.  For example, modules with
 * only an interface clock (such as MAILBOXES) don't have a companion
 * clock.  Right now, this code relies on the hardware exporting a bit
 * in the correct companion register that indicates that the
 * nonexistent 'companion clock' is active.  Future patches will
 * associate this type of code with per-module data structures to
 * avoid this issue, and remove the casts.  No return value.
134
 */
135 136
void omap2_clk_dflt_find_companion(struct clk *clk, void __iomem **other_reg,
				   u8 *other_bit)
137
{
138
	u32 r;
139 140

	/*
141 142
	 * Convert CM_ICLKEN* <-> CM_FCLKEN*.  This conversion assumes
	 * it's just a matter of XORing the bits.
143
	 */
144
	r = ((__force u32)clk->enable_reg ^ (CM_FCLKEN ^ CM_ICLKEN));
145

146 147 148
	*other_reg = (__force void __iomem *)r;
	*other_bit = clk->enable_bit;
}
149

150 151 152 153
/**
 * omap2_clk_dflt_find_idlest - find CM_IDLEST reg va, bit shift for @clk
 * @clk: struct clk * to find IDLEST info for
 * @idlest_reg: void __iomem ** to return the CM_IDLEST va in
154 155
 * @idlest_bit: u8 * to return the CM_IDLEST bit shift in
 * @idlest_val: u8 * to return the idle status indicator
156 157 158 159 160 161 162
 *
 * Return the CM_IDLEST register address and bit shift corresponding
 * to the module that "owns" this clock.  This default code assumes
 * that the CM_IDLEST bit shift is the CM_*CLKEN bit shift, and that
 * the IDLEST register address ID corresponds to the CM_*CLKEN
 * register address ID (e.g., that CM_FCLKEN2 corresponds to
 * CM_IDLEST2).  This is not true for all modules.  No return value.
163
 */
164
void omap2_clk_dflt_find_idlest(struct clk *clk, void __iomem **idlest_reg,
165
				u8 *idlest_bit, u8 *idlest_val)
166
{
167
	u32 r;
168

169 170 171
	r = (((__force u32)clk->enable_reg & ~0xf0) | 0x20);
	*idlest_reg = (__force void __iomem *)r;
	*idlest_bit = clk->enable_bit;
172 173 174 175 176 177 178 179 180 181 182 183 184

	/*
	 * 24xx uses 0 to indicate not ready, and 1 to indicate ready.
	 * 34xx reverses this, just to keep us on our toes
	 * AM35xx uses both, depending on the module.
	 */
	if (cpu_is_omap24xx())
		*idlest_val = OMAP24XX_CM_IDLEST_VAL;
	else if (cpu_is_omap34xx())
		*idlest_val = OMAP34XX_CM_IDLEST_VAL;
	else
		BUG();

185
}
186

187
int omap2_dflt_clk_enable(struct clk *clk)
188
{
189
	u32 v;
190

191
	if (unlikely(clk->enable_reg == NULL)) {
192
		pr_err("clock.c: Enable for %s without enable code\n",
193 194 195 196
		       clk->name);
		return 0; /* REVISIT: -EINVAL */
	}

197
	v = __raw_readl(clk->enable_reg);
198
	if (clk->flags & INVERT_ENABLE)
199
		v &= ~(1 << clk->enable_bit);
200
	else
201 202
		v |= (1 << clk->enable_bit);
	__raw_writel(v, clk->enable_reg);
203
	v = __raw_readl(clk->enable_reg); /* OCP barrier */
204

205
	if (clk->ops->find_idlest)
206
		_omap2_module_wait_ready(clk);
207

208
	return 0;
209 210
}

211
void omap2_dflt_clk_disable(struct clk *clk)
212
{
213
	u32 v;
214

215
	if (!clk->enable_reg) {
216 217 218 219 220 221 222 223 224
		/*
		 * 'Independent' here refers to a clock which is not
		 * controlled by its parent.
		 */
		printk(KERN_ERR "clock: clk_disable called on independent "
		       "clock %s which has no enable_reg\n", clk->name);
		return;
	}

225
	v = __raw_readl(clk->enable_reg);
226
	if (clk->flags & INVERT_ENABLE)
227
		v |= (1 << clk->enable_bit);
228
	else
229 230
		v &= ~(1 << clk->enable_bit);
	__raw_writel(v, clk->enable_reg);
231
	/* No OCP barrier needed here since it is a disable operation */
232 233
}

234
const struct clkops clkops_omap2_dflt_wait = {
235
	.enable		= omap2_dflt_clk_enable,
236
	.disable	= omap2_dflt_clk_disable,
237 238
	.find_companion	= omap2_clk_dflt_find_companion,
	.find_idlest	= omap2_clk_dflt_find_idlest,
239 240
};

241 242 243 244 245
const struct clkops clkops_omap2_dflt = {
	.enable		= omap2_dflt_clk_enable,
	.disable	= omap2_dflt_clk_disable,
};

246 247 248 249
void omap2_clk_disable(struct clk *clk)
{
	if (clk->usecount > 0 && !(--clk->usecount)) {
		_omap2_clk_disable(clk);
250
		if (clk->parent)
251
			omap2_clk_disable(clk->parent);
252 253 254
		if (clk->clkdm)
			omap2_clkdm_clk_disable(clk->clkdm, clk);

255 256 257 258 259 260 261 262
	}
}

int omap2_clk_enable(struct clk *clk)
{
	int ret = 0;

	if (clk->usecount++ == 0) {
263 264 265
		if (clk->clkdm)
			omap2_clkdm_clk_enable(clk->clkdm, clk);

266
		if (clk->parent) {
267
			ret = omap2_clk_enable(clk->parent);
268 269
			if (ret)
				goto err;
270
		}
271

272
		ret = _omap2_clk_enable(clk);
273 274
		if (ret) {
			if (clk->parent)
275
				omap2_clk_disable(clk->parent);
276 277

			goto err;
278 279
		}
	}
280
	return ret;
281

282
err:
283 284
	if (clk->clkdm)
		omap2_clkdm_clk_disable(clk->clkdm, clk);
285
	clk->usecount--;
286 287 288 289 290 291 292 293 294 295 296
	return ret;
}

/* Set the clock rate for a clock source */
int omap2_clk_set_rate(struct clk *clk, unsigned long rate)
{
	int ret = -EINVAL;

	pr_debug("clock: set_rate for clock %s to rate %ld\n", clk->name, rate);

	/* dpll_ck, core_ck, virt_prcm_set; plus all clksel clocks */
297
	if (clk->set_rate)
298 299 300 301 302 303 304 305 306 307
		ret = clk->set_rate(clk, rate);

	return ret;
}

int omap2_clk_set_parent(struct clk *clk, struct clk *new_parent)
{
	if (!clk->clksel)
		return -EINVAL;

308 309 310
	if (clk->parent == new_parent)
		return 0;

311
	return omap2_clksel_set_parent(clk, new_parent);
312 313
}

314 315 316 317 318 319 320 321 322 323 324 325
/* OMAP3/4 non-CORE DPLL clkops */

#if defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_ARCH_OMAP4)

const struct clkops clkops_omap3_noncore_dpll_ops = {
	.enable		= omap3_noncore_dpll_enable,
	.disable	= omap3_noncore_dpll_disable,
};

#endif


326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
/*-------------------------------------------------------------------------
 * Omap2 clock reset and init functions
 *-------------------------------------------------------------------------*/

#ifdef CONFIG_OMAP_RESET_CLOCKS
void omap2_clk_disable_unused(struct clk *clk)
{
	u32 regval32, v;

	v = (clk->flags & INVERT_ENABLE) ? (1 << clk->enable_bit) : 0;

	regval32 = __raw_readl(clk->enable_reg);
	if ((regval32 & (1 << clk->enable_bit)) == v)
		return;

341
	printk(KERN_DEBUG "Disabling unused clock \"%s\"\n", clk->name);
342 343 344 345 346
	if (cpu_is_omap34xx()) {
		omap2_clk_enable(clk);
		omap2_clk_disable(clk);
	} else
		_omap2_clk_disable(clk);
347 348
	if (clk->clkdm != NULL)
		pwrdm_clkdm_state_switch(clk->clkdm);
349 350
}
#endif
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367

/* Common data */

struct clk_functions omap2_clk_functions = {
	.clk_enable		= omap2_clk_enable,
	.clk_disable		= omap2_clk_disable,
	.clk_round_rate		= omap2_clk_round_rate,
	.clk_set_rate		= omap2_clk_set_rate,
	.clk_set_parent		= omap2_clk_set_parent,
	.clk_disable_unused	= omap2_clk_disable_unused,
#ifdef CONFIG_CPU_FREQ
	/* These will be removed when the OPP code is integrated */
	.clk_init_cpufreq_table	= omap2_clk_init_cpufreq_table,
	.clk_exit_cpufreq_table	= omap2_clk_exit_cpufreq_table,
#endif
};