]> git.karo-electronics.de Git - karo-tx-linux.git/blob - sound/soc/sh/rcar/gen.c
Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/cooloney...
[karo-tx-linux.git] / sound / soc / sh / rcar / gen.c
1 /*
2  * Renesas R-Car Gen1 SRU/SSI support
3  *
4  * Copyright (C) 2013 Renesas Solutions Corp.
5  * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11 #include "rsnd.h"
12
13 struct rsnd_gen {
14         void __iomem *base[RSND_BASE_MAX];
15
16         struct rsnd_gen_ops *ops;
17
18         struct regmap *regmap;
19         struct regmap_field *regs[RSND_REG_MAX];
20 };
21
22 #define rsnd_priv_to_gen(p)     ((struct rsnd_gen *)(p)->gen)
23
24 #define RSND_REG_SET(gen, id, reg_id, offset, _id_offset, _id_size)     \
25         [id] = {                                                        \
26                 .reg = (unsigned int)gen->base[reg_id] + offset,        \
27                 .lsb = 0,                                               \
28                 .msb = 31,                                              \
29                 .id_size = _id_size,                                    \
30                 .id_offset = _id_offset,                                \
31         }
32
33 /*
34  *              basic function
35  */
36 static int rsnd_regmap_write32(void *context, const void *_data, size_t count)
37 {
38         struct rsnd_priv *priv = context;
39         struct device *dev = rsnd_priv_to_dev(priv);
40         u32 *data = (u32 *)_data;
41         u32 val = data[1];
42         void __iomem *reg = (void *)data[0];
43
44         iowrite32(val, reg);
45
46         dev_dbg(dev, "w %p : %08x\n", reg, val);
47
48         return 0;
49 }
50
51 static int rsnd_regmap_read32(void *context,
52                               const void *_data, size_t reg_size,
53                               void *_val, size_t val_size)
54 {
55         struct rsnd_priv *priv = context;
56         struct device *dev = rsnd_priv_to_dev(priv);
57         u32 *data = (u32 *)_data;
58         u32 *val = (u32 *)_val;
59         void __iomem *reg = (void *)data[0];
60
61         *val = ioread32(reg);
62
63         dev_dbg(dev, "r %p : %08x\n", reg, *val);
64
65         return 0;
66 }
67
68 static struct regmap_bus rsnd_regmap_bus = {
69         .write                          = rsnd_regmap_write32,
70         .read                           = rsnd_regmap_read32,
71         .reg_format_endian_default      = REGMAP_ENDIAN_NATIVE,
72         .val_format_endian_default      = REGMAP_ENDIAN_NATIVE,
73 };
74
75 static int rsnd_is_accessible_reg(struct rsnd_priv *priv,
76                                   struct rsnd_gen *gen, enum rsnd_reg reg)
77 {
78         if (!gen->regs[reg]) {
79                 struct device *dev = rsnd_priv_to_dev(priv);
80
81                 dev_err(dev, "unsupported register access %x\n", reg);
82                 return 0;
83         }
84
85         return 1;
86 }
87
88 u32 rsnd_read(struct rsnd_priv *priv,
89               struct rsnd_mod *mod, enum rsnd_reg reg)
90 {
91         struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
92         u32 val;
93
94         if (!rsnd_is_accessible_reg(priv, gen, reg))
95                 return 0;
96
97         regmap_fields_read(gen->regs[reg], rsnd_mod_id(mod), &val);
98
99         return val;
100 }
101
102 void rsnd_write(struct rsnd_priv *priv,
103                 struct rsnd_mod *mod,
104                 enum rsnd_reg reg, u32 data)
105 {
106         struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
107
108         if (!rsnd_is_accessible_reg(priv, gen, reg))
109                 return;
110
111         regmap_fields_write(gen->regs[reg], rsnd_mod_id(mod), data);
112 }
113
114 void rsnd_bset(struct rsnd_priv *priv, struct rsnd_mod *mod,
115                enum rsnd_reg reg, u32 mask, u32 data)
116 {
117         struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
118
119         if (!rsnd_is_accessible_reg(priv, gen, reg))
120                 return;
121
122         regmap_fields_update_bits(gen->regs[reg], rsnd_mod_id(mod),
123                                   mask, data);
124 }
125
126 static int rsnd_gen_regmap_init(struct rsnd_priv *priv,
127                                 struct rsnd_gen  *gen,
128                                 struct reg_field *regf)
129 {
130         int i;
131         struct device *dev = rsnd_priv_to_dev(priv);
132         struct regmap_config regc;
133
134         memset(&regc, 0, sizeof(regc));
135         regc.reg_bits = 32;
136         regc.val_bits = 32;
137
138         gen->regmap = devm_regmap_init(dev, &rsnd_regmap_bus, priv, &regc);
139         if (IS_ERR(gen->regmap)) {
140                 dev_err(dev, "regmap error %ld\n", PTR_ERR(gen->regmap));
141                 return PTR_ERR(gen->regmap);
142         }
143
144         for (i = 0; i < RSND_REG_MAX; i++) {
145                 gen->regs[i] = NULL;
146                 if (!regf[i].reg)
147                         continue;
148
149                 gen->regs[i] = devm_regmap_field_alloc(dev, gen->regmap, regf[i]);
150                 if (IS_ERR(gen->regs[i]))
151                         return PTR_ERR(gen->regs[i]);
152
153         }
154
155         return 0;
156 }
157
158 /*
159  *              Gen2
160  */
161
162 /* single address mapping */
163 #define RSND_GEN2_S_REG(gen, reg, id, offset)                           \
164         RSND_REG_SET(gen, RSND_REG_##id, RSND_GEN2_##reg, offset, 0, 10)
165
166 /* multi address mapping */
167 #define RSND_GEN2_M_REG(gen, reg, id, offset, _id_offset)               \
168         RSND_REG_SET(gen, RSND_REG_##id, RSND_GEN2_##reg, offset, _id_offset, 10)
169
170 static int rsnd_gen2_regmap_init(struct rsnd_priv *priv, struct rsnd_gen *gen)
171 {
172         struct reg_field regf[RSND_REG_MAX] = {
173                 RSND_GEN2_S_REG(gen, SSIU,      SSI_MODE0,      0x800),
174                 RSND_GEN2_S_REG(gen, SSIU,      SSI_MODE1,      0x804),
175                 /* FIXME: it needs SSI_MODE2/3 in the future */
176                 RSND_GEN2_M_REG(gen, SSIU,      SSI_BUSIF_MODE, 0x0,    0x80),
177                 RSND_GEN2_M_REG(gen, SSIU,      SSI_BUSIF_ADINR,0x4,    0x80),
178                 RSND_GEN2_M_REG(gen, SSIU,      SSI_CTRL,       0x10,   0x80),
179                 RSND_GEN2_M_REG(gen, SSIU,      INT_ENABLE,     0x18,   0x80),
180
181                 RSND_GEN2_M_REG(gen, SCU,       SRC_BUSIF_MODE, 0x0,    0x20),
182                 RSND_GEN2_M_REG(gen, SCU,       SRC_ROUTE_MODE0,0xc,    0x20),
183                 RSND_GEN2_M_REG(gen, SCU,       SRC_CTRL,       0x10,   0x20),
184                 RSND_GEN2_M_REG(gen, SCU,       SRC_SWRSR,      0x200,  0x40),
185                 RSND_GEN2_M_REG(gen, SCU,       SRC_SRCIR,      0x204,  0x40),
186                 RSND_GEN2_M_REG(gen, SCU,       SRC_ADINR,      0x214,  0x40),
187                 RSND_GEN2_M_REG(gen, SCU,       SRC_IFSCR,      0x21c,  0x40),
188                 RSND_GEN2_M_REG(gen, SCU,       SRC_IFSVR,      0x220,  0x40),
189                 RSND_GEN2_M_REG(gen, SCU,       SRC_SRCCR,      0x224,  0x40),
190                 RSND_GEN2_M_REG(gen, SCU,       SRC_BSDSR,      0x22c,  0x40),
191                 RSND_GEN2_M_REG(gen, SCU,       SRC_BSISR,      0x238,  0x40),
192
193                 RSND_GEN2_S_REG(gen, ADG,       BRRA,           0x00),
194                 RSND_GEN2_S_REG(gen, ADG,       BRRB,           0x04),
195                 RSND_GEN2_S_REG(gen, ADG,       SSICKR,         0x08),
196                 RSND_GEN2_S_REG(gen, ADG,       AUDIO_CLK_SEL0, 0x0c),
197                 RSND_GEN2_S_REG(gen, ADG,       AUDIO_CLK_SEL1, 0x10),
198                 RSND_GEN2_S_REG(gen, ADG,       AUDIO_CLK_SEL2, 0x14),
199                 RSND_GEN2_S_REG(gen, ADG,       DIV_EN,         0x30),
200                 RSND_GEN2_S_REG(gen, ADG,       SRCIN_TIMSEL0,  0x34),
201                 RSND_GEN2_S_REG(gen, ADG,       SRCIN_TIMSEL1,  0x38),
202                 RSND_GEN2_S_REG(gen, ADG,       SRCIN_TIMSEL2,  0x3c),
203                 RSND_GEN2_S_REG(gen, ADG,       SRCIN_TIMSEL3,  0x40),
204                 RSND_GEN2_S_REG(gen, ADG,       SRCIN_TIMSEL4,  0x44),
205                 RSND_GEN2_S_REG(gen, ADG,       SRCOUT_TIMSEL0, 0x48),
206                 RSND_GEN2_S_REG(gen, ADG,       SRCOUT_TIMSEL1, 0x4c),
207                 RSND_GEN2_S_REG(gen, ADG,       SRCOUT_TIMSEL2, 0x50),
208                 RSND_GEN2_S_REG(gen, ADG,       SRCOUT_TIMSEL3, 0x54),
209                 RSND_GEN2_S_REG(gen, ADG,       SRCOUT_TIMSEL4, 0x58),
210
211                 RSND_GEN2_M_REG(gen, SSI,       SSICR,          0x00,   0x40),
212                 RSND_GEN2_M_REG(gen, SSI,       SSISR,          0x04,   0x40),
213                 RSND_GEN2_M_REG(gen, SSI,       SSITDR,         0x08,   0x40),
214                 RSND_GEN2_M_REG(gen, SSI,       SSIRDR,         0x0c,   0x40),
215                 RSND_GEN2_M_REG(gen, SSI,       SSIWSR,         0x20,   0x40),
216         };
217
218         return rsnd_gen_regmap_init(priv, gen, regf);
219 }
220
221 static int rsnd_gen2_probe(struct platform_device *pdev,
222                            struct rsnd_priv *priv)
223 {
224         struct device *dev = rsnd_priv_to_dev(priv);
225         struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
226         struct resource *scu_res;
227         struct resource *adg_res;
228         struct resource *ssiu_res;
229         struct resource *ssi_res;
230         int ret;
231
232         /*
233          * map address
234          */
235         scu_res  = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_SCU);
236         adg_res  = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_ADG);
237         ssiu_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_SSIU);
238         ssi_res  = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_SSI);
239
240         gen->base[RSND_GEN2_SCU]  = devm_ioremap_resource(dev, scu_res);
241         gen->base[RSND_GEN2_ADG]  = devm_ioremap_resource(dev, adg_res);
242         gen->base[RSND_GEN2_SSIU] = devm_ioremap_resource(dev, ssiu_res);
243         gen->base[RSND_GEN2_SSI]  = devm_ioremap_resource(dev, ssi_res);
244         if (IS_ERR(gen->base[RSND_GEN2_SCU])  ||
245             IS_ERR(gen->base[RSND_GEN2_ADG])  ||
246             IS_ERR(gen->base[RSND_GEN2_SSIU]) ||
247             IS_ERR(gen->base[RSND_GEN2_SSI]))
248                 return -ENODEV;
249
250         ret = rsnd_gen2_regmap_init(priv, gen);
251         if (ret < 0)
252                 return ret;
253
254         dev_dbg(dev, "Gen2 device probed\n");
255         dev_dbg(dev, "SCU  : %08x => %p\n", scu_res->start,
256                 gen->base[RSND_GEN2_SCU]);
257         dev_dbg(dev, "ADG  : %08x => %p\n", adg_res->start,
258                 gen->base[RSND_GEN2_ADG]);
259         dev_dbg(dev, "SSIU : %08x => %p\n", ssiu_res->start,
260                 gen->base[RSND_GEN2_SSIU]);
261         dev_dbg(dev, "SSI  : %08x => %p\n", ssi_res->start,
262                 gen->base[RSND_GEN2_SSI]);
263
264         return 0;
265 }
266
267 /*
268  *              Gen1
269  */
270
271 /* single address mapping */
272 #define RSND_GEN1_S_REG(gen, reg, id, offset)   \
273         RSND_REG_SET(gen, RSND_REG_##id, RSND_GEN1_##reg, offset, 0, 9)
274
275 /* multi address mapping */
276 #define RSND_GEN1_M_REG(gen, reg, id, offset, _id_offset)       \
277         RSND_REG_SET(gen, RSND_REG_##id, RSND_GEN1_##reg, offset, _id_offset, 9)
278
279 static int rsnd_gen1_regmap_init(struct rsnd_priv *priv, struct rsnd_gen *gen)
280 {
281         struct reg_field regf[RSND_REG_MAX] = {
282                 RSND_GEN1_S_REG(gen, SRU,       SRC_ROUTE_SEL,  0x00),
283                 RSND_GEN1_S_REG(gen, SRU,       SRC_TMG_SEL0,   0x08),
284                 RSND_GEN1_S_REG(gen, SRU,       SRC_TMG_SEL1,   0x0c),
285                 RSND_GEN1_S_REG(gen, SRU,       SRC_TMG_SEL2,   0x10),
286                 RSND_GEN1_S_REG(gen, SRU,       SRC_ROUTE_CTRL, 0xc0),
287                 RSND_GEN1_S_REG(gen, SRU,       SSI_MODE0,      0xD0),
288                 RSND_GEN1_S_REG(gen, SRU,       SSI_MODE1,      0xD4),
289                 RSND_GEN1_M_REG(gen, SRU,       SRC_BUSIF_MODE, 0x20,   0x4),
290                 RSND_GEN1_M_REG(gen, SRU,       SRC_ROUTE_MODE0,0x50,   0x8),
291                 RSND_GEN1_M_REG(gen, SRU,       SRC_SWRSR,      0x200,  0x40),
292                 RSND_GEN1_M_REG(gen, SRU,       SRC_SRCIR,      0x204,  0x40),
293                 RSND_GEN1_M_REG(gen, SRU,       SRC_ADINR,      0x214,  0x40),
294                 RSND_GEN1_M_REG(gen, SRU,       SRC_IFSCR,      0x21c,  0x40),
295                 RSND_GEN1_M_REG(gen, SRU,       SRC_IFSVR,      0x220,  0x40),
296                 RSND_GEN1_M_REG(gen, SRU,       SRC_SRCCR,      0x224,  0x40),
297                 RSND_GEN1_M_REG(gen, SRU,       SRC_MNFSR,      0x228,  0x40),
298
299                 RSND_GEN1_S_REG(gen, ADG,       BRRA,           0x00),
300                 RSND_GEN1_S_REG(gen, ADG,       BRRB,           0x04),
301                 RSND_GEN1_S_REG(gen, ADG,       SSICKR,         0x08),
302                 RSND_GEN1_S_REG(gen, ADG,       AUDIO_CLK_SEL0, 0x0c),
303                 RSND_GEN1_S_REG(gen, ADG,       AUDIO_CLK_SEL1, 0x10),
304                 RSND_GEN1_S_REG(gen, ADG,       AUDIO_CLK_SEL3, 0x18),
305                 RSND_GEN1_S_REG(gen, ADG,       AUDIO_CLK_SEL4, 0x1c),
306                 RSND_GEN1_S_REG(gen, ADG,       AUDIO_CLK_SEL5, 0x20),
307
308                 RSND_GEN1_M_REG(gen, SSI,       SSICR,          0x00,   0x40),
309                 RSND_GEN1_M_REG(gen, SSI,       SSISR,          0x04,   0x40),
310                 RSND_GEN1_M_REG(gen, SSI,       SSITDR,         0x08,   0x40),
311                 RSND_GEN1_M_REG(gen, SSI,       SSIRDR,         0x0c,   0x40),
312                 RSND_GEN1_M_REG(gen, SSI,       SSIWSR,         0x20,   0x40),
313         };
314
315         return rsnd_gen_regmap_init(priv, gen, regf);
316 }
317
318 static int rsnd_gen1_probe(struct platform_device *pdev,
319                            struct rsnd_priv *priv)
320 {
321         struct device *dev = rsnd_priv_to_dev(priv);
322         struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
323         struct resource *sru_res;
324         struct resource *adg_res;
325         struct resource *ssi_res;
326         int ret;
327
328         /*
329          * map address
330          */
331         sru_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_SRU);
332         adg_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_ADG);
333         ssi_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_SSI);
334
335         gen->base[RSND_GEN1_SRU] = devm_ioremap_resource(dev, sru_res);
336         gen->base[RSND_GEN1_ADG] = devm_ioremap_resource(dev, adg_res);
337         gen->base[RSND_GEN1_SSI] = devm_ioremap_resource(dev, ssi_res);
338         if (IS_ERR(gen->base[RSND_GEN1_SRU]) ||
339             IS_ERR(gen->base[RSND_GEN1_ADG]) ||
340             IS_ERR(gen->base[RSND_GEN1_SSI]))
341                 return -ENODEV;
342
343         ret = rsnd_gen1_regmap_init(priv, gen);
344         if (ret < 0)
345                 return ret;
346
347         dev_dbg(dev, "Gen1 device probed\n");
348         dev_dbg(dev, "SRU : %08x => %p\n",      sru_res->start,
349                                                 gen->base[RSND_GEN1_SRU]);
350         dev_dbg(dev, "ADG : %08x => %p\n",      adg_res->start,
351                                                 gen->base[RSND_GEN1_ADG]);
352         dev_dbg(dev, "SSI : %08x => %p\n",      ssi_res->start,
353                                                 gen->base[RSND_GEN1_SSI]);
354
355         return 0;
356
357 }
358
359 /*
360  *              Gen
361  */
362 static void rsnd_of_parse_gen(struct platform_device *pdev,
363                               const struct rsnd_of_data *of_data,
364                               struct rsnd_priv *priv)
365 {
366         struct rcar_snd_info *info = priv->info;
367
368         if (!of_data)
369                 return;
370
371         info->flags = of_data->flags;
372 }
373
374 int rsnd_gen_probe(struct platform_device *pdev,
375                    const struct rsnd_of_data *of_data,
376                    struct rsnd_priv *priv)
377 {
378         struct device *dev = rsnd_priv_to_dev(priv);
379         struct rsnd_gen *gen;
380         int ret;
381
382         rsnd_of_parse_gen(pdev, of_data, priv);
383
384         gen = devm_kzalloc(dev, sizeof(*gen), GFP_KERNEL);
385         if (!gen) {
386                 dev_err(dev, "GEN allocate failed\n");
387                 return -ENOMEM;
388         }
389
390         priv->gen = gen;
391
392         ret = -ENODEV;
393         if (rsnd_is_gen1(priv))
394                 ret = rsnd_gen1_probe(pdev, priv);
395         else if (rsnd_is_gen2(priv))
396                 ret = rsnd_gen2_probe(pdev, priv);
397
398         if (ret < 0)
399                 dev_err(dev, "unknown generation R-Car sound device\n");
400
401         return ret;
402 }