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