drivers/staging/greybus/audio_codec.c

   1 /*
   2  * APBridge ALSA SoC dummy codec driver
   3  * Copyright 2016 Google Inc.
   4  * Copyright 2016 Linaro Ltd.
   5  *
   6  * Released under the GPLv2 only.
   7  */
   8 #include <linux/kernel.h>
   9 #include <linux/module.h>
  10 #include <linux/pm_runtime.h>
  11 #include <sound/soc.h>
  12 #include <sound/pcm_params.h>
  13 #include <uapi/linux/input.h>
  14
  15 #include "audio_codec.h"
  16 #include "audio_apbridgea.h"
  17 #include "audio_manager.h"
  18
  19 static struct gbaudio_codec_info *gbcodec;
  20
  21 static struct gbaudio_data_connection *
  22 find_data(struct gbaudio_module_info *module, int id)
  23 {
  24         struct gbaudio_data_connection *data;
  25
  26         list_for_each_entry(data, &module->data_list, list) {
  27                 if (id == data->id)
  28                         return data;
  29         }
  30         return NULL;
  31 }
  32
  33 static struct gbaudio_stream_params *
  34 find_dai_stream_params(struct gbaudio_codec_info *codec, int id, int stream)
  35 {
  36         struct gbaudio_codec_dai *dai;
  37
  38         list_for_each_entry(dai, &codec->dai_list, list) {
  39                 if (dai->id == id)
  40                         return &dai->params[stream];
  41         }
  42         return NULL;
  43 }
  44
  45 static int gbaudio_module_enable_tx(struct gbaudio_codec_info *codec,
  46                                     struct gbaudio_module_info *module, int id)
  47 {
  48         int module_state, ret = 0;
  49         u16 data_cport, i2s_port, cportid;
  50         u8 sig_bits, channels;
  51         uint32_t format, rate;
  52         struct gbaudio_data_connection *data;
  53         struct gbaudio_stream_params *params;
  54
  55         /* find the dai */
  56         data = find_data(module, id);
  57         if (!data) {
  58                 dev_err(module->dev, "%d:DATA connection missing\n", id);
  59                 return -ENODEV;
  60         }
  61         module_state = data->state[SNDRV_PCM_STREAM_PLAYBACK];
  62
  63         params = find_dai_stream_params(codec, id, SNDRV_PCM_STREAM_PLAYBACK);
  64         if (!params) {
  65                 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
  66                 return -EINVAL;
  67         }
  68
  69         /* register cport */
  70         if (module_state < GBAUDIO_CODEC_STARTUP) {
  71                 i2s_port = 0;   /* fixed for now */
  72                 cportid = data->connection->hd_cport_id;
  73                 ret = gb_audio_apbridgea_register_cport(data->connection,
  74                                                 i2s_port, cportid,
  75                                                 AUDIO_APBRIDGEA_DIRECTION_TX);
  76                 if (ret) {
  77                         dev_err_ratelimited(module->dev,
  78                                             "reg_cport failed:%d\n", ret);
  79                         return ret;
  80                 }
  81                 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
  82                         GBAUDIO_CODEC_STARTUP;
  83                 dev_dbg(module->dev, "Dynamic Register %d DAI\n", cportid);
  84         }
  85
  86         /* hw_params */
  87         if (module_state < GBAUDIO_CODEC_HWPARAMS) {
  88                 format = params->format;
  89                 channels = params->channels;
  90                 rate = params->rate;
  91                 sig_bits = params->sig_bits;
  92                 data_cport = data->connection->intf_cport_id;
  93                 ret = gb_audio_gb_set_pcm(module->mgmt_connection, data_cport,
  94                                           format, rate, channels, sig_bits);
  95                 if (ret) {
  96                         dev_err_ratelimited(module->dev, "set_pcm failed:%d\n",
  97                                             ret);
  98                         return ret;
  99                 }
 100                 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
 101                         GBAUDIO_CODEC_HWPARAMS;
 102                 dev_dbg(module->dev, "Dynamic hw_params %d DAI\n", data_cport);
 103         }
 104
 105         /* prepare */
 106         if (module_state < GBAUDIO_CODEC_PREPARE) {
 107                 data_cport = data->connection->intf_cport_id;
 108                 ret = gb_audio_gb_set_tx_data_size(module->mgmt_connection,
 109                                                    data_cport, 192);
 110                 if (ret) {
 111                         dev_err_ratelimited(module->dev,
 112                                             "set_tx_data_size failed:%d\n",
 113                                             ret);
 114                         return ret;
 115                 }
 116                 ret = gb_audio_gb_activate_tx(module->mgmt_connection,
 117                                               data_cport);
 118                 if (ret) {
 119                         dev_err_ratelimited(module->dev,
 120                                             "activate_tx failed:%d\n", ret);
 121                         return ret;
 122                 }
 123                 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
 124                         GBAUDIO_CODEC_PREPARE;
 125                 dev_dbg(module->dev, "Dynamic prepare %d DAI\n", data_cport);
 126         }
 127
 128         return 0;
 129 }
 130
 131 static int gbaudio_module_disable_tx(struct gbaudio_module_info *module, int id)
 132 {
 133         int ret;
 134         u16 data_cport, cportid, i2s_port;
 135         int module_state;
 136         struct gbaudio_data_connection *data;
 137
 138         /* find the dai */
 139         data = find_data(module, id);
 140         if (!data) {
 141                 dev_err(module->dev, "%d:DATA connection missing\n", id);
 142                 return -ENODEV;
 143         }
 144         module_state = data->state[SNDRV_PCM_STREAM_PLAYBACK];
 145
 146         if (module_state > GBAUDIO_CODEC_HWPARAMS) {
 147                 data_cport = data->connection->intf_cport_id;
 148                 ret = gb_audio_gb_deactivate_tx(module->mgmt_connection,
 149                                                 data_cport);
 150                 if (ret) {
 151                         dev_err_ratelimited(module->dev,
 152                                             "deactivate_tx failed:%d\n", ret);
 153                         return ret;
 154                 }
 155                 dev_dbg(module->dev, "Dynamic deactivate %d DAI\n", data_cport);
 156                 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
 157                         GBAUDIO_CODEC_HWPARAMS;
 158         }
 159
 160         if (module_state > GBAUDIO_CODEC_SHUTDOWN) {
 161                 i2s_port = 0;   /* fixed for now */
 162                 cportid = data->connection->hd_cport_id;
 163                 ret = gb_audio_apbridgea_unregister_cport(data->connection,
 164                                                 i2s_port, cportid,
 165                                                 AUDIO_APBRIDGEA_DIRECTION_TX);
 166                 if (ret) {
 167                         dev_err_ratelimited(module->dev,
 168                                             "unregister_cport failed:%d\n",
 169                                             ret);
 170                         return ret;
 171                 }
 172                 dev_dbg(module->dev, "Dynamic Unregister %d DAI\n", cportid);
 173                 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
 174                         GBAUDIO_CODEC_SHUTDOWN;
 175         }
 176
 177         return 0;
 178 }
 179
 180 static int gbaudio_module_enable_rx(struct gbaudio_codec_info *codec,
 181                                     struct gbaudio_module_info *module, int id)
 182 {
 183         int module_state, ret = 0;
 184         u16 data_cport, i2s_port, cportid;
 185         u8 sig_bits, channels;
 186         uint32_t format, rate;
 187         struct gbaudio_data_connection *data;
 188         struct gbaudio_stream_params *params;
 189
 190         /* find the dai */
 191         data = find_data(module, id);
 192         if (!data) {
 193                 dev_err(module->dev, "%d:DATA connection missing\n", id);
 194                 return -ENODEV;
 195         }
 196         module_state = data->state[SNDRV_PCM_STREAM_CAPTURE];
 197
 198         params = find_dai_stream_params(codec, id, SNDRV_PCM_STREAM_CAPTURE);
 199         if (!params) {
 200                 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
 201                 return -EINVAL;
 202         }
 203
 204         /* register cport */
 205         if (module_state < GBAUDIO_CODEC_STARTUP) {
 206                 i2s_port = 0;   /* fixed for now */
 207                 cportid = data->connection->hd_cport_id;
 208                 ret = gb_audio_apbridgea_register_cport(data->connection,
 209                                                 i2s_port, cportid,
 210                                                 AUDIO_APBRIDGEA_DIRECTION_RX);
 211                 if (ret) {
 212                         dev_err_ratelimited(module->dev,
 213                                             "reg_cport failed:%d\n", ret);
 214                         return ret;
 215                 }
 216                 data->state[SNDRV_PCM_STREAM_CAPTURE] =
 217                         GBAUDIO_CODEC_STARTUP;
 218                 dev_dbg(module->dev, "Dynamic Register %d DAI\n", cportid);
 219         }
 220
 221         /* hw_params */
 222         if (module_state < GBAUDIO_CODEC_HWPARAMS) {
 223                 format = params->format;
 224                 channels = params->channels;
 225                 rate = params->rate;
 226                 sig_bits = params->sig_bits;
 227                 data_cport = data->connection->intf_cport_id;
 228                 ret = gb_audio_gb_set_pcm(module->mgmt_connection, data_cport,
 229                                           format, rate, channels, sig_bits);
 230                 if (ret) {
 231                         dev_err_ratelimited(module->dev, "set_pcm failed:%d\n",
 232                                             ret);
 233                         return ret;
 234                 }
 235                 data->state[SNDRV_PCM_STREAM_CAPTURE] =
 236                         GBAUDIO_CODEC_HWPARAMS;
 237                 dev_dbg(module->dev, "Dynamic hw_params %d DAI\n", data_cport);
 238         }
 239
 240         /* prepare */
 241         if (module_state < GBAUDIO_CODEC_PREPARE) {
 242                 data_cport = data->connection->intf_cport_id;
 243                 ret = gb_audio_gb_set_rx_data_size(module->mgmt_connection,
 244                                                    data_cport, 192);
 245                 if (ret) {
 246                         dev_err_ratelimited(module->dev,
 247                                             "set_rx_data_size failed:%d\n",
 248                                             ret);
 249                         return ret;
 250                 }
 251                 ret = gb_audio_gb_activate_rx(module->mgmt_connection,
 252                                               data_cport);
 253                 if (ret) {
 254                         dev_err_ratelimited(module->dev,
 255                                             "activate_rx failed:%d\n", ret);
 256                         return ret;
 257                 }
 258                 data->state[SNDRV_PCM_STREAM_CAPTURE] =
 259                         GBAUDIO_CODEC_PREPARE;
 260                 dev_dbg(module->dev, "Dynamic prepare %d DAI\n", data_cport);
 261         }
 262
 263         return 0;
 264 }
 265
 266 static int gbaudio_module_disable_rx(struct gbaudio_module_info *module, int id)
 267 {
 268         int ret;
 269         u16 data_cport, cportid, i2s_port;
 270         int module_state;
 271         struct gbaudio_data_connection *data;
 272
 273         /* find the dai */
 274         data = find_data(module, id);
 275         if (!data) {
 276                 dev_err(module->dev, "%d:DATA connection missing\n", id);
 277                 return -ENODEV;
 278         }
 279         module_state = data->state[SNDRV_PCM_STREAM_CAPTURE];
 280
 281         if (module_state > GBAUDIO_CODEC_HWPARAMS) {
 282                 data_cport = data->connection->intf_cport_id;
 283                 ret = gb_audio_gb_deactivate_rx(module->mgmt_connection,
 284                                                 data_cport);
 285                 if (ret) {
 286                         dev_err_ratelimited(module->dev,
 287                                             "deactivate_rx failed:%d\n", ret);
 288                         return ret;
 289                 }
 290                 dev_dbg(module->dev, "Dynamic deactivate %d DAI\n", data_cport);
 291                 data->state[SNDRV_PCM_STREAM_CAPTURE] =
 292                         GBAUDIO_CODEC_HWPARAMS;
 293         }
 294
 295         if (module_state > GBAUDIO_CODEC_SHUTDOWN) {
 296                 i2s_port = 0;   /* fixed for now */
 297                 cportid = data->connection->hd_cport_id;
 298                 ret = gb_audio_apbridgea_unregister_cport(data->connection,
 299                                                 i2s_port, cportid,
 300                                                 AUDIO_APBRIDGEA_DIRECTION_RX);
 301                 if (ret) {
 302                         dev_err_ratelimited(module->dev,
 303                                             "unregister_cport failed:%d\n",
 304                                             ret);
 305                         return ret;
 306                 }
 307                 dev_dbg(module->dev, "Dynamic Unregister %d DAI\n", cportid);
 308                 data->state[SNDRV_PCM_STREAM_CAPTURE] =
 309                         GBAUDIO_CODEC_SHUTDOWN;
 310         }
 311
 312         return 0;
 313 }
 314
 315 int gbaudio_module_update(struct gbaudio_codec_info *codec,
 316                           struct snd_soc_dapm_widget *w,
 317                           struct gbaudio_module_info *module, int enable)
 318 {
 319         int dai_id, ret;
 320         char intf_name[NAME_SIZE], dir[NAME_SIZE];
 321
 322         dev_dbg(module->dev, "%s:Module update %s sequence\n", w->name,
 323                 enable ? "Enable":"Disable");
 324
 325         if ((w->id != snd_soc_dapm_aif_in) && (w->id != snd_soc_dapm_aif_out)) {
 326                 dev_dbg(codec->dev, "No action required for %s\n", w->name);
 327                 return 0;
 328         }
 329
 330         /* parse dai_id from AIF widget's stream_name */
 331         ret = sscanf(w->sname, "%s %d %s", intf_name, &dai_id, dir);
 332         if (ret < 3) {
 333                 dev_err(codec->dev, "Error while parsing dai_id for %s\n",
 334                         w->name);
 335                 return -EINVAL;
 336         }
 337
 338         mutex_lock(&codec->lock);
 339         if (w->id == snd_soc_dapm_aif_in) {
 340                 if (enable)
 341                         ret = gbaudio_module_enable_tx(codec, module, dai_id);
 342                 else
 343                         ret = gbaudio_module_disable_tx(module, dai_id);
 344         } else if (w->id == snd_soc_dapm_aif_out) {
 345                 if (enable)
 346                         ret = gbaudio_module_enable_rx(codec, module, dai_id);
 347                 else
 348                         ret = gbaudio_module_disable_rx(module, dai_id);
 349         }
 350
 351         mutex_unlock(&codec->lock);
 352
 353         return ret;
 354 }
 355 EXPORT_SYMBOL(gbaudio_module_update);
 356
 357 /*
 358  * codec DAI ops
 359  */
 360 static int gbcodec_startup(struct snd_pcm_substream *substream,
 361                            struct snd_soc_dai *dai)
 362 {
 363         struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
 364         struct gbaudio_stream_params *params;
 365
 366         mutex_lock(&codec->lock);
 367
 368         if (list_empty(&codec->module_list)) {
 369                 dev_err(codec->dev, "No codec module available\n");
 370                 mutex_unlock(&codec->lock);
 371                 return -ENODEV;
 372         }
 373
 374         params = find_dai_stream_params(codec, dai->id, substream->stream);
 375         if (!params) {
 376                 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
 377                 mutex_unlock(&codec->lock);
 378                 return -EINVAL;
 379         }
 380         params->state = GBAUDIO_CODEC_STARTUP;
 381         mutex_unlock(&codec->lock);
 382         /* to prevent suspend in case of active audio */
 383         pm_stay_awake(dai->dev);
 384
 385         return 0;
 386 }
 387
 388 static void gbcodec_shutdown(struct snd_pcm_substream *substream,
 389                              struct snd_soc_dai *dai)
 390 {
 391         struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
 392         struct gbaudio_stream_params *params;
 393
 394         mutex_lock(&codec->lock);
 395
 396         if (list_empty(&codec->module_list))
 397                 dev_info(codec->dev, "No codec module available during shutdown\n");
 398
 399         params = find_dai_stream_params(codec, dai->id, substream->stream);
 400         if (!params) {
 401                 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
 402                 mutex_unlock(&codec->lock);
 403                 return;
 404         }
 405         params->state = GBAUDIO_CODEC_SHUTDOWN;
 406         mutex_unlock(&codec->lock);
 407         pm_relax(dai->dev);
 408         return;
 409 }
 410
 411 static int gbcodec_hw_params(struct snd_pcm_substream *substream,
 412                              struct snd_pcm_hw_params *hwparams,
 413                              struct snd_soc_dai *dai)
 414 {
 415         int ret;
 416         u8 sig_bits, channels;
 417         uint32_t format, rate;
 418         struct gbaudio_module_info *module;
 419         struct gbaudio_data_connection *data;
 420         struct gb_bundle *bundle;
 421         struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
 422         struct gbaudio_stream_params *params;
 423
 424         mutex_lock(&codec->lock);
 425
 426         if (list_empty(&codec->module_list)) {
 427                 dev_err(codec->dev, "No codec module available\n");
 428                 mutex_unlock(&codec->lock);
 429                 return -ENODEV;
 430         }
 431
 432         /*
 433          * assuming, currently only 48000 Hz, 16BIT_LE, stereo
 434          * is supported, validate params before configuring codec
 435          */
 436         if (params_channels(hwparams) != 2) {
 437                 dev_err(dai->dev, "Invalid channel count:%d\n",
 438                         params_channels(hwparams));
 439                 mutex_unlock(&codec->lock);
 440                 return -EINVAL;
 441         }
 442         channels = params_channels(hwparams);
 443
 444         if (params_rate(hwparams) != 48000) {
 445                 dev_err(dai->dev, "Invalid sampling rate:%d\n",
 446                         params_rate(hwparams));
 447                 mutex_unlock(&codec->lock);
 448                 return -EINVAL;
 449         }
 450         rate = GB_AUDIO_PCM_RATE_48000;
 451
 452         if (params_format(hwparams) != SNDRV_PCM_FORMAT_S16_LE) {
 453                 dev_err(dai->dev, "Invalid format:%d\n",
 454                         params_format(hwparams));
 455                 mutex_unlock(&codec->lock);
 456                 return -EINVAL;
 457         }
 458         format = GB_AUDIO_PCM_FMT_S16_LE;
 459
 460         /* find the data connection */
 461         list_for_each_entry(module, &codec->module_list, list) {
 462                 data = find_data(module, dai->id);
 463                 if (data)
 464                         break;
 465         }
 466
 467         if (!data) {
 468                 dev_err(dai->dev, "DATA connection missing\n");
 469                 mutex_unlock(&codec->lock);
 470                 return -EINVAL;
 471         }
 472
 473         params = find_dai_stream_params(codec, dai->id, substream->stream);
 474         if (!params) {
 475                 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
 476                 mutex_unlock(&codec->lock);
 477                 return -EINVAL;
 478         }
 479
 480         bundle = to_gb_bundle(module->dev);
 481         ret = gb_pm_runtime_get_sync(bundle);
 482         if (ret) {
 483                 mutex_unlock(&codec->lock);
 484                 return ret;
 485         }
 486
 487         ret = gb_audio_apbridgea_set_config(data->connection, 0,
 488                                             AUDIO_APBRIDGEA_PCM_FMT_16,
 489                                             AUDIO_APBRIDGEA_PCM_RATE_48000,
 490                                             6144000);
 491         if (ret) {
 492                 dev_err_ratelimited(dai->dev, "%d: Error during set_config\n",
 493                                     ret);
 494                 gb_pm_runtime_put_noidle(bundle);
 495                 mutex_unlock(&codec->lock);
 496                 return ret;
 497         }
 498
 499         gb_pm_runtime_put_noidle(bundle);
 500
 501         params->state = GBAUDIO_CODEC_HWPARAMS;
 502         params->format = format;
 503         params->rate = rate;
 504         params->channels = channels;
 505         params->sig_bits = sig_bits;
 506
 507         mutex_unlock(&codec->lock);
 508         return 0;
 509 }
 510
 511 static int gbcodec_prepare(struct snd_pcm_substream *substream,
 512                            struct snd_soc_dai *dai)
 513 {
 514         int ret;
 515         struct gbaudio_module_info *module;
 516         struct gbaudio_data_connection *data;
 517         struct gb_bundle *bundle;
 518         struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
 519         struct gbaudio_stream_params *params;
 520
 521         mutex_lock(&codec->lock);
 522
 523         if (list_empty(&codec->module_list)) {
 524                 dev_err(codec->dev, "No codec module available\n");
 525                 mutex_unlock(&codec->lock);
 526                 return -ENODEV;
 527         }
 528
 529         list_for_each_entry(module, &codec->module_list, list) {
 530                 /* find the dai */
 531                 data = find_data(module, dai->id);
 532                 if (data)
 533                         break;
 534         }
 535         if (!data) {
 536                 dev_err(dai->dev, "DATA connection missing\n");
 537                 mutex_unlock(&codec->lock);
 538                 return -ENODEV;
 539         }
 540
 541         params = find_dai_stream_params(codec, dai->id, substream->stream);
 542         if (!params) {
 543                 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
 544                 mutex_unlock(&codec->lock);
 545                 return -EINVAL;
 546         }
 547
 548         bundle = to_gb_bundle(module->dev);
 549         ret = gb_pm_runtime_get_sync(bundle);
 550         if (ret) {
 551                 mutex_unlock(&codec->lock);
 552                 return ret;
 553         }
 554
 555         switch (substream->stream) {
 556         case SNDRV_PCM_STREAM_PLAYBACK:
 557                 ret = gb_audio_apbridgea_set_tx_data_size(data->connection, 0,
 558                                                           192);
 559                 break;
 560         case SNDRV_PCM_STREAM_CAPTURE:
 561                 ret = gb_audio_apbridgea_set_rx_data_size(data->connection, 0,
 562                                                           192);
 563                 break;
 564         }
 565         if (ret) {
 566                 gb_pm_runtime_put_noidle(bundle);
 567                 mutex_unlock(&codec->lock);
 568                 dev_err_ratelimited(dai->dev, "set_data_size failed:%d\n",
 569                                      ret);
 570                 return ret;
 571         }
 572
 573         gb_pm_runtime_put_noidle(bundle);
 574
 575         params->state = GBAUDIO_CODEC_PREPARE;
 576         mutex_unlock(&codec->lock);
 577         return 0;
 578 }
 579
 580 static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
 581 {
 582         int ret;
 583         struct gbaudio_data_connection *data;
 584         struct gbaudio_module_info *module;
 585         struct gb_bundle *bundle;
 586         struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
 587         struct gbaudio_stream_params *params;
 588
 589
 590         dev_dbg(dai->dev, "Mute:%d, Direction:%s\n", mute,
 591                 stream ? "CAPTURE":"PLAYBACK");
 592
 593         mutex_lock(&codec->lock);
 594
 595         params = find_dai_stream_params(codec, dai->id, stream);
 596         if (!params) {
 597                 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
 598                 mutex_unlock(&codec->lock);
 599                 return -EINVAL;
 600         }
 601
 602         if (list_empty(&codec->module_list)) {
 603                 dev_err(codec->dev, "No codec module available\n");
 604                 if (mute) {
 605                         params->state = GBAUDIO_CODEC_STOP;
 606                         ret = 0;
 607                 } else {
 608                         ret = -ENODEV;
 609                 }
 610                 mutex_unlock(&codec->lock);
 611                 return ret;
 612         }
 613
 614         list_for_each_entry(module, &codec->module_list, list) {
 615                 /* find the dai */
 616                 data = find_data(module, dai->id);
 617                 if (data)
 618                         break;
 619         }
 620         if (!data) {
 621                 dev_err(dai->dev, "%s DATA connection missing\n",
 622                         dai->name);
 623                 mutex_unlock(&codec->lock);
 624                 return -ENODEV;
 625         }
 626
 627         bundle = to_gb_bundle(module->dev);
 628         ret = gb_pm_runtime_get_sync(bundle);
 629         if (ret) {
 630                 mutex_unlock(&codec->lock);
 631                 return ret;
 632         }
 633
 634         if (!mute && !stream) {/* start playback */
 635                 ret = gb_audio_apbridgea_prepare_tx(data->connection,
 636                                                     0);
 637                 if (!ret)
 638                         ret = gb_audio_apbridgea_start_tx(data->connection,
 639                                                           0, 0);
 640                 params->state = GBAUDIO_CODEC_START;
 641         } else if (!mute && stream) {/* start capture */
 642                 ret = gb_audio_apbridgea_prepare_rx(data->connection,
 643                                                     0);
 644                 if (!ret)
 645                         ret = gb_audio_apbridgea_start_rx(data->connection,
 646                                                           0);
 647                 params->state = GBAUDIO_CODEC_START;
 648         } else if (mute && !stream) {/* stop playback */
 649                 ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
 650                 if (!ret)
 651                         ret = gb_audio_apbridgea_shutdown_tx(data->connection,
 652                                                              0);
 653                 params->state = GBAUDIO_CODEC_STOP;
 654         } else if (mute && stream) {/* stop capture */
 655                 ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
 656                 if (!ret)
 657                         ret = gb_audio_apbridgea_shutdown_rx(data->connection,
 658                                                              0);
 659                 params->state = GBAUDIO_CODEC_STOP;
 660         } else
 661                 ret = -EINVAL;
 662         if (ret)
 663                 dev_err_ratelimited(dai->dev,
 664                                     "%s:Error during %s %s stream:%d\n",
 665                                     module->name, mute ? "Mute" : "Unmute",
 666                                     stream ? "Capture" : "Playback", ret);
 667
 668         gb_pm_runtime_put_noidle(bundle);
 669         mutex_unlock(&codec->lock);
 670         return ret;
 671 }
 672
 673 static struct snd_soc_dai_ops gbcodec_dai_ops = {
 674         .startup = gbcodec_startup,
 675         .shutdown = gbcodec_shutdown,
 676         .hw_params = gbcodec_hw_params,
 677         .prepare = gbcodec_prepare,
 678         .mute_stream = gbcodec_mute_stream,
 679 };
 680
 681 static struct snd_soc_dai_driver gbaudio_dai[] = {
 682         {
 683                 .name = "apb-i2s0",
 684                 .id = 0,
 685                 .playback = {
 686                         .stream_name = "I2S 0 Playback",
 687                         .rates = SNDRV_PCM_RATE_48000,
 688                         .formats = SNDRV_PCM_FORMAT_S16_LE,
 689                         .rate_max = 48000,
 690                         .rate_min = 48000,
 691                         .channels_min = 1,
 692                         .channels_max = 2,
 693                 },
 694                 .capture = {
 695                         .stream_name = "I2S 0 Capture",
 696                         .rates = SNDRV_PCM_RATE_48000,
 697                         .formats = SNDRV_PCM_FORMAT_S16_LE,
 698                         .rate_max = 48000,
 699                         .rate_min = 48000,
 700                         .channels_min = 1,
 701                         .channels_max = 2,
 702                 },
 703                 .ops = &gbcodec_dai_ops,
 704         },
 705 };
 706
 707 static int gbaudio_init_jack(struct gbaudio_module_info *module,
 708                              struct snd_soc_codec *codec)
 709 {
 710         int ret;
 711
 712         if (!module->jack_mask)
 713                 return 0;
 714
 715         snprintf(module->jack_name, NAME_SIZE, "GB %d Headset Jack",
 716                  module->dev_id);
 717         ret = snd_soc_jack_new(codec, module->jack_name, module->jack_mask,
 718                                &module->headset_jack);
 719         if (ret) {
 720                 dev_err(module->dev, "Failed to create new jack\n");
 721                 return ret;
 722         }
 723
 724         if (!module->button_mask)
 725                 return 0;
 726
 727         snprintf(module->button_name, NAME_SIZE, "GB %d Button Jack",
 728                  module->dev_id);
 729         ret = snd_soc_jack_new(codec, module->button_name, module->button_mask,
 730                                &module->button_jack);
 731         if (ret) {
 732                 dev_err(module->dev, "Failed to create button jack\n");
 733                 return ret;
 734         }
 735
 736         /*
 737          * Currently, max 4 buttons are supported with following key mapping
 738          * BTN_0 = KEY_MEDIA
 739          * BTN_1 = KEY_VOICECOMMAND
 740          * BTN_2 = KEY_VOLUMEUP
 741          * BTN_3 = KEY_VOLUMEDOWN
 742          */
 743
 744         if (module->button_mask & SND_JACK_BTN_0) {
 745                 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_0,
 746                                        KEY_MEDIA);
 747                 if (ret) {
 748                         dev_err(module->dev, "Failed to set BTN_0\n");
 749                         return ret;
 750                 }
 751         }
 752
 753         if (module->button_mask & SND_JACK_BTN_1) {
 754                 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_1,
 755                                        KEY_VOICECOMMAND);
 756                 if (ret) {
 757                         dev_err(module->dev, "Failed to set BTN_1\n");
 758                         return ret;
 759                 }
 760         }
 761
 762         if (module->button_mask & SND_JACK_BTN_2) {
 763                 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_2,
 764                                        KEY_VOLUMEUP);
 765                 if (ret) {
 766                         dev_err(module->dev, "Failed to set BTN_2\n");
 767                         return ret;
 768                 }
 769         }
 770
 771         if (module->button_mask & SND_JACK_BTN_3) {
 772                 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_3,
 773                                        KEY_VOLUMEDOWN);
 774                 if (ret) {
 775                         dev_err(module->dev, "Failed to set BTN_0\n");
 776                         return ret;
 777                 }
 778         }
 779
 780         /* FIXME
 781          * verify if this is really required
 782         set_bit(INPUT_PROP_NO_DUMMY_RELEASE,
 783                 module->button_jack.jack->input_dev->propbit);
 784         */
 785
 786         return 0;
 787 }
 788
 789 int gbaudio_register_module(struct gbaudio_module_info *module)
 790 {
 791         int ret;
 792         struct snd_soc_codec *codec;
 793         struct snd_card *card;
 794         struct snd_soc_jack *jack = NULL;
 795
 796         if (!gbcodec) {
 797                 dev_err(module->dev, "GB Codec not yet probed\n");
 798                 return -EAGAIN;
 799         }
 800
 801         codec = gbcodec->codec;
 802         card = codec->card->snd_card;
 803
 804         down_write(&card->controls_rwsem);
 805
 806         if (module->num_dais) {
 807                 dev_err(gbcodec->dev,
 808                         "%d:DAIs not supported via gbcodec driver\n",
 809                         module->num_dais);
 810                 up_write(&card->controls_rwsem);
 811                 return -EINVAL;
 812         }
 813
 814         ret = gbaudio_init_jack(module, codec);
 815         if (ret) {
 816                 up_write(&card->controls_rwsem);
 817                 return ret;
 818         }
 819
 820         if (module->dapm_widgets)
 821                 snd_soc_dapm_new_controls(&codec->dapm, module->dapm_widgets,
 822                                           module->num_dapm_widgets);
 823         if (module->controls)
 824                 snd_soc_add_codec_controls(codec, module->controls,
 825                                      module->num_controls);
 826         if (module->dapm_routes)
 827                 snd_soc_dapm_add_routes(&codec->dapm, module->dapm_routes,
 828                                         module->num_dapm_routes);
 829
 830         /* card already instantiated, create widgets here only */
 831         if (codec->card->instantiated) {
 832                 snd_soc_dapm_link_component_dai_widgets(codec->card,
 833                                                         &codec->dapm);
 834 #ifdef CONFIG_SND_JACK
 835                 /* register jack devices for this module from codec->jack_list */
 836                 list_for_each_entry(jack, &codec->jack_list, list) {
 837                         if ((jack == &module->headset_jack)
 838                             || (jack == &module->button_jack))
 839                                 snd_device_register(codec->card->snd_card,
 840                                                     jack->jack);
 841                 }
 842 #endif
 843         }
 844
 845         mutex_lock(&gbcodec->lock);
 846         list_add(&module->list, &gbcodec->module_list);
 847         mutex_unlock(&gbcodec->lock);
 848
 849         if (codec->card->instantiated)
 850                 ret = snd_soc_dapm_new_widgets(&codec->dapm);
 851         dev_dbg(codec->dev, "Registered %s module\n", module->name);
 852
 853         up_write(&card->controls_rwsem);
 854         return ret;
 855 }
 856 EXPORT_SYMBOL(gbaudio_register_module);
 857
 858 static void gbaudio_codec_clean_data_tx(struct gbaudio_data_connection *data)
 859 {
 860         u16 i2s_port, cportid;
 861         int ret;
 862
 863         if (list_is_singular(&gbcodec->module_list)) {
 864                 ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
 865                 if (ret)
 866                         return;
 867                 ret = gb_audio_apbridgea_shutdown_tx(data->connection,
 868                                                      0);
 869                 if (ret)
 870                         return;
 871         }
 872         i2s_port = 0;   /* fixed for now */
 873         cportid = data->connection->hd_cport_id;
 874         ret = gb_audio_apbridgea_unregister_cport(data->connection,
 875                                                   i2s_port, cportid,
 876                                                   AUDIO_APBRIDGEA_DIRECTION_TX);
 877         data->state[0] = GBAUDIO_CODEC_SHUTDOWN;
 878 }
 879
 880 static void gbaudio_codec_clean_data_rx(struct gbaudio_data_connection *data)
 881 {
 882         u16 i2s_port, cportid;
 883         int ret;
 884
 885         if (list_is_singular(&gbcodec->module_list)) {
 886                 ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
 887                 if (ret)
 888                         return;
 889                 ret = gb_audio_apbridgea_shutdown_rx(data->connection,
 890                                                      0);
 891                 if (ret)
 892                         return;
 893         }
 894         i2s_port = 0;   /* fixed for now */
 895         cportid = data->connection->hd_cport_id;
 896         ret = gb_audio_apbridgea_unregister_cport(data->connection,
 897                                                   i2s_port, cportid,
 898                                                   AUDIO_APBRIDGEA_DIRECTION_RX);
 899         data->state[1] = GBAUDIO_CODEC_SHUTDOWN;
 900 }
 901
 902
 903 static void gbaudio_codec_cleanup(struct gbaudio_module_info *module)
 904 {
 905         struct gbaudio_data_connection *data;
 906         int pb_state, cap_state;
 907
 908         dev_dbg(gbcodec->dev, "%s: removed, cleanup APBridge\n", module->name);
 909         list_for_each_entry(data, &module->data_list, list) {
 910                 pb_state = data->state[0];
 911                 cap_state = data->state[1];
 912
 913                 if (pb_state > GBAUDIO_CODEC_SHUTDOWN)
 914                         gbaudio_codec_clean_data_tx(data);
 915
 916                 if (cap_state > GBAUDIO_CODEC_SHUTDOWN)
 917                         gbaudio_codec_clean_data_rx(data);
 918
 919         }
 920 }
 921
 922 void gbaudio_unregister_module(struct gbaudio_module_info *module)
 923 {
 924         struct snd_soc_codec *codec = gbcodec->codec;
 925         struct snd_card *card = codec->card->snd_card;
 926         struct snd_soc_jack *jack, *next_j;
 927         int mask;
 928
 929         dev_dbg(codec->dev, "Unregister %s module\n", module->name);
 930
 931         down_write(&card->controls_rwsem);
 932         mutex_lock(&gbcodec->lock);
 933         gbaudio_codec_cleanup(module);
 934         list_del(&module->list);
 935         dev_dbg(codec->dev, "Process Unregister %s module\n", module->name);
 936         mutex_unlock(&gbcodec->lock);
 937
 938 #ifdef CONFIG_SND_JACK
 939         /* free jack devices for this module from codec->jack_list */
 940         list_for_each_entry_safe(jack, next_j, &codec->jack_list, list) {
 941                 if (jack == &module->headset_jack)
 942                         mask = GBCODEC_JACK_MASK;
 943                 else if (jack == &module->button_jack)
 944                         mask = GBCODEC_JACK_BUTTON_MASK;
 945                 else
 946                         mask = 0;
 947                 if (mask) {
 948                         dev_dbg(module->dev, "Report %s removal\n",
 949                                 jack->jack->id);
 950                         snd_soc_jack_report(jack, 0, mask);
 951                         snd_device_free(codec->card->snd_card, jack->jack);
 952                         list_del(&jack->list);
 953                 }
 954         }
 955 #endif
 956
 957         if (module->dapm_routes) {
 958                 dev_dbg(codec->dev, "Removing %d routes\n",
 959                         module->num_dapm_routes);
 960                 snd_soc_dapm_del_routes(&codec->dapm, module->dapm_routes,
 961                                         module->num_dapm_routes);
 962         }
 963         if (module->controls) {
 964                 dev_dbg(codec->dev, "Removing %d controls\n",
 965                         module->num_controls);
 966                 snd_soc_remove_codec_controls(codec, module->controls,
 967                                           module->num_controls);
 968         }
 969         if (module->dapm_widgets) {
 970                 dev_dbg(codec->dev, "Removing %d widgets\n",
 971                         module->num_dapm_widgets);
 972                 snd_soc_dapm_free_controls(&codec->dapm, module->dapm_widgets,
 973                                            module->num_dapm_widgets);
 974         }
 975
 976         dev_dbg(codec->dev, "Unregistered %s module\n", module->name);
 977
 978         up_write(&card->controls_rwsem);
 979 }
 980 EXPORT_SYMBOL(gbaudio_unregister_module);
 981
 982 /*
 983  * codec driver ops
 984  */
 985 static int gbcodec_probe(struct snd_soc_codec *codec)
 986 {
 987         int i;
 988         struct gbaudio_codec_info *info;
 989         struct gbaudio_codec_dai *dai;
 990
 991         info = devm_kzalloc(codec->dev, sizeof(*info), GFP_KERNEL);
 992         if (!info)
 993                 return -ENOMEM;
 994
 995         info->dev = codec->dev;
 996         INIT_LIST_HEAD(&info->module_list);
 997         mutex_init(&info->lock);
 998         INIT_LIST_HEAD(&info->dai_list);
 999
1000         /* init dai_list used to maintain runtime stream info */
1001         for (i = 0; i < ARRAY_SIZE(gbaudio_dai); i++) {
1002                 dai = devm_kzalloc(codec->dev, sizeof(*dai), GFP_KERNEL);
1003                 if (!dai)
1004                         return -ENOMEM;
1005                 dai->id = gbaudio_dai[i].id;
1006                 list_add(&dai->list, &info->dai_list);
1007         }
1008
1009         info->codec = codec;
1010         snd_soc_codec_set_drvdata(codec, info);
1011         gbcodec = info;
1012
1013         device_init_wakeup(codec->dev, 1);
1014         return 0;
1015 }
1016
1017 static int gbcodec_remove(struct snd_soc_codec *codec)
1018 {
1019         /* Empty function for now */
1020         return 0;
1021 }
1022
1023 static u8 gbcodec_reg[GBCODEC_REG_COUNT] = {
1024         [GBCODEC_CTL_REG] = GBCODEC_CTL_REG_DEFAULT,
1025         [GBCODEC_MUTE_REG] = GBCODEC_MUTE_REG_DEFAULT,
1026         [GBCODEC_PB_LVOL_REG] = GBCODEC_PB_VOL_REG_DEFAULT,
1027         [GBCODEC_PB_RVOL_REG] = GBCODEC_PB_VOL_REG_DEFAULT,
1028         [GBCODEC_CAP_LVOL_REG] = GBCODEC_CAP_VOL_REG_DEFAULT,
1029         [GBCODEC_CAP_RVOL_REG] = GBCODEC_CAP_VOL_REG_DEFAULT,
1030         [GBCODEC_APB1_MUX_REG] = GBCODEC_APB1_MUX_REG_DEFAULT,
1031         [GBCODEC_APB2_MUX_REG] = GBCODEC_APB2_MUX_REG_DEFAULT,
1032 };
1033
1034 static int gbcodec_write(struct snd_soc_codec *codec, unsigned int reg,
1035                          unsigned int value)
1036 {
1037         int ret = 0;
1038
1039         if (reg == SND_SOC_NOPM)
1040                 return 0;
1041
1042         BUG_ON(reg >= GBCODEC_REG_COUNT);
1043
1044         gbcodec_reg[reg] = value;
1045         dev_dbg(codec->dev, "reg[%d] = 0x%x\n", reg, value);
1046
1047         return ret;
1048 }
1049
1050 static unsigned int gbcodec_read(struct snd_soc_codec *codec,
1051                                  unsigned int reg)
1052 {
1053         unsigned int val = 0;
1054
1055         if (reg == SND_SOC_NOPM)
1056                 return 0;
1057
1058         BUG_ON(reg >= GBCODEC_REG_COUNT);
1059
1060         val = gbcodec_reg[reg];
1061         dev_dbg(codec->dev, "reg[%d] = 0x%x\n", reg, val);
1062
1063         return val;
1064 }
1065
1066 static struct snd_soc_codec_driver soc_codec_dev_gbaudio = {
1067         .probe  = gbcodec_probe,
1068         .remove = gbcodec_remove,
1069
1070         .read = gbcodec_read,
1071         .write = gbcodec_write,
1072
1073         .reg_cache_size = GBCODEC_REG_COUNT,
1074         .reg_cache_default = gbcodec_reg_defaults,
1075         .reg_word_size = 1,
1076
1077         .idle_bias_off = true,
1078         .ignore_pmdown_time = 1,
1079 };
1080
1081 #ifdef CONFIG_PM
1082 static int gbaudio_codec_suspend(struct device *dev)
1083 {
1084         dev_dbg(dev, "%s: suspend\n", __func__);
1085         return 0;
1086 }
1087
1088 static int gbaudio_codec_resume(struct device *dev)
1089 {
1090         dev_dbg(dev, "%s: resume\n", __func__);
1091         return 0;
1092 }
1093
1094 static const struct dev_pm_ops gbaudio_codec_pm_ops = {
1095         .suspend        = gbaudio_codec_suspend,
1096         .resume         = gbaudio_codec_resume,
1097 };
1098 #endif
1099
1100 static int gbaudio_codec_probe(struct platform_device *pdev)
1101 {
1102         return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_gbaudio,
1103                         gbaudio_dai, ARRAY_SIZE(gbaudio_dai));
1104 }
1105
1106 static int gbaudio_codec_remove(struct platform_device *pdev)
1107 {
1108         snd_soc_unregister_codec(&pdev->dev);
1109         return 0;
1110 }
1111
1112 static const struct of_device_id greybus_asoc_machine_of_match[]  = {
1113         { .compatible = "toshiba,apb-dummy-codec", },
1114         {},
1115 };
1116
1117 static struct platform_driver gbaudio_codec_driver = {
1118         .driver = {
1119                 .name = "apb-dummy-codec",
1120                 .owner = THIS_MODULE,
1121 #ifdef CONFIG_PM
1122                 .pm = &gbaudio_codec_pm_ops,
1123 #endif
1124                 .of_match_table = greybus_asoc_machine_of_match,
1125         },
1126         .probe = gbaudio_codec_probe,
1127         .remove = gbaudio_codec_remove,
1128 };
1129 module_platform_driver(gbaudio_codec_driver);
1130
1131 MODULE_DESCRIPTION("APBridge ALSA SoC dummy codec driver");
1132 MODULE_AUTHOR("Vaibhav Agarwal <vaibhav.agarwal@linaro.org>");
1133 MODULE_LICENSE("GPL v2");
1134 MODULE_ALIAS("platform:apb-dummy-codec");