blob: 81f977510775460fa2bf8b0bd500c69027c02274 [file] [log] [blame]
Stephen Warren45f5ff82012-04-04 15:48:31 -06001/*
2 * Register map access API - MMIO support
3 *
4 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18
Philipp Zabel878ec672013-02-14 17:39:08 +010019#include <linux/clk.h>
Stephen Warren45f5ff82012-04-04 15:48:31 -060020#include <linux/err.h>
21#include <linux/init.h>
22#include <linux/io.h>
23#include <linux/module.h>
24#include <linux/regmap.h>
25#include <linux/slab.h>
26
27struct regmap_mmio_context {
28 void __iomem *regs;
29 unsigned val_bytes;
Philipp Zabel878ec672013-02-14 17:39:08 +010030 struct clk *clk;
Stephen Warren45f5ff82012-04-04 15:48:31 -060031};
32
33static int regmap_mmio_gather_write(void *context,
34 const void *reg, size_t reg_size,
35 const void *val, size_t val_size)
36{
37 struct regmap_mmio_context *ctx = context;
38 u32 offset;
Philipp Zabel878ec672013-02-14 17:39:08 +010039 int ret;
Stephen Warren45f5ff82012-04-04 15:48:31 -060040
Stephen Warren40606db2012-04-06 15:17:32 -060041 BUG_ON(reg_size != 4);
42
Stephen Warren6b8e0902013-11-25 15:12:47 -070043 if (!IS_ERR(ctx->clk)) {
Philipp Zabel878ec672013-02-14 17:39:08 +010044 ret = clk_enable(ctx->clk);
45 if (ret < 0)
46 return ret;
47 }
48
Stephen Warren6a552442012-05-24 10:47:27 -060049 offset = *(u32 *)reg;
Stephen Warren45f5ff82012-04-04 15:48:31 -060050
51 while (val_size) {
52 switch (ctx->val_bytes) {
53 case 1:
54 writeb(*(u8 *)val, ctx->regs + offset);
55 break;
56 case 2:
Stephen Warren6a552442012-05-24 10:47:27 -060057 writew(*(u16 *)val, ctx->regs + offset);
Stephen Warren45f5ff82012-04-04 15:48:31 -060058 break;
59 case 4:
Stephen Warren6a552442012-05-24 10:47:27 -060060 writel(*(u32 *)val, ctx->regs + offset);
Stephen Warren45f5ff82012-04-04 15:48:31 -060061 break;
62#ifdef CONFIG_64BIT
63 case 8:
Stephen Warren6a552442012-05-24 10:47:27 -060064 writeq(*(u64 *)val, ctx->regs + offset);
Stephen Warren45f5ff82012-04-04 15:48:31 -060065 break;
66#endif
67 default:
68 /* Should be caught by regmap_mmio_check_config */
Stephen Warren40606db2012-04-06 15:17:32 -060069 BUG();
Stephen Warren45f5ff82012-04-04 15:48:31 -060070 }
71 val_size -= ctx->val_bytes;
72 val += ctx->val_bytes;
73 offset += ctx->val_bytes;
74 }
75
Stephen Warren6b8e0902013-11-25 15:12:47 -070076 if (!IS_ERR(ctx->clk))
Philipp Zabel878ec672013-02-14 17:39:08 +010077 clk_disable(ctx->clk);
78
Stephen Warren45f5ff82012-04-04 15:48:31 -060079 return 0;
80}
81
82static int regmap_mmio_write(void *context, const void *data, size_t count)
83{
Stephen Warren40606db2012-04-06 15:17:32 -060084 BUG_ON(count < 4);
85
Stephen Warren45f5ff82012-04-04 15:48:31 -060086 return regmap_mmio_gather_write(context, data, 4, data + 4, count - 4);
87}
88
89static int regmap_mmio_read(void *context,
90 const void *reg, size_t reg_size,
91 void *val, size_t val_size)
92{
93 struct regmap_mmio_context *ctx = context;
94 u32 offset;
Philipp Zabel878ec672013-02-14 17:39:08 +010095 int ret;
Stephen Warren45f5ff82012-04-04 15:48:31 -060096
Stephen Warren40606db2012-04-06 15:17:32 -060097 BUG_ON(reg_size != 4);
98
Stephen Warren6b8e0902013-11-25 15:12:47 -070099 if (!IS_ERR(ctx->clk)) {
Philipp Zabel878ec672013-02-14 17:39:08 +0100100 ret = clk_enable(ctx->clk);
101 if (ret < 0)
102 return ret;
103 }
104
Stephen Warren6a552442012-05-24 10:47:27 -0600105 offset = *(u32 *)reg;
Stephen Warren45f5ff82012-04-04 15:48:31 -0600106
107 while (val_size) {
108 switch (ctx->val_bytes) {
109 case 1:
110 *(u8 *)val = readb(ctx->regs + offset);
111 break;
112 case 2:
Stephen Warren6a552442012-05-24 10:47:27 -0600113 *(u16 *)val = readw(ctx->regs + offset);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600114 break;
115 case 4:
Stephen Warren6a552442012-05-24 10:47:27 -0600116 *(u32 *)val = readl(ctx->regs + offset);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600117 break;
118#ifdef CONFIG_64BIT
119 case 8:
Stephen Warren6a552442012-05-24 10:47:27 -0600120 *(u64 *)val = readq(ctx->regs + offset);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600121 break;
122#endif
123 default:
124 /* Should be caught by regmap_mmio_check_config */
Stephen Warren40606db2012-04-06 15:17:32 -0600125 BUG();
Stephen Warren45f5ff82012-04-04 15:48:31 -0600126 }
127 val_size -= ctx->val_bytes;
128 val += ctx->val_bytes;
129 offset += ctx->val_bytes;
130 }
131
Stephen Warren6b8e0902013-11-25 15:12:47 -0700132 if (!IS_ERR(ctx->clk))
Philipp Zabel878ec672013-02-14 17:39:08 +0100133 clk_disable(ctx->clk);
134
Stephen Warren45f5ff82012-04-04 15:48:31 -0600135 return 0;
136}
137
138static void regmap_mmio_free_context(void *context)
139{
Philipp Zabel878ec672013-02-14 17:39:08 +0100140 struct regmap_mmio_context *ctx = context;
141
Stephen Warren6b8e0902013-11-25 15:12:47 -0700142 if (!IS_ERR(ctx->clk)) {
Philipp Zabel878ec672013-02-14 17:39:08 +0100143 clk_unprepare(ctx->clk);
144 clk_put(ctx->clk);
145 }
Stephen Warren45f5ff82012-04-04 15:48:31 -0600146 kfree(context);
147}
148
149static struct regmap_bus regmap_mmio = {
150 .fast_io = true,
151 .write = regmap_mmio_write,
152 .gather_write = regmap_mmio_gather_write,
153 .read = regmap_mmio_read,
154 .free_context = regmap_mmio_free_context,
Stephen Warren6a552442012-05-24 10:47:27 -0600155 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
156 .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
Stephen Warren45f5ff82012-04-04 15:48:31 -0600157};
158
Philipp Zabel878ec672013-02-14 17:39:08 +0100159static struct regmap_mmio_context *regmap_mmio_gen_context(struct device *dev,
160 const char *clk_id,
161 void __iomem *regs,
Stephen Warren45f5ff82012-04-04 15:48:31 -0600162 const struct regmap_config *config)
163{
164 struct regmap_mmio_context *ctx;
Stephen Warrenf01ee602012-04-09 13:40:24 -0600165 int min_stride;
Philipp Zabel878ec672013-02-14 17:39:08 +0100166 int ret;
Stephen Warren45f5ff82012-04-04 15:48:31 -0600167
168 if (config->reg_bits != 32)
169 return ERR_PTR(-EINVAL);
170
171 if (config->pad_bits)
172 return ERR_PTR(-EINVAL);
173
174 switch (config->val_bits) {
175 case 8:
Stephen Warrenf01ee602012-04-09 13:40:24 -0600176 /* The core treats 0 as 1 */
177 min_stride = 0;
178 break;
Stephen Warren45f5ff82012-04-04 15:48:31 -0600179 case 16:
Stephen Warrenf01ee602012-04-09 13:40:24 -0600180 min_stride = 2;
181 break;
Stephen Warren45f5ff82012-04-04 15:48:31 -0600182 case 32:
Stephen Warrenf01ee602012-04-09 13:40:24 -0600183 min_stride = 4;
184 break;
Stephen Warren45f5ff82012-04-04 15:48:31 -0600185#ifdef CONFIG_64BIT
186 case 64:
Stephen Warrenf01ee602012-04-09 13:40:24 -0600187 min_stride = 8;
188 break;
Stephen Warren45f5ff82012-04-04 15:48:31 -0600189#endif
190 break;
191 default:
192 return ERR_PTR(-EINVAL);
193 }
194
Stephen Warrenf01ee602012-04-09 13:40:24 -0600195 if (config->reg_stride < min_stride)
196 return ERR_PTR(-EINVAL);
197
Stephen Warren6a552442012-05-24 10:47:27 -0600198 switch (config->reg_format_endian) {
199 case REGMAP_ENDIAN_DEFAULT:
200 case REGMAP_ENDIAN_NATIVE:
201 break;
202 default:
203 return ERR_PTR(-EINVAL);
204 }
205
Dimitris Papastamos46335112012-07-18 14:17:23 +0100206 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600207 if (!ctx)
208 return ERR_PTR(-ENOMEM);
209
210 ctx->regs = regs;
211 ctx->val_bytes = config->val_bits / 8;
Stephen Warren6b8e0902013-11-25 15:12:47 -0700212 ctx->clk = ERR_PTR(-ENODEV);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600213
Philipp Zabel878ec672013-02-14 17:39:08 +0100214 if (clk_id == NULL)
215 return ctx;
216
217 ctx->clk = clk_get(dev, clk_id);
218 if (IS_ERR(ctx->clk)) {
219 ret = PTR_ERR(ctx->clk);
220 goto err_free;
221 }
222
223 ret = clk_prepare(ctx->clk);
224 if (ret < 0) {
225 clk_put(ctx->clk);
226 goto err_free;
227 }
228
Stephen Warren45f5ff82012-04-04 15:48:31 -0600229 return ctx;
Philipp Zabel878ec672013-02-14 17:39:08 +0100230
231err_free:
232 kfree(ctx);
233
234 return ERR_PTR(ret);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600235}
236
237/**
Philipp Zabel878ec672013-02-14 17:39:08 +0100238 * regmap_init_mmio_clk(): Initialise register map with register clock
Stephen Warren45f5ff82012-04-04 15:48:31 -0600239 *
240 * @dev: Device that will be interacted with
Philipp Zabel878ec672013-02-14 17:39:08 +0100241 * @clk_id: register clock consumer ID
Stephen Warren45f5ff82012-04-04 15:48:31 -0600242 * @regs: Pointer to memory-mapped IO region
243 * @config: Configuration for register map
244 *
245 * The return value will be an ERR_PTR() on error or a valid pointer to
246 * a struct regmap.
247 */
Philipp Zabel878ec672013-02-14 17:39:08 +0100248struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
249 void __iomem *regs,
250 const struct regmap_config *config)
Stephen Warren45f5ff82012-04-04 15:48:31 -0600251{
252 struct regmap_mmio_context *ctx;
253
Philipp Zabel878ec672013-02-14 17:39:08 +0100254 ctx = regmap_mmio_gen_context(dev, clk_id, regs, config);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600255 if (IS_ERR(ctx))
256 return ERR_CAST(ctx);
257
258 return regmap_init(dev, &regmap_mmio, ctx, config);
259}
Philipp Zabel878ec672013-02-14 17:39:08 +0100260EXPORT_SYMBOL_GPL(regmap_init_mmio_clk);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600261
262/**
Philipp Zabel878ec672013-02-14 17:39:08 +0100263 * devm_regmap_init_mmio_clk(): Initialise managed register map with clock
Stephen Warren45f5ff82012-04-04 15:48:31 -0600264 *
265 * @dev: Device that will be interacted with
Philipp Zabel878ec672013-02-14 17:39:08 +0100266 * @clk_id: register clock consumer ID
Stephen Warren45f5ff82012-04-04 15:48:31 -0600267 * @regs: Pointer to memory-mapped IO region
268 * @config: Configuration for register map
269 *
270 * The return value will be an ERR_PTR() on error or a valid pointer
271 * to a struct regmap. The regmap will be automatically freed by the
272 * device management code.
273 */
Philipp Zabel878ec672013-02-14 17:39:08 +0100274struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
275 void __iomem *regs,
276 const struct regmap_config *config)
Stephen Warren45f5ff82012-04-04 15:48:31 -0600277{
278 struct regmap_mmio_context *ctx;
279
Philipp Zabel878ec672013-02-14 17:39:08 +0100280 ctx = regmap_mmio_gen_context(dev, clk_id, regs, config);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600281 if (IS_ERR(ctx))
282 return ERR_CAST(ctx);
283
284 return devm_regmap_init(dev, &regmap_mmio, ctx, config);
285}
Philipp Zabel878ec672013-02-14 17:39:08 +0100286EXPORT_SYMBOL_GPL(devm_regmap_init_mmio_clk);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600287
288MODULE_LICENSE("GPL v2");