drivers/staging/greybus/audio_codec.c

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