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