sound/soc/soc-compress.c

   1 /*
   2  * soc-compress.c  --  ALSA SoC Compress
   3  *
   4  * Copyright (C) 2012 Intel Corp.
   5  *
   6  * Authors: Namarta Kohli <namartax.kohli@intel.com>
   7  *          Ramesh Babu K V <ramesh.babu@linux.intel.com>
   8  *          Vinod Koul <vinod.koul@linux.intel.com>
   9  *
  10  *  This program is free software; you can redistribute  it and/or modify it
  11  *  under  the terms of  the GNU General  Public License as published by the
  12  *  Free Software Foundation;  either version 2 of the  License, or (at your
  13  *  option) any later version.
  14  *
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/init.h>
  19 #include <linux/delay.h>
  20 #include <linux/slab.h>
  21 #include <linux/workqueue.h>
  22 #include <sound/core.h>
  23 #include <sound/compress_params.h>
  24 #include <sound/compress_driver.h>
  25 #include <sound/soc.h>
  26 #include <sound/initval.h>
  27 #include <sound/soc-dpcm.h>
  28
  29 static int soc_compr_open(struct snd_compr_stream *cstream)
  30 {
  31         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
  32         struct snd_soc_platform *platform = rtd->platform;
  33         struct snd_soc_component *component;
  34         struct snd_soc_rtdcom_list *rtdcom;
  35         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
  36         int ret = 0, __ret;
  37
  38         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
  39
  40         if (cpu_dai->driver->cops && cpu_dai->driver->cops->startup) {
  41                 ret = cpu_dai->driver->cops->startup(cstream, cpu_dai);
  42                 if (ret < 0) {
  43                         dev_err(cpu_dai->dev, "Compress ASoC: can't open interface %s: %d\n",
  44                                 cpu_dai->name, ret);
  45                         goto out;
  46                 }
  47         }
  48
  49         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) {
  50                 ret = platform->driver->compr_ops->open(cstream);
  51                 if (ret < 0) {
  52                         pr_err("compress asoc: can't open platform %s\n",
  53                                 platform->component.name);
  54                         goto plat_err;
  55                 }
  56         }
  57
  58         for_each_rtdcom(rtd, rtdcom) {
  59                 component = rtdcom->component;
  60
  61                 /* ignore duplication for now */
  62                 if (platform && (component == &platform->component))
  63                         continue;
  64
  65                 if (!component->driver->compr_ops ||
  66                     !component->driver->compr_ops->open)
  67                         continue;
  68
  69                 __ret = component->driver->compr_ops->open(cstream);
  70                 if (__ret < 0) {
  71                         pr_err("compress asoc: can't open platform %s\n",
  72                                component->name);
  73                         ret = __ret;
  74                 }
  75         }
  76         if (ret < 0)
  77                 goto machine_err;
  78
  79         if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->startup) {
  80                 ret = rtd->dai_link->compr_ops->startup(cstream);
  81                 if (ret < 0) {
  82                         pr_err("compress asoc: %s startup failed\n", rtd->dai_link->name);
  83                         goto machine_err;
  84                 }
  85         }
  86
  87         snd_soc_runtime_activate(rtd, cstream->direction);
  88
  89         mutex_unlock(&rtd->pcm_mutex);
  90
  91         return 0;
  92
  93 machine_err:
  94         for_each_rtdcom(rtd, rtdcom) {
  95                 component = rtdcom->component;
  96
  97                 /* ignore duplication for now */
  98                 if (platform && (component == &platform->component))
  99                         continue;
 100
 101                 if (!component->driver->compr_ops ||
 102                     !component->driver->compr_ops->free)
 103                         continue;
 104
 105                 component->driver->compr_ops->free(cstream);
 106         }
 107
 108         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
 109                 platform->driver->compr_ops->free(cstream);
 110 plat_err:
 111         if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
 112                 cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
 113 out:
 114         mutex_unlock(&rtd->pcm_mutex);
 115         return ret;
 116 }
 117
 118 static int soc_compr_open_fe(struct snd_compr_stream *cstream)
 119 {
 120         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 121         struct snd_pcm_substream *fe_substream =
 122                  fe->pcm->streams[cstream->direction].substream;
 123         struct snd_soc_platform *platform = fe->platform;
 124         struct snd_soc_component *component;
 125         struct snd_soc_rtdcom_list *rtdcom;
 126         struct snd_soc_dai *cpu_dai = fe->cpu_dai;
 127         struct snd_soc_dpcm *dpcm;
 128         struct snd_soc_dapm_widget_list *list;
 129         int stream;
 130         int ret = 0, __ret;
 131
 132         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 133                 stream = SNDRV_PCM_STREAM_PLAYBACK;
 134         else
 135                 stream = SNDRV_PCM_STREAM_CAPTURE;
 136
 137         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 138
 139         if (cpu_dai->driver->cops && cpu_dai->driver->cops->startup) {
 140                 ret = cpu_dai->driver->cops->startup(cstream, cpu_dai);
 141                 if (ret < 0) {
 142                         dev_err(cpu_dai->dev, "Compress ASoC: can't open interface %s: %d\n",
 143                                 cpu_dai->name, ret);
 144                         goto out;
 145                 }
 146         }
 147
 148
 149         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) {
 150                 ret = platform->driver->compr_ops->open(cstream);
 151                 if (ret < 0) {
 152                         pr_err("compress asoc: can't open platform %s\n",
 153                                 platform->component.name);
 154                         goto plat_err;
 155                 }
 156         }
 157
 158         for_each_rtdcom(fe, rtdcom) {
 159                 component = rtdcom->component;
 160
 161                 /* ignore duplication for now */
 162                 if (platform && (component == &platform->component))
 163                         continue;
 164
 165                 if (!component->driver->compr_ops ||
 166                     !component->driver->compr_ops->open)
 167                         continue;
 168
 169                 __ret = component->driver->compr_ops->open(cstream);
 170                 if (__ret < 0) {
 171                         pr_err("compress asoc: can't open platform %s\n",
 172                                component->name);
 173                         ret = __ret;
 174                 }
 175         }
 176         if (ret < 0)
 177                 goto machine_err;
 178
 179         if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->startup) {
 180                 ret = fe->dai_link->compr_ops->startup(cstream);
 181                 if (ret < 0) {
 182                         pr_err("compress asoc: %s startup failed\n", fe->dai_link->name);
 183                         goto machine_err;
 184                 }
 185         }
 186
 187         fe->dpcm[stream].runtime = fe_substream->runtime;
 188
 189         ret = dpcm_path_get(fe, stream, &list);
 190         if (ret < 0)
 191                 goto fe_err;
 192         else if (ret == 0)
 193                 dev_dbg(fe->dev, "ASoC: %s no valid %s route\n",
 194                         fe->dai_link->name, stream ? "capture" : "playback");
 195
 196         /* calculate valid and active FE <-> BE dpcms */
 197         dpcm_process_paths(fe, stream, &list, 1);
 198
 199         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 200
 201         ret = dpcm_be_dai_startup(fe, stream);
 202         if (ret < 0) {
 203                 /* clean up all links */
 204                 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
 205                         dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
 206
 207                 dpcm_be_disconnect(fe, stream);
 208                 fe->dpcm[stream].runtime = NULL;
 209                 goto path_err;
 210         }
 211
 212         dpcm_clear_pending_state(fe, stream);
 213         dpcm_path_put(&list);
 214
 215         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
 216         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 217
 218         snd_soc_runtime_activate(fe, stream);
 219
 220         mutex_unlock(&fe->card->mutex);
 221
 222         return 0;
 223
 224 path_err:
 225         dpcm_path_put(&list);
 226 fe_err:
 227         if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
 228                 fe->dai_link->compr_ops->shutdown(cstream);
 229 machine_err:
 230         for_each_rtdcom(fe, rtdcom) {
 231                 component = rtdcom->component;
 232
 233                 /* ignore duplication for now */
 234                 if (platform && (component == &platform->component))
 235                         continue;
 236
 237                 if (!component->driver->compr_ops ||
 238                     !component->driver->compr_ops->free)
 239                         continue;
 240
 241                 component->driver->compr_ops->free(cstream);
 242         }
 243
 244         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
 245                 platform->driver->compr_ops->free(cstream);
 246 plat_err:
 247         if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
 248                 cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
 249 out:
 250         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 251         mutex_unlock(&fe->card->mutex);
 252         return ret;
 253 }
 254
 255 /*
 256  * Power down the audio subsystem pmdown_time msecs after close is called.
 257  * This is to ensure there are no pops or clicks in between any music tracks
 258  * due to DAPM power cycling.
 259  */
 260 static void close_delayed_work(struct work_struct *work)
 261 {
 262         struct snd_soc_pcm_runtime *rtd =
 263                         container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
 264         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 265
 266         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 267
 268         dev_dbg(rtd->dev, "ASoC: pop wq checking: %s status: %s waiting: %s\n",
 269                  codec_dai->driver->playback.stream_name,
 270                  codec_dai->playback_active ? "active" : "inactive",
 271                  rtd->pop_wait ? "yes" : "no");
 272
 273         /* are we waiting on this codec DAI stream */
 274         if (rtd->pop_wait == 1) {
 275                 rtd->pop_wait = 0;
 276                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
 277                                           SND_SOC_DAPM_STREAM_STOP);
 278         }
 279
 280         mutex_unlock(&rtd->pcm_mutex);
 281 }
 282
 283 static int soc_compr_free(struct snd_compr_stream *cstream)
 284 {
 285         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 286         struct snd_soc_platform *platform = rtd->platform;
 287         struct snd_soc_component *component;
 288         struct snd_soc_rtdcom_list *rtdcom;
 289         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 290         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 291         int stream;
 292
 293         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 294
 295         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 296                 stream = SNDRV_PCM_STREAM_PLAYBACK;
 297         else
 298                 stream = SNDRV_PCM_STREAM_CAPTURE;
 299
 300         snd_soc_runtime_deactivate(rtd, stream);
 301
 302         snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
 303
 304         if (!cpu_dai->active)
 305                 cpu_dai->rate = 0;
 306
 307         if (!codec_dai->active)
 308                 codec_dai->rate = 0;
 309
 310
 311         if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown)
 312                 rtd->dai_link->compr_ops->shutdown(cstream);
 313
 314         for_each_rtdcom(rtd, rtdcom) {
 315                 component = rtdcom->component;
 316
 317                 /* ignore duplication for now */
 318                 if (platform && (component == &platform->component))
 319                         continue;
 320
 321                 if (!component->driver->compr_ops ||
 322                     !component->driver->compr_ops->free)
 323                         continue;
 324
 325                 component->driver->compr_ops->free(cstream);
 326         }
 327
 328         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
 329                 platform->driver->compr_ops->free(cstream);
 330
 331         if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
 332                 cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
 333
 334         if (cstream->direction == SND_COMPRESS_PLAYBACK) {
 335                 if (snd_soc_runtime_ignore_pmdown_time(rtd)) {
 336                         snd_soc_dapm_stream_event(rtd,
 337                                         SNDRV_PCM_STREAM_PLAYBACK,
 338                                         SND_SOC_DAPM_STREAM_STOP);
 339                 } else {
 340                         rtd->pop_wait = 1;
 341                         queue_delayed_work(system_power_efficient_wq,
 342                                            &rtd->delayed_work,
 343                                            msecs_to_jiffies(rtd->pmdown_time));
 344                 }
 345         } else {
 346                 /* capture streams can be powered down now */
 347                 snd_soc_dapm_stream_event(rtd,
 348                         SNDRV_PCM_STREAM_CAPTURE,
 349                         SND_SOC_DAPM_STREAM_STOP);
 350         }
 351
 352         mutex_unlock(&rtd->pcm_mutex);
 353         return 0;
 354 }
 355
 356 static int soc_compr_free_fe(struct snd_compr_stream *cstream)
 357 {
 358         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 359         struct snd_soc_platform *platform = fe->platform;
 360         struct snd_soc_component *component;
 361         struct snd_soc_rtdcom_list *rtdcom;
 362         struct snd_soc_dai *cpu_dai = fe->cpu_dai;
 363         struct snd_soc_dpcm *dpcm;
 364         int stream, ret;
 365
 366         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 367
 368         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 369                 stream = SNDRV_PCM_STREAM_PLAYBACK;
 370         else
 371                 stream = SNDRV_PCM_STREAM_CAPTURE;
 372
 373         snd_soc_runtime_deactivate(fe, stream);
 374
 375         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 376
 377         ret = dpcm_be_dai_hw_free(fe, stream);
 378         if (ret < 0)
 379                 dev_err(fe->dev, "compressed hw_free failed %d\n", ret);
 380
 381         ret = dpcm_be_dai_shutdown(fe, stream);
 382
 383         /* mark FE's links ready to prune */
 384         list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
 385                 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
 386
 387         dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
 388
 389         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
 390         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 391
 392         dpcm_be_disconnect(fe, stream);
 393
 394         fe->dpcm[stream].runtime = NULL;
 395
 396         if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
 397                 fe->dai_link->compr_ops->shutdown(cstream);
 398
 399         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
 400                 platform->driver->compr_ops->free(cstream);
 401
 402         for_each_rtdcom(fe, rtdcom) {
 403                 component = rtdcom->component;
 404
 405                 /* ignore duplication for now */
 406                 if (platform && (component == &platform->component))
 407                         continue;
 408
 409                 if (!component->driver->compr_ops ||
 410                     !component->driver->compr_ops->free)
 411                         continue;
 412
 413                 component->driver->compr_ops->free(cstream);
 414         }
 415
 416         if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
 417                 cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
 418
 419         mutex_unlock(&fe->card->mutex);
 420         return 0;
 421 }
 422
 423 static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)
 424 {
 425
 426         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 427         struct snd_soc_platform *platform = rtd->platform;
 428         struct snd_soc_component *component;
 429         struct snd_soc_rtdcom_list *rtdcom;
 430         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 431         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 432         int ret = 0, __ret;
 433
 434         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 435
 436         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
 437                 ret = platform->driver->compr_ops->trigger(cstream, cmd);
 438                 if (ret < 0)
 439                         goto out;
 440         }
 441
 442         for_each_rtdcom(rtd, rtdcom) {
 443                 component = rtdcom->component;
 444
 445                 /* ignore duplication for now */
 446                 if (platform && (component == &platform->component))
 447                         continue;
 448
 449                 if (!component->driver->compr_ops ||
 450                     !component->driver->compr_ops->trigger)
 451                         continue;
 452
 453                 __ret = component->driver->compr_ops->trigger(cstream, cmd);
 454                 if (__ret < 0)
 455                         ret = __ret;
 456         }
 457         if (ret < 0)
 458                 goto out;
 459
 460         if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger)
 461                 cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai);
 462
 463
 464         switch (cmd) {
 465         case SNDRV_PCM_TRIGGER_START:
 466                 snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction);
 467                 break;
 468         case SNDRV_PCM_TRIGGER_STOP:
 469                 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
 470                 break;
 471         }
 472
 473 out:
 474         mutex_unlock(&rtd->pcm_mutex);
 475         return ret;
 476 }
 477
 478 static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)
 479 {
 480         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 481         struct snd_soc_platform *platform = fe->platform;
 482         struct snd_soc_component *component;
 483         struct snd_soc_rtdcom_list *rtdcom;
 484         struct snd_soc_dai *cpu_dai = fe->cpu_dai;
 485         int ret = 0, __ret, stream;
 486
 487         if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN ||
 488                 cmd == SND_COMPR_TRIGGER_DRAIN) {
 489
 490                 if (platform &&
 491                     platform->driver->compr_ops &&
 492                     platform->driver->compr_ops->trigger)
 493                         return platform->driver->compr_ops->trigger(cstream,
 494                                                                     cmd);
 495
 496                 for_each_rtdcom(fe, rtdcom) {
 497                         component = rtdcom->component;
 498
 499                         /* ignore duplication for now */
 500                         if (platform && (component == &platform->component))
 501                                 continue;
 502
 503                         if (!component->driver->compr_ops ||
 504                             !component->driver->compr_ops->trigger)
 505                                 continue;
 506
 507                         __ret = component->driver->compr_ops->trigger(cstream, cmd);
 508                         if (__ret < 0)
 509                                 ret = __ret;
 510                 }
 511                 return ret;
 512         }
 513
 514         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 515                 stream = SNDRV_PCM_STREAM_PLAYBACK;
 516         else
 517                 stream = SNDRV_PCM_STREAM_CAPTURE;
 518
 519
 520         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 521
 522         if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger) {
 523                 ret = cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai);
 524                 if (ret < 0)
 525                         goto out;
 526         }
 527
 528         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
 529                 ret = platform->driver->compr_ops->trigger(cstream, cmd);
 530                 if (ret < 0)
 531                         goto out;
 532         }
 533
 534         for_each_rtdcom(fe, rtdcom) {
 535                 component = rtdcom->component;
 536
 537                 /* ignore duplication for now */
 538                 if (platform && (component == &platform->component))
 539                         continue;
 540
 541                 if (!component->driver->compr_ops ||
 542                     !component->driver->compr_ops->trigger)
 543                         continue;
 544
 545                 __ret = component->driver->compr_ops->trigger(cstream, cmd);
 546                 if (__ret < 0)
 547                         ret = __ret;
 548         }
 549         if (ret < 0)
 550                 goto out;
 551
 552         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 553
 554         ret = dpcm_be_dai_trigger(fe, stream, cmd);
 555
 556         switch (cmd) {
 557         case SNDRV_PCM_TRIGGER_START:
 558         case SNDRV_PCM_TRIGGER_RESUME:
 559         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 560                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
 561                 break;
 562         case SNDRV_PCM_TRIGGER_STOP:
 563         case SNDRV_PCM_TRIGGER_SUSPEND:
 564                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
 565                 break;
 566         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 567                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
 568                 break;
 569         }
 570
 571 out:
 572         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 573         mutex_unlock(&fe->card->mutex);
 574         return ret;
 575 }
 576
 577 static int soc_compr_set_params(struct snd_compr_stream *cstream,
 578                                         struct snd_compr_params *params)
 579 {
 580         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 581         struct snd_soc_platform *platform = rtd->platform;
 582         struct snd_soc_component *component;
 583         struct snd_soc_rtdcom_list *rtdcom;
 584         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 585         int ret = 0, __ret;
 586
 587         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 588
 589         /* first we call set_params for the platform driver
 590          * this should configure the soc side
 591          * if the machine has compressed ops then we call that as well
 592          * expectation is that platform and machine will configure everything
 593          * for this compress path, like configuring pcm port for codec
 594          */
 595         if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_params) {
 596                 ret = cpu_dai->driver->cops->set_params(cstream, params, cpu_dai);
 597                 if (ret < 0)
 598                         goto err;
 599         }
 600
 601         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
 602                 ret = platform->driver->compr_ops->set_params(cstream, params);
 603                 if (ret < 0)
 604                         goto err;
 605         }
 606
 607         for_each_rtdcom(rtd, rtdcom) {
 608                 component = rtdcom->component;
 609
 610                 /* ignore duplication for now */
 611                 if (platform && (component == &platform->component))
 612                         continue;
 613
 614                 if (!component->driver->compr_ops ||
 615                     !component->driver->compr_ops->set_params)
 616                         continue;
 617
 618                 __ret = component->driver->compr_ops->set_params(cstream, params);
 619                 if (__ret < 0)
 620                         ret = __ret;
 621         }
 622         if (ret < 0)
 623                 goto err;
 624
 625         if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) {
 626                 ret = rtd->dai_link->compr_ops->set_params(cstream);
 627                 if (ret < 0)
 628                         goto err;
 629         }
 630
 631         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 632                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
 633                                         SND_SOC_DAPM_STREAM_START);
 634         else
 635                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE,
 636                                         SND_SOC_DAPM_STREAM_START);
 637
 638         /* cancel any delayed stream shutdown that is pending */
 639         rtd->pop_wait = 0;
 640         mutex_unlock(&rtd->pcm_mutex);
 641
 642         cancel_delayed_work_sync(&rtd->delayed_work);
 643
 644         return ret;
 645
 646 err:
 647         mutex_unlock(&rtd->pcm_mutex);
 648         return ret;
 649 }
 650
 651 static int soc_compr_set_params_fe(struct snd_compr_stream *cstream,
 652                                         struct snd_compr_params *params)
 653 {
 654         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 655         struct snd_pcm_substream *fe_substream =
 656                  fe->pcm->streams[cstream->direction].substream;
 657         struct snd_soc_platform *platform = fe->platform;
 658         struct snd_soc_component *component;
 659         struct snd_soc_rtdcom_list *rtdcom;
 660         struct snd_soc_dai *cpu_dai = fe->cpu_dai;
 661         int ret = 0, __ret, stream;
 662
 663         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 664                 stream = SNDRV_PCM_STREAM_PLAYBACK;
 665         else
 666                 stream = SNDRV_PCM_STREAM_CAPTURE;
 667
 668         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 669
 670         if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_params) {
 671                 ret = cpu_dai->driver->cops->set_params(cstream, params, cpu_dai);
 672                 if (ret < 0)
 673                         goto out;
 674         }
 675
 676         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
 677                 ret = platform->driver->compr_ops->set_params(cstream, params);
 678                 if (ret < 0)
 679                         goto out;
 680         }
 681
 682         for_each_rtdcom(fe, rtdcom) {
 683                 component = rtdcom->component;
 684
 685                 /* ignore duplication for now */
 686                 if (platform && (component == &platform->component))
 687                         continue;
 688
 689                 if (!component->driver->compr_ops ||
 690                     !component->driver->compr_ops->set_params)
 691                         continue;
 692
 693                 __ret = component->driver->compr_ops->set_params(cstream, params);
 694                 if (__ret < 0)
 695                         ret = __ret;
 696         }
 697         if (ret < 0)
 698                 goto out;
 699
 700         if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->set_params) {
 701                 ret = fe->dai_link->compr_ops->set_params(cstream);
 702                 if (ret < 0)
 703                         goto out;
 704         }
 705
 706         /*
 707          * Create an empty hw_params for the BE as the machine driver must
 708          * fix this up to match DSP decoder and ASRC configuration.
 709          * I.e. machine driver fixup for compressed BE is mandatory.
 710          */
 711         memset(&fe->dpcm[fe_substream->stream].hw_params, 0,
 712                 sizeof(struct snd_pcm_hw_params));
 713
 714         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 715
 716         ret = dpcm_be_dai_hw_params(fe, stream);
 717         if (ret < 0)
 718                 goto out;
 719
 720         ret = dpcm_be_dai_prepare(fe, stream);
 721         if (ret < 0)
 722                 goto out;
 723
 724         dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
 725         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
 726
 727 out:
 728         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 729         mutex_unlock(&fe->card->mutex);
 730         return ret;
 731 }
 732
 733 static int soc_compr_get_params(struct snd_compr_stream *cstream,
 734                                         struct snd_codec *params)
 735 {
 736         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 737         struct snd_soc_platform *platform = rtd->platform;
 738         struct snd_soc_component *component;
 739         struct snd_soc_rtdcom_list *rtdcom;
 740         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 741         int ret = 0, __ret;
 742
 743         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 744
 745         if (cpu_dai->driver->cops && cpu_dai->driver->cops->get_params) {
 746                 ret = cpu_dai->driver->cops->get_params(cstream, params, cpu_dai);
 747                 if (ret < 0)
 748                         goto err;
 749         }
 750
 751         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_params) {
 752                 ret = platform->driver->compr_ops->get_params(cstream, params);
 753                 if (ret < 0)
 754                         goto err;
 755         }
 756
 757         for_each_rtdcom(rtd, rtdcom) {
 758                 component = rtdcom->component;
 759
 760                 /* ignore duplication for now */
 761                 if (platform && (component == &platform->component))
 762                         continue;
 763
 764                 if (!component->driver->compr_ops ||
 765                     !component->driver->compr_ops->get_params)
 766                         continue;
 767
 768                 __ret = component->driver->compr_ops->get_params(cstream, params);
 769                 if (__ret < 0)
 770                         ret = __ret;
 771         }
 772
 773 err:
 774         mutex_unlock(&rtd->pcm_mutex);
 775         return ret;
 776 }
 777
 778 static int soc_compr_get_caps(struct snd_compr_stream *cstream,
 779                                 struct snd_compr_caps *caps)
 780 {
 781         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 782         struct snd_soc_platform *platform = rtd->platform;
 783         struct snd_soc_component *component;
 784         struct snd_soc_rtdcom_list *rtdcom;
 785         int ret = 0, __ret;
 786
 787         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 788
 789         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_caps) {
 790                 ret = platform->driver->compr_ops->get_caps(cstream, caps);
 791                 if (ret < 0)
 792                         goto err;
 793         }
 794
 795         for_each_rtdcom(rtd, rtdcom) {
 796                 component = rtdcom->component;
 797
 798                 /* ignore duplication for now */
 799                 if (platform && (component == &platform->component))
 800                         continue;
 801
 802                 if (!component->driver->compr_ops ||
 803                     !component->driver->compr_ops->get_caps)
 804                         continue;
 805
 806                 __ret = component->driver->compr_ops->get_caps(cstream, caps);
 807                 if (__ret < 0)
 808                         ret = __ret;
 809         }
 810
 811 err:
 812         mutex_unlock(&rtd->pcm_mutex);
 813         return ret;
 814 }
 815
 816 static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream,
 817                                 struct snd_compr_codec_caps *codec)
 818 {
 819         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 820         struct snd_soc_platform *platform = rtd->platform;
 821         struct snd_soc_component *component;
 822         struct snd_soc_rtdcom_list *rtdcom;
 823         int ret = 0, __ret;
 824
 825         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 826
 827         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps) {
 828                 ret = platform->driver->compr_ops->get_codec_caps(cstream, codec);
 829                 if (ret < 0)
 830                         goto err;
 831         }
 832
 833         for_each_rtdcom(rtd, rtdcom) {
 834                 component = rtdcom->component;
 835
 836                 /* ignore duplication for now */
 837                 if (platform && (component == &platform->component))
 838                         continue;
 839
 840                 if (!component->driver->compr_ops ||
 841                     !component->driver->compr_ops->get_codec_caps)
 842                         continue;
 843
 844                 __ret = component->driver->compr_ops->get_codec_caps(cstream, codec);
 845                 if (__ret < 0)
 846                         ret = __ret;
 847         }
 848
 849 err:
 850         mutex_unlock(&rtd->pcm_mutex);
 851         return ret;
 852 }
 853
 854 static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
 855 {
 856         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 857         struct snd_soc_platform *platform = rtd->platform;
 858         struct snd_soc_component *component;
 859         struct snd_soc_rtdcom_list *rtdcom;
 860         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 861         int ret = 0, __ret;
 862
 863         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 864
 865         if (cpu_dai->driver->cops && cpu_dai->driver->cops->ack) {
 866                 ret = cpu_dai->driver->cops->ack(cstream, bytes, cpu_dai);
 867                 if (ret < 0)
 868                         goto err;
 869         }
 870
 871         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->ack) {
 872                 ret = platform->driver->compr_ops->ack(cstream, bytes);
 873                 if (ret < 0)
 874                         goto err;
 875         }
 876
 877         for_each_rtdcom(rtd, rtdcom) {
 878                 component = rtdcom->component;
 879
 880                 /* ignore duplication for now */
 881                 if (platform && (component == &platform->component))
 882                         continue;
 883
 884                 if (!component->driver->compr_ops ||
 885                     !component->driver->compr_ops->ack)
 886                         continue;
 887
 888                 __ret = component->driver->compr_ops->ack(cstream, bytes);
 889                 if (__ret < 0)
 890                         ret = __ret;
 891         }
 892
 893 err:
 894         mutex_unlock(&rtd->pcm_mutex);
 895         return ret;
 896 }
 897
 898 static int soc_compr_pointer(struct snd_compr_stream *cstream,
 899                         struct snd_compr_tstamp *tstamp)
 900 {
 901         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 902         struct snd_soc_platform *platform = rtd->platform;
 903         struct snd_soc_component *component;
 904         struct snd_soc_rtdcom_list *rtdcom;
 905         int ret = 0, __ret;
 906         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 907
 908         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 909
 910         if (cpu_dai->driver->cops && cpu_dai->driver->cops->pointer)
 911                 cpu_dai->driver->cops->pointer(cstream, tstamp, cpu_dai);
 912
 913         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->pointer) {
 914                 ret = platform->driver->compr_ops->pointer(cstream, tstamp);
 915                 if (ret < 0)
 916                         goto err;
 917         }
 918
 919         for_each_rtdcom(rtd, rtdcom) {
 920                 component = rtdcom->component;
 921
 922                 /* ignore duplication for now */
 923                 if (platform && (component == &platform->component))
 924                         continue;
 925
 926                 if (!component->driver->compr_ops ||
 927                     !component->driver->compr_ops->pointer)
 928                         continue;
 929
 930                 __ret = component->driver->compr_ops->pointer(cstream, tstamp);
 931                 if (__ret < 0)
 932                         ret = __ret;
 933         }
 934
 935 err:
 936         mutex_unlock(&rtd->pcm_mutex);
 937         return ret;
 938 }
 939
 940 static int soc_compr_copy(struct snd_compr_stream *cstream,
 941                           char __user *buf, size_t count)
 942 {
 943         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 944         struct snd_soc_platform *platform = rtd->platform;
 945         struct snd_soc_component *component;
 946         struct snd_soc_rtdcom_list *rtdcom;
 947         int ret = 0, __ret;
 948
 949         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 950
 951         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy) {
 952                 ret = platform->driver->compr_ops->copy(cstream, buf, count);
 953                 if (ret < 0)
 954                         goto err;
 955         }
 956
 957         for_each_rtdcom(rtd, rtdcom) {
 958                 component = rtdcom->component;
 959
 960                 /* ignore duplication for now */
 961                 if (platform && (component == &platform->component))
 962                         continue;
 963
 964                 if (!component->driver->compr_ops ||
 965                     !component->driver->compr_ops->copy)
 966                         continue;
 967
 968                 __ret = component->driver->compr_ops->copy(cstream, buf, count);
 969                 if (__ret < 0)
 970                         ret = __ret;
 971         }
 972 err:
 973         mutex_unlock(&rtd->pcm_mutex);
 974         return ret;
 975 }
 976
 977 static int soc_compr_set_metadata(struct snd_compr_stream *cstream,
 978                                 struct snd_compr_metadata *metadata)
 979 {
 980         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 981         struct snd_soc_platform *platform = rtd->platform;
 982         struct snd_soc_component *component;
 983         struct snd_soc_rtdcom_list *rtdcom;
 984         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 985         int ret = 0, __ret;
 986
 987         if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_metadata) {
 988                 ret = cpu_dai->driver->cops->set_metadata(cstream, metadata, cpu_dai);
 989                 if (ret < 0)
 990                         return ret;
 991         }
 992
 993         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_metadata) {
 994                 ret = platform->driver->compr_ops->set_metadata(cstream, metadata);
 995                 if (ret < 0)
 996                         return ret;
 997         }
 998
 999         for_each_rtdcom(rtd, rtdcom) {
1000                 component = rtdcom->component;
1001
1002                 /* ignore duplication for now */
1003                 if (platform && (component == &platform->component))
1004                         continue;
1005
1006                 if (!component->driver->compr_ops ||
1007                     !component->driver->compr_ops->set_metadata)
1008                         continue;
1009
1010                 __ret = component->driver->compr_ops->set_metadata(cstream, metadata);
1011                 if (__ret < 0)
1012                         ret = __ret;
1013         }
1014
1015         return ret;
1016 }
1017
1018 static int soc_compr_get_metadata(struct snd_compr_stream *cstream,
1019                                 struct snd_compr_metadata *metadata)
1020 {
1021         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
1022         struct snd_soc_platform *platform = rtd->platform;
1023         struct snd_soc_component *component;
1024         struct snd_soc_rtdcom_list *rtdcom;
1025         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1026         int ret = 0, __ret;
1027
1028         if (cpu_dai->driver->cops && cpu_dai->driver->cops->get_metadata) {
1029                 ret = cpu_dai->driver->cops->get_metadata(cstream, metadata, cpu_dai);
1030                 if (ret < 0)
1031                         return ret;
1032         }
1033
1034         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_metadata) {
1035                 ret = platform->driver->compr_ops->get_metadata(cstream, metadata);
1036                 if (ret < 0)
1037                         return ret;
1038         }
1039
1040         for_each_rtdcom(rtd, rtdcom) {
1041                 component = rtdcom->component;
1042
1043                 /* ignore duplication for now */
1044                 if (platform && (component == &platform->component))
1045                         continue;
1046
1047                 if (!component->driver->compr_ops ||
1048                     !component->driver->compr_ops->get_metadata)
1049                         continue;
1050
1051                 __ret = component->driver->compr_ops->get_metadata(cstream, metadata);
1052                 if (__ret < 0)
1053                         ret = __ret;
1054         }
1055
1056         return ret;
1057 }
1058
1059 /* ASoC Compress operations */
1060 static struct snd_compr_ops soc_compr_ops = {
1061         .open           = soc_compr_open,
1062         .free           = soc_compr_free,
1063         .set_params     = soc_compr_set_params,
1064         .set_metadata   = soc_compr_set_metadata,
1065         .get_metadata   = soc_compr_get_metadata,
1066         .get_params     = soc_compr_get_params,
1067         .trigger        = soc_compr_trigger,
1068         .pointer        = soc_compr_pointer,
1069         .ack            = soc_compr_ack,
1070         .get_caps       = soc_compr_get_caps,
1071         .get_codec_caps = soc_compr_get_codec_caps
1072 };
1073
1074 /* ASoC Dynamic Compress operations */
1075 static struct snd_compr_ops soc_compr_dyn_ops = {
1076         .open           = soc_compr_open_fe,
1077         .free           = soc_compr_free_fe,
1078         .set_params     = soc_compr_set_params_fe,
1079         .get_params     = soc_compr_get_params,
1080         .set_metadata   = soc_compr_set_metadata,
1081         .get_metadata   = soc_compr_get_metadata,
1082         .trigger        = soc_compr_trigger_fe,
1083         .pointer        = soc_compr_pointer,
1084         .ack            = soc_compr_ack,
1085         .get_caps       = soc_compr_get_caps,
1086         .get_codec_caps = soc_compr_get_codec_caps
1087 };
1088
1089 /**
1090  * snd_soc_new_compress - create a new compress.
1091  *
1092  * @rtd: The runtime for which we will create compress
1093  * @num: the device index number (zero based - shared with normal PCMs)
1094  *
1095  * Return: 0 for success, else error.
1096  */
1097 int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
1098 {
1099         struct snd_soc_codec *codec = rtd->codec;
1100         struct snd_soc_platform *platform = rtd->platform;
1101         struct snd_soc_component *component;
1102         struct snd_soc_rtdcom_list *rtdcom;
1103         struct snd_soc_dai *codec_dai = rtd->codec_dai;
1104         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1105         struct snd_compr *compr;
1106         struct snd_pcm *be_pcm;
1107         char new_name[64];
1108         int ret = 0, direction = 0;
1109         int playback = 0, capture = 0;
1110
1111         if (rtd->num_codecs > 1) {
1112                 dev_err(rtd->card->dev, "Multicodec not supported for compressed stream\n");
1113                 return -EINVAL;
1114         }
1115
1116         /* check client and interface hw capabilities */
1117         if (codec_dai->driver->playback.channels_min)
1118                 playback = 1;
1119         if (codec_dai->driver->capture.channels_min)
1120                 capture = 1;
1121
1122         capture = capture && cpu_dai->driver->capture.channels_min;
1123         playback = playback && cpu_dai->driver->playback.channels_min;
1124
1125         /*
1126          * Compress devices are unidirectional so only one of the directions
1127          * should be set, check for that (xor)
1128          */
1129         if (playback + capture != 1) {
1130                 dev_err(rtd->card->dev, "Invalid direction for compress P %d, C %d\n",
1131                                 playback, capture);
1132                 return -EINVAL;
1133         }
1134
1135         if (playback)
1136                 direction = SND_COMPRESS_PLAYBACK;
1137         else
1138                 direction = SND_COMPRESS_CAPTURE;
1139
1140         compr = kzalloc(sizeof(*compr), GFP_KERNEL);
1141         if (!compr)
1142                 return -ENOMEM;
1143
1144         compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops),
1145                                   GFP_KERNEL);
1146         if (!compr->ops) {
1147                 ret = -ENOMEM;
1148                 goto compr_err;
1149         }
1150
1151         if (rtd->dai_link->dynamic) {
1152                 snprintf(new_name, sizeof(new_name), "(%s)",
1153                         rtd->dai_link->stream_name);
1154
1155                 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
1156                                 rtd->dai_link->dpcm_playback,
1157                                 rtd->dai_link->dpcm_capture, &be_pcm);
1158                 if (ret < 0) {
1159                         dev_err(rtd->card->dev, "ASoC: can't create compressed for %s\n",
1160                                 rtd->dai_link->name);
1161                         goto compr_err;
1162                 }
1163
1164                 rtd->pcm = be_pcm;
1165                 rtd->fe_compr = 1;
1166                 if (rtd->dai_link->dpcm_playback)
1167                         be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
1168                 else if (rtd->dai_link->dpcm_capture)
1169                         be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
1170                 memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops));
1171         } else {
1172                 snprintf(new_name, sizeof(new_name), "%s %s-%d",
1173                         rtd->dai_link->stream_name, codec_dai->name, num);
1174
1175                 memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));
1176         }
1177
1178
1179         /* Add copy callback for not memory mapped DSPs */
1180         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy)
1181                 compr->ops->copy = soc_compr_copy;
1182
1183         for_each_rtdcom(rtd, rtdcom) {
1184                 component = rtdcom->component;
1185
1186                 /* ignore duplication for now */
1187                 if (platform && (component == &platform->component))
1188                         continue;
1189
1190                 if (!component->driver->compr_ops ||
1191                     !component->driver->compr_ops->copy)
1192                         continue;
1193
1194                 compr->ops->copy = soc_compr_copy;
1195         }
1196
1197
1198         mutex_init(&compr->lock);
1199         ret = snd_compress_new(rtd->card->snd_card, num, direction,
1200                                 new_name, compr);
1201         if (ret < 0) {
1202                 pr_err("compress asoc: can't create compress for codec %s\n",
1203                         codec->component.name);
1204                 goto compr_err;
1205         }
1206
1207         /* DAPM dai link stream work */
1208         INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
1209
1210         rtd->compr = compr;
1211         compr->private_data = rtd;
1212
1213         printk(KERN_INFO "compress asoc: %s <-> %s mapping ok\n", codec_dai->name,
1214                 cpu_dai->name);
1215         return ret;
1216
1217 compr_err:
1218         kfree(compr);
1219         return ret;
1220 }
1221 EXPORT_SYMBOL_GPL(snd_soc_new_compress);