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 int rsnd_gen_path_init(struct rsnd_priv *priv,
 159                        struct rsnd_dai *rdai,
 160                        struct rsnd_dai_stream *io)
 161 {
 162         struct rsnd_mod *mod;
 163         int ret;
 164         int id;
 165
 166         /*
 167          * Gen1 is created by SRU/SSI, and this SRU is base module of
 168          * Gen2's SCU/SSIU/SSI. (Gen2 SCU/SSIU came from SRU)
 169          *
 170          * Easy image is..
 171          *      Gen1 SRU = Gen2 SCU + SSIU + etc
 172          *
 173          * Gen2 SCU path is very flexible, but, Gen1 SRU (SCU parts) is
 174          * using fixed path.
 175          *
 176          * Then, SSI id = SCU id here
 177          */
 178
 179         /* get SSI's ID */
 180         mod = rsnd_ssi_mod_get_frm_dai(priv,
 181                                        rsnd_dai_id(priv, rdai),
 182                                        rsnd_dai_is_play(rdai, io));
 183         id = rsnd_mod_id(mod);
 184
 185         /* SCU */
 186         mod = rsnd_scu_mod_get(priv, id);
 187         ret = rsnd_dai_connect(rdai, mod, io);
 188         if (ret < 0)
 189                 return ret;
 190
 191         /* SSI */
 192         mod = rsnd_ssi_mod_get(priv, id);
 193         ret = rsnd_dai_connect(rdai, mod, io);
 194
 195         return ret;
 196 }
 197
 198 int rsnd_gen_path_exit(struct rsnd_priv *priv,
 199                        struct rsnd_dai *rdai,
 200                        struct rsnd_dai_stream *io)
 201 {
 202         struct rsnd_mod *mod, *n;
 203         int ret = 0;
 204
 205         /*
 206          * remove all mod from rdai
 207          */
 208         for_each_rsnd_mod(mod, n, io)
 209                 ret |= rsnd_dai_disconnect(mod);
 210
 211         return ret;
 212 }
 213
 214 /*
 215  *              Gen2
 216  */
 217
 218 /* single address mapping */
 219 #define RSND_GEN2_S_REG(gen, reg, id, offset)                           \
 220         RSND_REG_SET(gen, RSND_REG_##id, RSND_GEN2_##reg, offset, 0, 10)
 221
 222 /* multi address mapping */
 223 #define RSND_GEN2_M_REG(gen, reg, id, offset, _id_offset)               \
 224         RSND_REG_SET(gen, RSND_REG_##id, RSND_GEN2_##reg, offset, _id_offset, 10)
 225
 226 static int rsnd_gen2_regmap_init(struct rsnd_priv *priv, struct rsnd_gen *gen)
 227 {
 228         struct reg_field regf[RSND_REG_MAX] = {
 229                 RSND_GEN2_S_REG(gen, SSIU,      SSI_MODE0,      0x800),
 230                 RSND_GEN2_S_REG(gen, SSIU,      SSI_MODE1,      0x804),
 231                 /* FIXME: it needs SSI_MODE2/3 in the future */
 232                 RSND_GEN2_S_REG(gen, SSIU,      SSI_CONTROL,    0x810),
 233                 RSND_GEN2_M_REG(gen, SSIU,      SSI_BUSIF_MODE, 0x0,    0x80),
 234                 RSND_GEN2_M_REG(gen, SSIU,      SSI_BUSIF_ADINR,0x4,    0x80),
 235                 RSND_GEN2_M_REG(gen, SSIU,      SSI_CTRL,       0x10,   0x80),
 236                 RSND_GEN2_M_REG(gen, SSIU,      INT_ENABLE,     0x18,   0x80),
 237
 238                 RSND_GEN2_M_REG(gen, SCU,       SRC_BUSIF_MODE, 0x0,    0x20),
 239                 RSND_GEN2_M_REG(gen, SCU,       SRC_ROUTE_MODE0,0xc,    0x20),
 240                 RSND_GEN2_M_REG(gen, SCU,       SRC_CTRL,       0x10,   0x20),
 241                 RSND_GEN2_M_REG(gen, SCU,       SRC_SWRSR,      0x200,  0x40),
 242                 RSND_GEN2_M_REG(gen, SCU,       SRC_SRCIR,      0x204,  0x40),
 243                 RSND_GEN2_M_REG(gen, SCU,       SRC_ADINR,      0x214,  0x40),
 244                 RSND_GEN2_M_REG(gen, SCU,       SRC_IFSCR,      0x21c,  0x40),
 245                 RSND_GEN2_M_REG(gen, SCU,       SRC_IFSVR,      0x220,  0x40),
 246                 RSND_GEN2_M_REG(gen, SCU,       SRC_SRCCR,      0x224,  0x40),
 247                 RSND_GEN2_M_REG(gen, SCU,       SRC_BSDSR,      0x22c,  0x40),
 248                 RSND_GEN2_M_REG(gen, SCU,       SRC_BSISR,      0x238,  0x40),
 249
 250                 RSND_GEN2_S_REG(gen, ADG,       BRRA,           0x00),
 251                 RSND_GEN2_S_REG(gen, ADG,       BRRB,           0x04),
 252                 RSND_GEN2_S_REG(gen, ADG,       SSICKR,         0x08),
 253                 RSND_GEN2_S_REG(gen, ADG,       AUDIO_CLK_SEL0, 0x0c),
 254                 RSND_GEN2_S_REG(gen, ADG,       AUDIO_CLK_SEL1, 0x10),
 255                 RSND_GEN2_S_REG(gen, ADG,       AUDIO_CLK_SEL2, 0x14),
 256                 RSND_GEN2_S_REG(gen, ADG,       SRCIN_TIMSEL0,  0x34),
 257                 RSND_GEN2_S_REG(gen, ADG,       SRCIN_TIMSEL1,  0x38),
 258                 RSND_GEN2_S_REG(gen, ADG,       SRCIN_TIMSEL2,  0x3c),
 259                 RSND_GEN2_S_REG(gen, ADG,       SRCIN_TIMSEL3,  0x40),
 260                 RSND_GEN2_S_REG(gen, ADG,       SRCIN_TIMSEL4,  0x44),
 261                 RSND_GEN2_S_REG(gen, ADG,       SRCOUT_TIMSEL0, 0x48),
 262                 RSND_GEN2_S_REG(gen, ADG,       SRCOUT_TIMSEL1, 0x4c),
 263                 RSND_GEN2_S_REG(gen, ADG,       SRCOUT_TIMSEL2, 0x50),
 264                 RSND_GEN2_S_REG(gen, ADG,       SRCOUT_TIMSEL3, 0x54),
 265                 RSND_GEN2_S_REG(gen, ADG,       SRCOUT_TIMSEL4, 0x58),
 266
 267                 RSND_GEN2_M_REG(gen, SSI,       SSICR,          0x00,   0x40),
 268                 RSND_GEN2_M_REG(gen, SSI,       SSISR,          0x04,   0x40),
 269                 RSND_GEN2_M_REG(gen, SSI,       SSITDR,         0x08,   0x40),
 270                 RSND_GEN2_M_REG(gen, SSI,       SSIRDR,         0x0c,   0x40),
 271                 RSND_GEN2_M_REG(gen, SSI,       SSIWSR,         0x20,   0x40),
 272         };
 273
 274         return rsnd_gen_regmap_init(priv, gen, regf);
 275 }
 276
 277 static int rsnd_gen2_probe(struct platform_device *pdev,
 278                            struct rcar_snd_info *info,
 279                            struct rsnd_priv *priv)
 280 {
 281         struct device *dev = rsnd_priv_to_dev(priv);
 282         struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
 283         struct resource *scu_res;
 284         struct resource *adg_res;
 285         struct resource *ssiu_res;
 286         struct resource *ssi_res;
 287         int ret;
 288
 289         /*
 290          * map address
 291          */
 292         scu_res  = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_SCU);
 293         adg_res  = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_ADG);
 294         ssiu_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_SSIU);
 295         ssi_res  = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_SSI);
 296
 297         gen->base[RSND_GEN2_SCU]  = devm_ioremap_resource(dev, scu_res);
 298         gen->base[RSND_GEN2_ADG]  = devm_ioremap_resource(dev, adg_res);
 299         gen->base[RSND_GEN2_SSIU] = devm_ioremap_resource(dev, ssiu_res);
 300         gen->base[RSND_GEN2_SSI]  = devm_ioremap_resource(dev, ssi_res);
 301         if (IS_ERR(gen->base[RSND_GEN2_SCU])  ||
 302             IS_ERR(gen->base[RSND_GEN2_ADG])  ||
 303             IS_ERR(gen->base[RSND_GEN2_SSIU]) ||
 304             IS_ERR(gen->base[RSND_GEN2_SSI]))
 305                 return -ENODEV;
 306
 307         ret = rsnd_gen2_regmap_init(priv, gen);
 308         if (ret < 0)
 309                 return ret;
 310
 311         dev_dbg(dev, "Gen2 device probed\n");
 312         dev_dbg(dev, "SCU  : %08x => %p\n", scu_res->start,
 313                 gen->base[RSND_GEN2_SCU]);
 314         dev_dbg(dev, "ADG  : %08x => %p\n", adg_res->start,
 315                 gen->base[RSND_GEN2_ADG]);
 316         dev_dbg(dev, "SSIU : %08x => %p\n", ssiu_res->start,
 317                 gen->base[RSND_GEN2_SSIU]);
 318         dev_dbg(dev, "SSI  : %08x => %p\n", ssi_res->start,
 319                 gen->base[RSND_GEN2_SSI]);
 320
 321         return 0;
 322 }
 323
 324 /*
 325  *              Gen1
 326  */
 327
 328 /* single address mapping */
 329 #define RSND_GEN1_S_REG(gen, reg, id, offset)   \
 330         RSND_REG_SET(gen, RSND_REG_##id, RSND_GEN1_##reg, offset, 0, 9)
 331
 332 /* multi address mapping */
 333 #define RSND_GEN1_M_REG(gen, reg, id, offset, _id_offset)       \
 334         RSND_REG_SET(gen, RSND_REG_##id, RSND_GEN1_##reg, offset, _id_offset, 9)
 335
 336 static int rsnd_gen1_regmap_init(struct rsnd_priv *priv, struct rsnd_gen *gen)
 337 {
 338         struct reg_field regf[RSND_REG_MAX] = {
 339                 RSND_GEN1_S_REG(gen, SRU,       SRC_ROUTE_SEL,  0x00),
 340                 RSND_GEN1_S_REG(gen, SRU,       SRC_TMG_SEL0,   0x08),
 341                 RSND_GEN1_S_REG(gen, SRU,       SRC_TMG_SEL1,   0x0c),
 342                 RSND_GEN1_S_REG(gen, SRU,       SRC_TMG_SEL2,   0x10),
 343                 RSND_GEN1_S_REG(gen, SRU,       SRC_ROUTE_CTRL, 0xc0),
 344                 RSND_GEN1_S_REG(gen, SRU,       SSI_MODE0,      0xD0),
 345                 RSND_GEN1_S_REG(gen, SRU,       SSI_MODE1,      0xD4),
 346                 RSND_GEN1_M_REG(gen, SRU,       SRC_BUSIF_MODE, 0x20,   0x4),
 347                 RSND_GEN1_M_REG(gen, SRU,       SRC_ROUTE_MODE0,0x50,   0x8),
 348                 RSND_GEN1_M_REG(gen, SRU,       SRC_SWRSR,      0x200,  0x40),
 349                 RSND_GEN1_M_REG(gen, SRU,       SRC_SRCIR,      0x204,  0x40),
 350                 RSND_GEN1_M_REG(gen, SRU,       SRC_ADINR,      0x214,  0x40),
 351                 RSND_GEN1_M_REG(gen, SRU,       SRC_IFSCR,      0x21c,  0x40),
 352                 RSND_GEN1_M_REG(gen, SRU,       SRC_IFSVR,      0x220,  0x40),
 353                 RSND_GEN1_M_REG(gen, SRU,       SRC_SRCCR,      0x224,  0x40),
 354                 RSND_GEN1_M_REG(gen, SRU,       SRC_MNFSR,      0x228,  0x40),
 355
 356                 RSND_GEN1_S_REG(gen, ADG,       BRRA,           0x00),
 357                 RSND_GEN1_S_REG(gen, ADG,       BRRB,           0x04),
 358                 RSND_GEN1_S_REG(gen, ADG,       SSICKR,         0x08),
 359                 RSND_GEN1_S_REG(gen, ADG,       AUDIO_CLK_SEL0, 0x0c),
 360                 RSND_GEN1_S_REG(gen, ADG,       AUDIO_CLK_SEL1, 0x10),
 361                 RSND_GEN1_S_REG(gen, ADG,       AUDIO_CLK_SEL3, 0x18),
 362                 RSND_GEN1_S_REG(gen, ADG,       AUDIO_CLK_SEL4, 0x1c),
 363                 RSND_GEN1_S_REG(gen, ADG,       AUDIO_CLK_SEL5, 0x20),
 364
 365                 RSND_GEN1_M_REG(gen, SSI,       SSICR,          0x00,   0x40),
 366                 RSND_GEN1_M_REG(gen, SSI,       SSISR,          0x04,   0x40),
 367                 RSND_GEN1_M_REG(gen, SSI,       SSITDR,         0x08,   0x40),
 368                 RSND_GEN1_M_REG(gen, SSI,       SSIRDR,         0x0c,   0x40),
 369                 RSND_GEN1_M_REG(gen, SSI,       SSIWSR,         0x20,   0x40),
 370         };
 371
 372         return rsnd_gen_regmap_init(priv, gen, regf);
 373 }
 374
 375 static int rsnd_gen1_probe(struct platform_device *pdev,
 376                            struct rcar_snd_info *info,
 377                            struct rsnd_priv *priv)
 378 {
 379         struct device *dev = rsnd_priv_to_dev(priv);
 380         struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
 381         struct resource *sru_res;
 382         struct resource *adg_res;
 383         struct resource *ssi_res;
 384         int ret;
 385
 386         /*
 387          * map address
 388          */
 389         sru_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_SRU);
 390         adg_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_ADG);
 391         ssi_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_SSI);
 392
 393         gen->base[RSND_GEN1_SRU] = devm_ioremap_resource(dev, sru_res);
 394         gen->base[RSND_GEN1_ADG] = devm_ioremap_resource(dev, adg_res);
 395         gen->base[RSND_GEN1_SSI] = devm_ioremap_resource(dev, ssi_res);
 396         if (IS_ERR(gen->base[RSND_GEN1_SRU]) ||
 397             IS_ERR(gen->base[RSND_GEN1_ADG]) ||
 398             IS_ERR(gen->base[RSND_GEN1_SSI]))
 399                 return -ENODEV;
 400
 401         ret = rsnd_gen1_regmap_init(priv, gen);
 402         if (ret < 0)
 403                 return ret;
 404
 405         dev_dbg(dev, "Gen1 device probed\n");
 406         dev_dbg(dev, "SRU : %08x => %p\n",      sru_res->start,
 407                                                 gen->base[RSND_GEN1_SRU]);
 408         dev_dbg(dev, "ADG : %08x => %p\n",      adg_res->start,
 409                                                 gen->base[RSND_GEN1_ADG]);
 410         dev_dbg(dev, "SSI : %08x => %p\n",      ssi_res->start,
 411                                                 gen->base[RSND_GEN1_SSI]);
 412
 413         return 0;
 414
 415 }
 416
 417 /*
 418  *              Gen
 419  */
 420 int rsnd_gen_probe(struct platform_device *pdev,
 421                    struct rcar_snd_info *info,
 422                    struct rsnd_priv *priv)
 423 {
 424         struct device *dev = rsnd_priv_to_dev(priv);
 425         struct rsnd_gen *gen;
 426         int ret;
 427
 428         gen = devm_kzalloc(dev, sizeof(*gen), GFP_KERNEL);
 429         if (!gen) {
 430                 dev_err(dev, "GEN allocate failed\n");
 431                 return -ENOMEM;
 432         }
 433
 434         priv->gen = gen;
 435
 436         ret = -ENODEV;
 437         if (rsnd_is_gen1(priv))
 438                 ret = rsnd_gen1_probe(pdev, info, priv);
 439         else if (rsnd_is_gen2(priv))
 440                 ret = rsnd_gen2_probe(pdev, info, priv);
 441
 442         if (ret < 0)
 443                 dev_err(dev, "unknown generation R-Car sound device\n");
 444
 445         return ret;
 446 }
 447
 448 void rsnd_gen_remove(struct platform_device *pdev,
 449                      struct rsnd_priv *priv)
 450 {
 451 }