sound/soc/generic/simple-card.c

   1 /*
   2  * ASoC simple sound card support
   3  *
   4  * Copyright (C) 2012 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 <linux/clk.h>
  12 #include <linux/device.h>
  13 #include <linux/gpio.h>
  14 #include <linux/module.h>
  15 #include <linux/of.h>
  16 #include <linux/of_gpio.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/string.h>
  19 #include <sound/jack.h>
  20 #include <sound/simple_card.h>
  21 #include <sound/soc-dai.h>
  22 #include <sound/soc.h>
  23
  24 struct simple_card_data {
  25         struct snd_soc_card snd_card;
  26         struct simple_dai_props {
  27                 struct asoc_simple_dai cpu_dai;
  28                 struct asoc_simple_dai codec_dai;
  29         } *dai_props;
  30         unsigned int mclk_fs;
  31         int gpio_hp_det;
  32         int gpio_hp_det_invert;
  33         int gpio_mic_det;
  34         int gpio_mic_det_invert;
  35         struct snd_soc_dai_link dai_link[];     /* dynamically allocated */
  36 };
  37
  38 #define simple_priv_to_dev(priv) ((priv)->snd_card.dev)
  39 #define simple_priv_to_link(priv, i) ((priv)->snd_card.dai_link + i)
  40 #define simple_priv_to_props(priv, i) ((priv)->dai_props + i)
  41
  42 static int asoc_simple_card_hw_params(struct snd_pcm_substream *substream,
  43                                       struct snd_pcm_hw_params *params)
  44 {
  45         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  46         struct snd_soc_dai *codec_dai = rtd->codec_dai;
  47         struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
  48         unsigned int mclk;
  49         int ret = 0;
  50
  51         if (priv->mclk_fs) {
  52                 mclk = params_rate(params) * priv->mclk_fs;
  53                 ret = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
  54                                              SND_SOC_CLOCK_IN);
  55         }
  56
  57         return ret;
  58 }
  59
  60 static struct snd_soc_ops asoc_simple_card_ops = {
  61         .hw_params = asoc_simple_card_hw_params,
  62 };
  63
  64 static struct snd_soc_jack simple_card_hp_jack;
  65 static struct snd_soc_jack_pin simple_card_hp_jack_pins[] = {
  66         {
  67                 .pin = "Headphones",
  68                 .mask = SND_JACK_HEADPHONE,
  69         },
  70 };
  71 static struct snd_soc_jack_gpio simple_card_hp_jack_gpio = {
  72         .name = "Headphone detection",
  73         .report = SND_JACK_HEADPHONE,
  74         .debounce_time = 150,
  75 };
  76
  77 static struct snd_soc_jack simple_card_mic_jack;
  78 static struct snd_soc_jack_pin simple_card_mic_jack_pins[] = {
  79         {
  80                 .pin = "Mic Jack",
  81                 .mask = SND_JACK_MICROPHONE,
  82         },
  83 };
  84 static struct snd_soc_jack_gpio simple_card_mic_jack_gpio = {
  85         .name = "Mic detection",
  86         .report = SND_JACK_MICROPHONE,
  87         .debounce_time = 150,
  88 };
  89
  90 static int __asoc_simple_card_dai_init(struct snd_soc_dai *dai,
  91                                        struct asoc_simple_dai *set)
  92 {
  93         int ret;
  94
  95         if (set->fmt) {
  96                 ret = snd_soc_dai_set_fmt(dai, set->fmt);
  97                 if (ret && ret != -ENOTSUPP) {
  98                         dev_err(dai->dev, "simple-card: set_fmt error\n");
  99                         goto err;
 100                 }
 101         }
 102
 103         if (set->sysclk) {
 104                 ret = snd_soc_dai_set_sysclk(dai, 0, set->sysclk, 0);
 105                 if (ret && ret != -ENOTSUPP) {
 106                         dev_err(dai->dev, "simple-card: set_sysclk error\n");
 107                         goto err;
 108                 }
 109         }
 110
 111         if (set->slots) {
 112                 ret = snd_soc_dai_set_tdm_slot(dai, 0, 0,
 113                                                 set->slots,
 114                                                 set->slot_width);
 115                 if (ret && ret != -ENOTSUPP) {
 116                         dev_err(dai->dev, "simple-card: set_tdm_slot error\n");
 117                         goto err;
 118                 }
 119         }
 120
 121         ret = 0;
 122
 123 err:
 124         return ret;
 125 }
 126
 127 static int asoc_simple_card_dai_init(struct snd_soc_pcm_runtime *rtd)
 128 {
 129         struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
 130         struct snd_soc_dai *codec = rtd->codec_dai;
 131         struct snd_soc_dai *cpu = rtd->cpu_dai;
 132         struct simple_dai_props *dai_props;
 133         int num, ret;
 134
 135         num = rtd - rtd->card->rtd;
 136         dai_props = &priv->dai_props[num];
 137         ret = __asoc_simple_card_dai_init(codec, &dai_props->codec_dai);
 138         if (ret < 0)
 139                 return ret;
 140
 141         ret = __asoc_simple_card_dai_init(cpu, &dai_props->cpu_dai);
 142         if (ret < 0)
 143                 return ret;
 144
 145         if (gpio_is_valid(priv->gpio_hp_det)) {
 146                 snd_soc_jack_new(codec->codec, "Headphones", SND_JACK_HEADPHONE,
 147                                  &simple_card_hp_jack);
 148                 snd_soc_jack_add_pins(&simple_card_hp_jack,
 149                                       ARRAY_SIZE(simple_card_hp_jack_pins),
 150                                       simple_card_hp_jack_pins);
 151
 152                 simple_card_hp_jack_gpio.gpio = priv->gpio_hp_det;
 153                 simple_card_hp_jack_gpio.invert = priv->gpio_hp_det_invert;
 154                 snd_soc_jack_add_gpios(&simple_card_hp_jack, 1,
 155                                        &simple_card_hp_jack_gpio);
 156         }
 157
 158         if (gpio_is_valid(priv->gpio_mic_det)) {
 159                 snd_soc_jack_new(codec->codec, "Mic Jack", SND_JACK_MICROPHONE,
 160                                  &simple_card_mic_jack);
 161                 snd_soc_jack_add_pins(&simple_card_mic_jack,
 162                                       ARRAY_SIZE(simple_card_mic_jack_pins),
 163                                       simple_card_mic_jack_pins);
 164                 simple_card_mic_jack_gpio.gpio = priv->gpio_mic_det;
 165                 simple_card_mic_jack_gpio.invert = priv->gpio_mic_det_invert;
 166                 snd_soc_jack_add_gpios(&simple_card_mic_jack, 1,
 167                                        &simple_card_mic_jack_gpio);
 168         }
 169         return 0;
 170 }
 171
 172 static int
 173 asoc_simple_card_sub_parse_of(struct device_node *np,
 174                               struct asoc_simple_dai *dai,
 175                               struct device_node **p_node,
 176                               const char **name,
 177                               int *args_count)
 178 {
 179         struct of_phandle_args args;
 180         struct clk *clk;
 181         u32 val;
 182         int ret;
 183
 184         /*
 185          * Get node via "sound-dai = <&phandle port>"
 186          * it will be used as xxx_of_node on soc_bind_dai_link()
 187          */
 188         ret = of_parse_phandle_with_args(np, "sound-dai",
 189                                          "#sound-dai-cells", 0, &args);
 190         if (ret)
 191                 return ret;
 192
 193         *p_node = args.np;
 194
 195         if (args_count)
 196                 *args_count = args.args_count;
 197
 198         /* Get dai->name */
 199         ret = snd_soc_of_get_dai_name(np, name);
 200         if (ret < 0)
 201                 return ret;
 202
 203         /* Parse TDM slot */
 204         ret = snd_soc_of_parse_tdm_slot(np, &dai->slots, &dai->slot_width);
 205         if (ret)
 206                 return ret;
 207
 208         /*
 209          * Parse dai->sysclk come from "clocks = <&xxx>"
 210          * (if system has common clock)
 211          *  or "system-clock-frequency = <xxx>"
 212          *  or device's module clock.
 213          */
 214         if (of_property_read_bool(np, "clocks")) {
 215                 clk = of_clk_get(np, 0);
 216                 if (IS_ERR(clk)) {
 217                         ret = PTR_ERR(clk);
 218                         return ret;
 219                 }
 220
 221                 dai->sysclk = clk_get_rate(clk);
 222         } else if (!of_property_read_u32(np, "system-clock-frequency", &val)) {
 223                 dai->sysclk = val;
 224         } else {
 225                 clk = of_clk_get(args.np, 0);
 226                 if (!IS_ERR(clk))
 227                         dai->sysclk = clk_get_rate(clk);
 228         }
 229
 230         return 0;
 231 }
 232
 233 static int asoc_simple_card_parse_daifmt(struct device_node *node,
 234                                          struct simple_card_data *priv,
 235                                          struct device_node *cpu,
 236                                          struct device_node *codec,
 237                                          char *prefix, int idx)
 238 {
 239         struct device *dev = simple_priv_to_dev(priv);
 240         struct device_node *bitclkmaster = NULL;
 241         struct device_node *framemaster = NULL;
 242         struct simple_dai_props *dai_props = simple_priv_to_props(priv, idx);
 243         struct asoc_simple_dai *cpu_dai = &dai_props->cpu_dai;
 244         struct asoc_simple_dai *codec_dai = &dai_props->codec_dai;
 245         unsigned int daifmt;
 246
 247         daifmt = snd_soc_of_parse_daifmt(node, prefix,
 248                                          &bitclkmaster, &framemaster);
 249         daifmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
 250
 251         if (strlen(prefix) && !bitclkmaster && !framemaster) {
 252                 /*
 253                  * No dai-link level and master setting was not found from
 254                  * sound node level, revert back to legacy DT parsing and
 255                  * take the settings from codec node.
 256                  */
 257                 dev_dbg(dev, "Revert to legacy daifmt parsing\n");
 258
 259                 cpu_dai->fmt = codec_dai->fmt =
 260                         snd_soc_of_parse_daifmt(codec, NULL, NULL, NULL) |
 261                         (daifmt & ~SND_SOC_DAIFMT_CLOCK_MASK);
 262         } else {
 263                 if (codec == bitclkmaster)
 264                         daifmt |= (codec == framemaster) ?
 265                                 SND_SOC_DAIFMT_CBM_CFM : SND_SOC_DAIFMT_CBM_CFS;
 266                 else
 267                         daifmt |= (codec == framemaster) ?
 268                                 SND_SOC_DAIFMT_CBS_CFM : SND_SOC_DAIFMT_CBS_CFS;
 269
 270                 cpu_dai->fmt    = daifmt;
 271                 codec_dai->fmt  = daifmt;
 272         }
 273
 274         of_node_put(bitclkmaster);
 275         of_node_put(framemaster);
 276
 277         return 0;
 278 }
 279
 280 static int asoc_simple_card_dai_link_of(struct device_node *node,
 281                                         struct simple_card_data *priv,
 282                                         int idx,
 283                                         bool is_top_level_node)
 284 {
 285         struct device *dev = simple_priv_to_dev(priv);
 286         struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, idx);
 287         struct simple_dai_props *dai_props = simple_priv_to_props(priv, idx);
 288         struct device_node *cpu = NULL;
 289         struct device_node *codec = NULL;
 290         char *name;
 291         char prop[128];
 292         char *prefix = "";
 293         int ret, cpu_args;
 294
 295         /* For single DAI link & old style of DT node */
 296         if (is_top_level_node)
 297                 prefix = "simple-audio-card,";
 298
 299         snprintf(prop, sizeof(prop), "%scpu", prefix);
 300         cpu = of_get_child_by_name(node, prop);
 301
 302         snprintf(prop, sizeof(prop), "%scodec", prefix);
 303         codec = of_get_child_by_name(node, prop);
 304
 305         if (!cpu || !codec) {
 306                 ret = -EINVAL;
 307                 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop);
 308                 goto dai_link_of_err;
 309         }
 310
 311         ret = asoc_simple_card_parse_daifmt(node, priv,
 312                                             cpu, codec, prefix, idx);
 313         if (ret < 0)
 314                 goto dai_link_of_err;
 315
 316         ret = asoc_simple_card_sub_parse_of(cpu, &dai_props->cpu_dai,
 317                                             &dai_link->cpu_of_node,
 318                                             &dai_link->cpu_dai_name,
 319                                             &cpu_args);
 320         if (ret < 0)
 321                 goto dai_link_of_err;
 322
 323         ret = asoc_simple_card_sub_parse_of(codec, &dai_props->codec_dai,
 324                                             &dai_link->codec_of_node,
 325                                             &dai_link->codec_dai_name, NULL);
 326         if (ret < 0)
 327                 goto dai_link_of_err;
 328
 329         if (!dai_link->cpu_dai_name || !dai_link->codec_dai_name) {
 330                 ret = -EINVAL;
 331                 goto dai_link_of_err;
 332         }
 333
 334         /* Simple Card assumes platform == cpu */
 335         dai_link->platform_of_node = dai_link->cpu_of_node;
 336
 337         /* DAI link name is created from CPU/CODEC dai name */
 338         name = devm_kzalloc(dev,
 339                             strlen(dai_link->cpu_dai_name)   +
 340                             strlen(dai_link->codec_dai_name) + 2,
 341                             GFP_KERNEL);
 342         sprintf(name, "%s-%s", dai_link->cpu_dai_name,
 343                                 dai_link->codec_dai_name);
 344         dai_link->name = dai_link->stream_name = name;
 345         dai_link->ops = &asoc_simple_card_ops;
 346         dai_link->init = asoc_simple_card_dai_init;
 347
 348         dev_dbg(dev, "\tname : %s\n", dai_link->stream_name);
 349         dev_dbg(dev, "\tcpu : %s / %04x / %d\n",
 350                 dai_link->cpu_dai_name,
 351                 dai_props->cpu_dai.fmt,
 352                 dai_props->cpu_dai.sysclk);
 353         dev_dbg(dev, "\tcodec : %s / %04x / %d\n",
 354                 dai_link->codec_dai_name,
 355                 dai_props->codec_dai.fmt,
 356                 dai_props->codec_dai.sysclk);
 357
 358         /*
 359          * In soc_bind_dai_link() will check cpu name after
 360          * of_node matching if dai_link has cpu_dai_name.
 361          * but, it will never match if name was created by
 362          * fmt_single_name() remove cpu_dai_name if cpu_args
 363          * was 0. See:
 364          *      fmt_single_name()
 365          *      fmt_multiple_name()
 366          */
 367         if (!cpu_args)
 368                 dai_link->cpu_dai_name = NULL;
 369
 370 dai_link_of_err:
 371         of_node_put(cpu);
 372         of_node_put(codec);
 373
 374         return ret;
 375 }
 376
 377 static int asoc_simple_card_parse_of(struct device_node *node,
 378                                      struct simple_card_data *priv)
 379 {
 380         struct device *dev = simple_priv_to_dev(priv);
 381         enum of_gpio_flags flags;
 382         u32 val;
 383         int ret;
 384
 385         if (!node)
 386                 return -EINVAL;
 387
 388         /* Parse the card name from DT */
 389         snd_soc_of_parse_card_name(&priv->snd_card, "simple-audio-card,name");
 390
 391         /* The off-codec widgets */
 392         if (of_property_read_bool(node, "simple-audio-card,widgets")) {
 393                 ret = snd_soc_of_parse_audio_simple_widgets(&priv->snd_card,
 394                                         "simple-audio-card,widgets");
 395                 if (ret)
 396                         return ret;
 397         }
 398
 399         /* DAPM routes */
 400         if (of_property_read_bool(node, "simple-audio-card,routing")) {
 401                 ret = snd_soc_of_parse_audio_routing(&priv->snd_card,
 402                                         "simple-audio-card,routing");
 403                 if (ret)
 404                         return ret;
 405         }
 406
 407         /* Factor to mclk, used in hw_params() */
 408         ret = of_property_read_u32(node, "simple-audio-card,mclk-fs", &val);
 409         if (ret == 0)
 410                 priv->mclk_fs = val;
 411
 412         dev_dbg(dev, "New simple-card: %s\n", priv->snd_card.name ?
 413                 priv->snd_card.name : "");
 414
 415         /* Single/Muti DAI link(s) & New style of DT node */
 416         if (of_get_child_by_name(node, "simple-audio-card,dai-link")) {
 417                 struct device_node *np = NULL;
 418                 int i = 0;
 419
 420                 for_each_child_of_node(node, np) {
 421                         dev_dbg(dev, "\tlink %d:\n", i);
 422                         ret = asoc_simple_card_dai_link_of(np, priv,
 423                                                            i, false);
 424                         if (ret < 0) {
 425                                 of_node_put(np);
 426                                 return ret;
 427                         }
 428                         i++;
 429                 }
 430         } else {
 431                 /* For single DAI link & old style of DT node */
 432                 ret = asoc_simple_card_dai_link_of(node, priv, 0, true);
 433                 if (ret < 0)
 434                         return ret;
 435         }
 436
 437         priv->gpio_hp_det = of_get_named_gpio_flags(node,
 438                                 "simple-audio-card,hp-det-gpio", 0, &flags);
 439         priv->gpio_hp_det_invert = !!(flags & OF_GPIO_ACTIVE_LOW);
 440         if (priv->gpio_hp_det == -EPROBE_DEFER)
 441                 return -EPROBE_DEFER;
 442
 443         priv->gpio_mic_det = of_get_named_gpio_flags(node,
 444                                 "simple-audio-card,mic-det-gpio", 0, &flags);
 445         priv->gpio_mic_det_invert = !!(flags & OF_GPIO_ACTIVE_LOW);
 446         if (priv->gpio_mic_det == -EPROBE_DEFER)
 447                 return -EPROBE_DEFER;
 448
 449         if (!priv->snd_card.name)
 450                 priv->snd_card.name = priv->snd_card.dai_link->name;
 451
 452         return 0;
 453 }
 454
 455 /* Decrease the reference count of the device nodes */
 456 static int asoc_simple_card_unref(struct platform_device *pdev)
 457 {
 458         struct snd_soc_card *card = platform_get_drvdata(pdev);
 459         struct snd_soc_dai_link *dai_link;
 460         int num_links;
 461
 462         for (num_links = 0, dai_link = card->dai_link;
 463              num_links < card->num_links;
 464              num_links++, dai_link++) {
 465                 of_node_put(dai_link->cpu_of_node);
 466                 of_node_put(dai_link->codec_of_node);
 467         }
 468         return 0;
 469 }
 470
 471 static int asoc_simple_card_probe(struct platform_device *pdev)
 472 {
 473         struct simple_card_data *priv;
 474         struct snd_soc_dai_link *dai_link;
 475         struct device_node *np = pdev->dev.of_node;
 476         struct device *dev = &pdev->dev;
 477         int num_links, ret;
 478
 479         /* Get the number of DAI links */
 480         if (np && of_get_child_by_name(np, "simple-audio-card,dai-link"))
 481                 num_links = of_get_child_count(np);
 482         else
 483                 num_links = 1;
 484
 485         /* Allocate the private data and the DAI link array */
 486         priv = devm_kzalloc(dev,
 487                         sizeof(*priv) + sizeof(*dai_link) * num_links,
 488                         GFP_KERNEL);
 489         if (!priv)
 490                 return -ENOMEM;
 491
 492         /* Init snd_soc_card */
 493         priv->snd_card.owner = THIS_MODULE;
 494         priv->snd_card.dev = dev;
 495         dai_link = priv->dai_link;
 496         priv->snd_card.dai_link = dai_link;
 497         priv->snd_card.num_links = num_links;
 498
 499         priv->gpio_hp_det = -ENOENT;
 500         priv->gpio_mic_det = -ENOENT;
 501
 502         /* Get room for the other properties */
 503         priv->dai_props = devm_kzalloc(dev,
 504                         sizeof(*priv->dai_props) * num_links,
 505                         GFP_KERNEL);
 506         if (!priv->dai_props)
 507                 return -ENOMEM;
 508
 509         if (np && of_device_is_available(np)) {
 510
 511                 ret = asoc_simple_card_parse_of(np, priv);
 512                 if (ret < 0) {
 513                         if (ret != -EPROBE_DEFER)
 514                                 dev_err(dev, "parse error %d\n", ret);
 515                         goto err;
 516                 }
 517
 518         } else {
 519                 struct asoc_simple_card_info *cinfo;
 520
 521                 cinfo = dev->platform_data;
 522                 if (!cinfo) {
 523                         dev_err(dev, "no info for asoc-simple-card\n");
 524                         return -EINVAL;
 525                 }
 526
 527                 if (!cinfo->name ||
 528                     !cinfo->codec_dai.name ||
 529                     !cinfo->codec ||
 530                     !cinfo->platform ||
 531                     !cinfo->cpu_dai.name) {
 532                         dev_err(dev, "insufficient asoc_simple_card_info settings\n");
 533                         return -EINVAL;
 534                 }
 535
 536                 priv->snd_card.name     = (cinfo->card) ? cinfo->card : cinfo->name;
 537                 dai_link->name          = cinfo->name;
 538                 dai_link->stream_name   = cinfo->name;
 539                 dai_link->platform_name = cinfo->platform;
 540                 dai_link->codec_name    = cinfo->codec;
 541                 dai_link->cpu_dai_name  = cinfo->cpu_dai.name;
 542                 dai_link->codec_dai_name = cinfo->codec_dai.name;
 543                 dai_link->init          = asoc_simple_card_dai_init;
 544                 memcpy(&priv->dai_props->cpu_dai, &cinfo->cpu_dai,
 545                                         sizeof(priv->dai_props->cpu_dai));
 546                 memcpy(&priv->dai_props->codec_dai, &cinfo->codec_dai,
 547                                         sizeof(priv->dai_props->codec_dai));
 548
 549                 priv->dai_props->cpu_dai.fmt    |= cinfo->daifmt;
 550                 priv->dai_props->codec_dai.fmt  |= cinfo->daifmt;
 551         }
 552
 553         snd_soc_card_set_drvdata(&priv->snd_card, priv);
 554
 555         ret = devm_snd_soc_register_card(&pdev->dev, &priv->snd_card);
 556         if (ret >= 0)
 557                 return ret;
 558
 559 err:
 560         asoc_simple_card_unref(pdev);
 561         return ret;
 562 }
 563
 564 static int asoc_simple_card_remove(struct platform_device *pdev)
 565 {
 566         struct snd_soc_card *card = platform_get_drvdata(pdev);
 567         struct simple_card_data *priv = snd_soc_card_get_drvdata(card);
 568
 569         if (gpio_is_valid(priv->gpio_hp_det))
 570                 snd_soc_jack_free_gpios(&simple_card_hp_jack, 1,
 571                                         &simple_card_hp_jack_gpio);
 572         if (gpio_is_valid(priv->gpio_mic_det))
 573                 snd_soc_jack_free_gpios(&simple_card_mic_jack, 1,
 574                                         &simple_card_mic_jack_gpio);
 575
 576         return asoc_simple_card_unref(pdev);
 577 }
 578
 579 static const struct of_device_id asoc_simple_of_match[] = {
 580         { .compatible = "simple-audio-card", },
 581         {},
 582 };
 583 MODULE_DEVICE_TABLE(of, asoc_simple_of_match);
 584
 585 static struct platform_driver asoc_simple_card = {
 586         .driver = {
 587                 .name = "asoc-simple-card",
 588                 .owner = THIS_MODULE,
 589                 .of_match_table = asoc_simple_of_match,
 590         },
 591         .probe = asoc_simple_card_probe,
 592         .remove = asoc_simple_card_remove,
 593 };
 594
 595 module_platform_driver(asoc_simple_card);
 596
 597 MODULE_ALIAS("platform:asoc-simple-card");
 598 MODULE_LICENSE("GPL");
 599 MODULE_DESCRIPTION("ASoC Simple Sound Card");
 600 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");