clk-mux.c 5.76 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
/*
 * Copyright (C) 2011 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de>
 * Copyright (C) 2011 Richard Zhao, Linaro <richard.zhao@linaro.org>
 * Copyright (C) 2011-2012 Mike Turquette, Linaro Ltd <mturquette@linaro.org>
 *
 * 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.
 *
 * Simple multiplexer clock implementation
 */

#include <linux/clk-provider.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/err.h>

/*
 * DOC: basic adjustable multiplexer clock that cannot gate
 *
 * Traits of this clock:
 * prepare - clk_prepare only ensures that parents are prepared
 * enable - clk_enable only ensures that parents are enabled
 * rate - rate is only affected by parent switching.  No clk_set_rate support
 * parent - parent is adjustable through clk_set_parent
 */

static u8 clk_mux_get_parent(struct clk_hw *hw)
{
	struct clk_mux *mux = to_clk_mux(hw);
32
	int num_parents = clk_hw_get_num_parents(hw);
33 34 35 36 37 38 39 40 41
	u32 val;

	/*
	 * FIXME need a mux-specific flag to determine if val is bitwise or numeric
	 * e.g. sys_clkin_ck's clksel field is 3 bits wide, but ranges from 0x1
	 * to 0x7 (index starts at one)
	 * OTOH, pmd_trace_clk_mux_ck uses a separate bit for each clock, so
	 * val = 0x4 really means "bit 2, index starts at bit 0"
	 */
42
	val = clk_readl(mux->reg) >> mux->shift;
43 44 45 46 47 48 49 50 51 52
	val &= mux->mask;

	if (mux->table) {
		int i;

		for (i = 0; i < num_parents; i++)
			if (mux->table[i] == val)
				return i;
		return -EINVAL;
	}
53 54 55 56 57 58 59

	if (val && (mux->flags & CLK_MUX_INDEX_BIT))
		val = ffs(val) - 1;

	if (val && (mux->flags & CLK_MUX_INDEX_ONE))
		val--;

60
	if (val >= num_parents)
61 62 63 64 65 66 67 68 69 70 71
		return -EINVAL;

	return val;
}

static int clk_mux_set_parent(struct clk_hw *hw, u8 index)
{
	struct clk_mux *mux = to_clk_mux(hw);
	u32 val;
	unsigned long flags = 0;

72
	if (mux->table) {
73
		index = mux->table[index];
74
	} else {
75
		if (mux->flags & CLK_MUX_INDEX_BIT)
76
			index = 1 << index;
77 78 79 80

		if (mux->flags & CLK_MUX_INDEX_ONE)
			index++;
	}
81 82 83

	if (mux->lock)
		spin_lock_irqsave(mux->lock, flags);
84 85
	else
		__acquire(mux->lock);
86

87 88 89
	if (mux->flags & CLK_MUX_HIWORD_MASK) {
		val = mux->mask << (mux->shift + 16);
	} else {
90
		val = clk_readl(mux->reg);
91 92
		val &= ~(mux->mask << mux->shift);
	}
93
	val |= index << mux->shift;
94
	clk_writel(val, mux->reg);
95 96 97

	if (mux->lock)
		spin_unlock_irqrestore(mux->lock, flags);
98 99
	else
		__release(mux->lock);
100 101 102 103

	return 0;
}

104
const struct clk_ops clk_mux_ops = {
105 106
	.get_parent = clk_mux_get_parent,
	.set_parent = clk_mux_set_parent,
107
	.determine_rate = __clk_mux_determine_rate,
108 109 110
};
EXPORT_SYMBOL_GPL(clk_mux_ops);

111 112 113 114 115
const struct clk_ops clk_mux_ro_ops = {
	.get_parent = clk_mux_get_parent,
};
EXPORT_SYMBOL_GPL(clk_mux_ro_ops);

116
struct clk_hw *clk_hw_register_mux_table(struct device *dev, const char *name,
117 118
		const char * const *parent_names, u8 num_parents,
		unsigned long flags,
119 120
		void __iomem *reg, u8 shift, u32 mask,
		u8 clk_mux_flags, u32 *table, spinlock_t *lock)
121 122
{
	struct clk_mux *mux;
123
	struct clk_hw *hw;
124
	struct clk_init_data init;
125
	u8 width = 0;
126
	int ret;
127 128 129 130 131 132 133 134

	if (clk_mux_flags & CLK_MUX_HIWORD_MASK) {
		width = fls(mask) - ffs(mask) + 1;
		if (width + shift > 16) {
			pr_err("mux value exceeds LOWORD field\n");
			return ERR_PTR(-EINVAL);
		}
	}
135

136
	/* allocate the mux */
137
	mux = kzalloc(sizeof(struct clk_mux), GFP_KERNEL);
138 139 140 141 142
	if (!mux) {
		pr_err("%s: could not allocate mux clk\n", __func__);
		return ERR_PTR(-ENOMEM);
	}

143
	init.name = name;
144 145 146 147
	if (clk_mux_flags & CLK_MUX_READ_ONLY)
		init.ops = &clk_mux_ro_ops;
	else
		init.ops = &clk_mux_ops;
148
	init.flags = flags | CLK_IS_BASIC;
149 150 151
	init.parent_names = parent_names;
	init.num_parents = num_parents;

152 153 154
	/* struct clk_mux assignments */
	mux->reg = reg;
	mux->shift = shift;
155
	mux->mask = mask;
156 157
	mux->flags = clk_mux_flags;
	mux->lock = lock;
158
	mux->table = table;
159
	mux->hw.init = &init;
160

161 162 163
	hw = &mux->hw;
	ret = clk_hw_register(dev, hw);
	if (ret) {
164
		kfree(mux);
165 166
		hw = ERR_PTR(ret);
	}
167

168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
	return hw;
}
EXPORT_SYMBOL_GPL(clk_hw_register_mux_table);

struct clk *clk_register_mux_table(struct device *dev, const char *name,
		const char * const *parent_names, u8 num_parents,
		unsigned long flags,
		void __iomem *reg, u8 shift, u32 mask,
		u8 clk_mux_flags, u32 *table, spinlock_t *lock)
{
	struct clk_hw *hw;

	hw = clk_hw_register_mux_table(dev, name, parent_names, num_parents,
				       flags, reg, shift, mask, clk_mux_flags,
				       table, lock);
	if (IS_ERR(hw))
		return ERR_CAST(hw);
	return hw->clk;
186
}
187
EXPORT_SYMBOL_GPL(clk_register_mux_table);
188 189

struct clk *clk_register_mux(struct device *dev, const char *name,
190 191
		const char * const *parent_names, u8 num_parents,
		unsigned long flags,
192 193 194 195 196 197 198 199 200
		void __iomem *reg, u8 shift, u8 width,
		u8 clk_mux_flags, spinlock_t *lock)
{
	u32 mask = BIT(width) - 1;

	return clk_register_mux_table(dev, name, parent_names, num_parents,
				      flags, reg, shift, mask, clk_mux_flags,
				      NULL, lock);
}
201
EXPORT_SYMBOL_GPL(clk_register_mux);
202

203 204 205 206 207 208 209 210 211 212 213 214 215 216
struct clk_hw *clk_hw_register_mux(struct device *dev, const char *name,
		const char * const *parent_names, u8 num_parents,
		unsigned long flags,
		void __iomem *reg, u8 shift, u8 width,
		u8 clk_mux_flags, spinlock_t *lock)
{
	u32 mask = BIT(width) - 1;

	return clk_hw_register_mux_table(dev, name, parent_names, num_parents,
				      flags, reg, shift, mask, clk_mux_flags,
				      NULL, lock);
}
EXPORT_SYMBOL_GPL(clk_hw_register_mux);

217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
void clk_unregister_mux(struct clk *clk)
{
	struct clk_mux *mux;
	struct clk_hw *hw;

	hw = __clk_get_hw(clk);
	if (!hw)
		return;

	mux = to_clk_mux(hw);

	clk_unregister(clk);
	kfree(mux);
}
EXPORT_SYMBOL_GPL(clk_unregister_mux);
232 233 234 235 236 237 238 239 240 241 242

void clk_hw_unregister_mux(struct clk_hw *hw)
{
	struct clk_mux *mux;

	mux = to_clk_mux(hw);

	clk_hw_unregister(hw);
	kfree(mux);
}
EXPORT_SYMBOL_GPL(clk_hw_unregister_mux);