Merge tag 'regmap-3.9' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap
[~shefty/rdma-dev.git] / drivers / base / regmap / regmap-mmio.c
1 /*
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
19 #include <linux/clk.h>
20 #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
27 struct regmap_mmio_context {
28         void __iomem *regs;
29         unsigned val_bytes;
30         struct clk *clk;
31 };
32
33 static 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;
39         int ret;
40
41         BUG_ON(reg_size != 4);
42
43         if (ctx->clk) {
44                 ret = clk_enable(ctx->clk);
45                 if (ret < 0)
46                         return ret;
47         }
48
49         offset = *(u32 *)reg;
50
51         while (val_size) {
52                 switch (ctx->val_bytes) {
53                 case 1:
54                         writeb(*(u8 *)val, ctx->regs + offset);
55                         break;
56                 case 2:
57                         writew(*(u16 *)val, ctx->regs + offset);
58                         break;
59                 case 4:
60                         writel(*(u32 *)val, ctx->regs + offset);
61                         break;
62 #ifdef CONFIG_64BIT
63                 case 8:
64                         writeq(*(u64 *)val, ctx->regs + offset);
65                         break;
66 #endif
67                 default:
68                         /* Should be caught by regmap_mmio_check_config */
69                         BUG();
70                 }
71                 val_size -= ctx->val_bytes;
72                 val += ctx->val_bytes;
73                 offset += ctx->val_bytes;
74         }
75
76         if (ctx->clk)
77                 clk_disable(ctx->clk);
78
79         return 0;
80 }
81
82 static int regmap_mmio_write(void *context, const void *data, size_t count)
83 {
84         BUG_ON(count < 4);
85
86         return regmap_mmio_gather_write(context, data, 4, data + 4, count - 4);
87 }
88
89 static 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;
95         int ret;
96
97         BUG_ON(reg_size != 4);
98
99         if (ctx->clk) {
100                 ret = clk_enable(ctx->clk);
101                 if (ret < 0)
102                         return ret;
103         }
104
105         offset = *(u32 *)reg;
106
107         while (val_size) {
108                 switch (ctx->val_bytes) {
109                 case 1:
110                         *(u8 *)val = readb(ctx->regs + offset);
111                         break;
112                 case 2:
113                         *(u16 *)val = readw(ctx->regs + offset);
114                         break;
115                 case 4:
116                         *(u32 *)val = readl(ctx->regs + offset);
117                         break;
118 #ifdef CONFIG_64BIT
119                 case 8:
120                         *(u64 *)val = readq(ctx->regs + offset);
121                         break;
122 #endif
123                 default:
124                         /* Should be caught by regmap_mmio_check_config */
125                         BUG();
126                 }
127                 val_size -= ctx->val_bytes;
128                 val += ctx->val_bytes;
129                 offset += ctx->val_bytes;
130         }
131
132         if (ctx->clk)
133                 clk_disable(ctx->clk);
134
135         return 0;
136 }
137
138 static void regmap_mmio_free_context(void *context)
139 {
140         struct regmap_mmio_context *ctx = context;
141
142         if (ctx->clk) {
143                 clk_unprepare(ctx->clk);
144                 clk_put(ctx->clk);
145         }
146         kfree(context);
147 }
148
149 static 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,
155         .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
156         .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
157 };
158
159 static struct regmap_mmio_context *regmap_mmio_gen_context(struct device *dev,
160                                         const char *clk_id,
161                                         void __iomem *regs,
162                                         const struct regmap_config *config)
163 {
164         struct regmap_mmio_context *ctx;
165         int min_stride;
166         int ret;
167
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:
176                 /* The core treats 0 as 1 */
177                 min_stride = 0;
178                 break;
179         case 16:
180                 min_stride = 2;
181                 break;
182         case 32:
183                 min_stride = 4;
184                 break;
185 #ifdef CONFIG_64BIT
186         case 64:
187                 min_stride = 8;
188                 break;
189 #endif
190                 break;
191         default:
192                 return ERR_PTR(-EINVAL);
193         }
194
195         if (config->reg_stride < min_stride)
196                 return ERR_PTR(-EINVAL);
197
198         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
206         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
207         if (!ctx)
208                 return ERR_PTR(-ENOMEM);
209
210         ctx->regs = regs;
211         ctx->val_bytes = config->val_bits / 8;
212
213         if (clk_id == NULL)
214                 return ctx;
215
216         ctx->clk = clk_get(dev, clk_id);
217         if (IS_ERR(ctx->clk)) {
218                 ret = PTR_ERR(ctx->clk);
219                 goto err_free;
220         }
221
222         ret = clk_prepare(ctx->clk);
223         if (ret < 0) {
224                 clk_put(ctx->clk);
225                 goto err_free;
226         }
227
228         return ctx;
229
230 err_free:
231         kfree(ctx);
232
233         return ERR_PTR(ret);
234 }
235
236 /**
237  * regmap_init_mmio_clk(): Initialise register map with register clock
238  *
239  * @dev: Device that will be interacted with
240  * @clk_id: register clock consumer ID
241  * @regs: Pointer to memory-mapped IO region
242  * @config: Configuration for register map
243  *
244  * The return value will be an ERR_PTR() on error or a valid pointer to
245  * a struct regmap.
246  */
247 struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
248                                     void __iomem *regs,
249                                     const struct regmap_config *config)
250 {
251         struct regmap_mmio_context *ctx;
252
253         ctx = regmap_mmio_gen_context(dev, clk_id, regs, config);
254         if (IS_ERR(ctx))
255                 return ERR_CAST(ctx);
256
257         return regmap_init(dev, &regmap_mmio, ctx, config);
258 }
259 EXPORT_SYMBOL_GPL(regmap_init_mmio_clk);
260
261 /**
262  * devm_regmap_init_mmio_clk(): Initialise managed register map with clock
263  *
264  * @dev: Device that will be interacted with
265  * @clk_id: register clock consumer ID
266  * @regs: Pointer to memory-mapped IO region
267  * @config: Configuration for register map
268  *
269  * The return value will be an ERR_PTR() on error or a valid pointer
270  * to a struct regmap.  The regmap will be automatically freed by the
271  * device management code.
272  */
273 struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
274                                          void __iomem *regs,
275                                          const struct regmap_config *config)
276 {
277         struct regmap_mmio_context *ctx;
278
279         ctx = regmap_mmio_gen_context(dev, clk_id, regs, config);
280         if (IS_ERR(ctx))
281                 return ERR_CAST(ctx);
282
283         return devm_regmap_init(dev, &regmap_mmio, ctx, config);
284 }
285 EXPORT_SYMBOL_GPL(devm_regmap_init_mmio_clk);
286
287 MODULE_LICENSE("GPL v2");