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         int ret = 0;
  34
  35         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
  36
  37         if (platform->driver->compr_ops && platform->driver->compr_ops->open) {
  38                 ret = platform->driver->compr_ops->open(cstream);
  39                 if (ret < 0) {
  40                         pr_err("compress asoc: can't open platform %s\n",
  41                                 platform->component.name);
  42                         goto out;
  43                 }
  44         }
  45
  46         if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->startup) {
  47                 ret = rtd->dai_link->compr_ops->startup(cstream);
  48                 if (ret < 0) {
  49                         pr_err("compress asoc: %s startup failed\n", rtd->dai_link->name);
  50                         goto machine_err;
  51                 }
  52         }
  53
  54         snd_soc_runtime_activate(rtd, cstream->direction);
  55
  56         mutex_unlock(&rtd->pcm_mutex);
  57
  58         return 0;
  59
  60 machine_err:
  61         if (platform->driver->compr_ops && platform->driver->compr_ops->free)
  62                 platform->driver->compr_ops->free(cstream);
  63 out:
  64         mutex_unlock(&rtd->pcm_mutex);
  65         return ret;
  66 }
  67
  68 static int soc_compr_open_fe(struct snd_compr_stream *cstream)
  69 {
  70         struct snd_soc_pcm_runtime *fe = cstream->private_data;
  71         struct snd_pcm_substream *fe_substream =
  72                  fe->pcm->streams[cstream->direction].substream;
  73         struct snd_soc_platform *platform = fe->platform;
  74         struct snd_soc_dpcm *dpcm;
  75         struct snd_soc_dapm_widget_list *list;
  76         int stream;
  77         int ret = 0;
  78
  79         if (cstream->direction == SND_COMPRESS_PLAYBACK)
  80                 stream = SNDRV_PCM_STREAM_PLAYBACK;
  81         else
  82                 stream = SNDRV_PCM_STREAM_CAPTURE;
  83
  84         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
  85
  86         if (platform->driver->compr_ops && platform->driver->compr_ops->open) {
  87                 ret = platform->driver->compr_ops->open(cstream);
  88                 if (ret < 0) {
  89                         pr_err("compress asoc: can't open platform %s\n",
  90                                 platform->component.name);
  91                         goto out;
  92                 }
  93         }
  94
  95         if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->startup) {
  96                 ret = fe->dai_link->compr_ops->startup(cstream);
  97                 if (ret < 0) {
  98                         pr_err("compress asoc: %s startup failed\n", fe->dai_link->name);
  99                         goto machine_err;
 100                 }
 101         }
 102
 103         fe->dpcm[stream].runtime = fe_substream->runtime;
 104
 105         ret = dpcm_path_get(fe, stream, &list);
 106         if (ret < 0)
 107                 goto fe_err;
 108         else if (ret == 0)
 109                 dev_dbg(fe->dev, "ASoC: %s no valid %s route\n",
 110                         fe->dai_link->name, stream ? "capture" : "playback");
 111
 112         /* calculate valid and active FE <-> BE dpcms */
 113         dpcm_process_paths(fe, stream, &list, 1);
 114
 115         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 116
 117         ret = dpcm_be_dai_startup(fe, stream);
 118         if (ret < 0) {
 119                 /* clean up all links */
 120                 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
 121                         dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
 122
 123                 dpcm_be_disconnect(fe, stream);
 124                 fe->dpcm[stream].runtime = NULL;
 125                 goto fe_err;
 126         }
 127
 128         dpcm_clear_pending_state(fe, stream);
 129         dpcm_path_put(&list);
 130
 131         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
 132         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 133
 134         snd_soc_runtime_activate(fe, stream);
 135
 136         mutex_unlock(&fe->card->mutex);
 137
 138         return 0;
 139
 140 fe_err:
 141         if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
 142                 fe->dai_link->compr_ops->shutdown(cstream);
 143 machine_err:
 144         if (platform->driver->compr_ops && platform->driver->compr_ops->free)
 145                 platform->driver->compr_ops->free(cstream);
 146 out:
 147         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 148         mutex_unlock(&fe->card->mutex);
 149         return ret;
 150 }
 151
 152 /*
 153  * Power down the audio subsystem pmdown_time msecs after close is called.
 154  * This is to ensure there are no pops or clicks in between any music tracks
 155  * due to DAPM power cycling.
 156  */
 157 static void close_delayed_work(struct work_struct *work)
 158 {
 159         struct snd_soc_pcm_runtime *rtd =
 160                         container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
 161         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 162
 163         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 164
 165         dev_dbg(rtd->dev, "ASoC: pop wq checking: %s status: %s waiting: %s\n",
 166                  codec_dai->driver->playback.stream_name,
 167                  codec_dai->playback_active ? "active" : "inactive",
 168                  rtd->pop_wait ? "yes" : "no");
 169
 170         /* are we waiting on this codec DAI stream */
 171         if (rtd->pop_wait == 1) {
 172                 rtd->pop_wait = 0;
 173                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
 174                                           SND_SOC_DAPM_STREAM_STOP);
 175         }
 176
 177         mutex_unlock(&rtd->pcm_mutex);
 178 }
 179
 180 static int soc_compr_free(struct snd_compr_stream *cstream)
 181 {
 182         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 183         struct snd_soc_platform *platform = rtd->platform;
 184         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 185         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 186         int stream;
 187
 188         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 189
 190         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 191                 stream = SNDRV_PCM_STREAM_PLAYBACK;
 192         else
 193                 stream = SNDRV_PCM_STREAM_CAPTURE;
 194
 195         snd_soc_runtime_deactivate(rtd, stream);
 196
 197         snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
 198
 199         if (!cpu_dai->active)
 200                 cpu_dai->rate = 0;
 201
 202         if (!codec_dai->active)
 203                 codec_dai->rate = 0;
 204
 205
 206         if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown)
 207                 rtd->dai_link->compr_ops->shutdown(cstream);
 208
 209         if (platform->driver->compr_ops && platform->driver->compr_ops->free)
 210                 platform->driver->compr_ops->free(cstream);
 211
 212         if (cstream->direction == SND_COMPRESS_PLAYBACK) {
 213                 if (snd_soc_runtime_ignore_pmdown_time(rtd)) {
 214                         snd_soc_dapm_stream_event(rtd,
 215                                         SNDRV_PCM_STREAM_PLAYBACK,
 216                                         SND_SOC_DAPM_STREAM_STOP);
 217                 } else {
 218                         rtd->pop_wait = 1;
 219                         queue_delayed_work(system_power_efficient_wq,
 220                                            &rtd->delayed_work,
 221                                            msecs_to_jiffies(rtd->pmdown_time));
 222                 }
 223         } else {
 224                 /* capture streams can be powered down now */
 225                 snd_soc_dapm_stream_event(rtd,
 226                         SNDRV_PCM_STREAM_CAPTURE,
 227                         SND_SOC_DAPM_STREAM_STOP);
 228         }
 229
 230         mutex_unlock(&rtd->pcm_mutex);
 231         return 0;
 232 }
 233
 234 static int soc_compr_free_fe(struct snd_compr_stream *cstream)
 235 {
 236         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 237         struct snd_soc_platform *platform = fe->platform;
 238         struct snd_soc_dpcm *dpcm;
 239         int stream, ret;
 240
 241         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 242
 243         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 244                 stream = SNDRV_PCM_STREAM_PLAYBACK;
 245         else
 246                 stream = SNDRV_PCM_STREAM_CAPTURE;
 247
 248         snd_soc_runtime_deactivate(fe, stream);
 249
 250         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 251
 252         ret = dpcm_be_dai_hw_free(fe, stream);
 253         if (ret < 0)
 254                 dev_err(fe->dev, "compressed hw_free failed %d\n", ret);
 255
 256         ret = dpcm_be_dai_shutdown(fe, stream);
 257
 258         /* mark FE's links ready to prune */
 259         list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
 260                 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
 261
 262         dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
 263
 264         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
 265         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 266
 267         dpcm_be_disconnect(fe, stream);
 268
 269         fe->dpcm[stream].runtime = NULL;
 270
 271         if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
 272                 fe->dai_link->compr_ops->shutdown(cstream);
 273
 274         if (platform->driver->compr_ops && platform->driver->compr_ops->free)
 275                 platform->driver->compr_ops->free(cstream);
 276
 277         mutex_unlock(&fe->card->mutex);
 278         return 0;
 279 }
 280
 281 static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)
 282 {
 283
 284         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 285         struct snd_soc_platform *platform = rtd->platform;
 286         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 287         int ret = 0;
 288
 289         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 290
 291         if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
 292                 ret = platform->driver->compr_ops->trigger(cstream, cmd);
 293                 if (ret < 0)
 294                         goto out;
 295         }
 296
 297         switch (cmd) {
 298         case SNDRV_PCM_TRIGGER_START:
 299                 snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction);
 300                 break;
 301         case SNDRV_PCM_TRIGGER_STOP:
 302                 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
 303                 break;
 304         }
 305
 306 out:
 307         mutex_unlock(&rtd->pcm_mutex);
 308         return ret;
 309 }
 310
 311 static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)
 312 {
 313         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 314         struct snd_soc_platform *platform = fe->platform;
 315         int ret = 0, stream;
 316
 317         if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN ||
 318                 cmd == SND_COMPR_TRIGGER_DRAIN) {
 319
 320                 if (platform->driver->compr_ops &&
 321                     platform->driver->compr_ops->trigger)
 322                         return platform->driver->compr_ops->trigger(cstream,
 323                                                                     cmd);
 324         }
 325
 326         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 327                 stream = SNDRV_PCM_STREAM_PLAYBACK;
 328         else
 329                 stream = SNDRV_PCM_STREAM_CAPTURE;
 330
 331
 332         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 333
 334         if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
 335                 ret = platform->driver->compr_ops->trigger(cstream, cmd);
 336                 if (ret < 0)
 337                         goto out;
 338         }
 339
 340         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 341
 342         ret = dpcm_be_dai_trigger(fe, stream, cmd);
 343
 344         switch (cmd) {
 345         case SNDRV_PCM_TRIGGER_START:
 346         case SNDRV_PCM_TRIGGER_RESUME:
 347         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 348                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
 349                 break;
 350         case SNDRV_PCM_TRIGGER_STOP:
 351         case SNDRV_PCM_TRIGGER_SUSPEND:
 352                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
 353                 break;
 354         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 355                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
 356                 break;
 357         }
 358
 359 out:
 360         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 361         mutex_unlock(&fe->card->mutex);
 362         return ret;
 363 }
 364
 365 static int soc_compr_set_params(struct snd_compr_stream *cstream,
 366                                         struct snd_compr_params *params)
 367 {
 368         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 369         struct snd_soc_platform *platform = rtd->platform;
 370         int ret = 0;
 371
 372         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 373
 374         /* first we call set_params for the platform driver
 375          * this should configure the soc side
 376          * if the machine has compressed ops then we call that as well
 377          * expectation is that platform and machine will configure everything
 378          * for this compress path, like configuring pcm port for codec
 379          */
 380         if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
 381                 ret = platform->driver->compr_ops->set_params(cstream, params);
 382                 if (ret < 0)
 383                         goto err;
 384         }
 385
 386         if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) {
 387                 ret = rtd->dai_link->compr_ops->set_params(cstream);
 388                 if (ret < 0)
 389                         goto err;
 390         }
 391
 392         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 393                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
 394                                         SND_SOC_DAPM_STREAM_START);
 395         else
 396                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE,
 397                                         SND_SOC_DAPM_STREAM_START);
 398
 399         /* cancel any delayed stream shutdown that is pending */
 400         rtd->pop_wait = 0;
 401         mutex_unlock(&rtd->pcm_mutex);
 402
 403         cancel_delayed_work_sync(&rtd->delayed_work);
 404
 405         return ret;
 406
 407 err:
 408         mutex_unlock(&rtd->pcm_mutex);
 409         return ret;
 410 }
 411
 412 static void dpcm_be_hw_params_prepare(void *data)
 413 {
 414         struct snd_compr_stream *cstream = data;
 415         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 416         struct snd_soc_pcm_runtime *be = cstream->be;
 417         int stream, ret;
 418
 419         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 420                 stream = SNDRV_PCM_STREAM_PLAYBACK;
 421         else
 422                 stream = SNDRV_PCM_STREAM_CAPTURE;
 423
 424         ret = dpcm_fe_dai_hw_params_be(fe, be,
 425                     &fe->dpcm[stream].hw_params, stream);
 426         if (ret < 0) {
 427                 fe->err_ops = ret;
 428                 return;
 429         }
 430
 431         ret = dpcm_fe_dai_prepare_be(fe, be, stream);
 432         if (ret < 0) {
 433                 fe->err_ops = ret;
 434                 return;
 435         }
 436 }
 437
 438 static void dpcm_be_hw_params_prepare_async(void *data, async_cookie_t cookie)
 439 {
 440         dpcm_be_hw_params_prepare(data);
 441 }
 442
 443 static int soc_compr_set_params_fe(struct snd_compr_stream *cstream,
 444                                         struct snd_compr_params *params)
 445 {
 446         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 447         struct snd_pcm_substream *fe_substream =
 448                  fe->pcm->streams[cstream->direction].substream;
 449         struct snd_soc_platform *platform = fe->platform;
 450         struct snd_soc_pcm_runtime *be_list[DPCM_MAX_BE_USERS];
 451         struct snd_soc_dpcm *dpcm;
 452         int ret = 0, stream, i, j = 0;
 453
 454         ASYNC_DOMAIN_EXCLUSIVE(async_domain);
 455
 456         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 457                 stream = SNDRV_PCM_STREAM_PLAYBACK;
 458         else
 459                 stream = SNDRV_PCM_STREAM_CAPTURE;
 460
 461         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 462
 463         if (!(fe->dai_link->async_ops & ASYNC_DPCM_SND_SOC_HW_PARAMS)) {
 464                 /* first we call set_params for the platform driver
 465                  * this should configure the soc side
 466                  * if the machine has compressed ops then we call that as well
 467                  * expectation is that platform and machine will configure
 468                  * everything for this compress path, like configuring pcm
 469                  * port for codec
 470                  */
 471                 if (platform->driver->compr_ops &&
 472                                 platform->driver->compr_ops->set_params) {
 473                         ret = platform->driver->compr_ops->set_params(cstream,
 474                                                                 params);
 475                         if (ret < 0)
 476                                 goto out;
 477                 }
 478
 479                 if (fe->dai_link->compr_ops &&
 480                                         fe->dai_link->compr_ops->set_params) {
 481                         ret = fe->dai_link->compr_ops->set_params(cstream);
 482                         if (ret < 0)
 483                                 goto out;
 484                 }
 485
 486                 /*
 487                  * Create an empty hw_params for the BE as the machine
 488                  * driver must fix this up to match DSP decoder and
 489                  * ASRC configuration.
 490                  * I.e. machine driver fixup for compressed BE is
 491                  * mandatory.
 492                  */
 493                 memset(&fe->dpcm[fe_substream->stream].hw_params, 0,
 494                                 sizeof(struct snd_pcm_hw_params));
 495
 496                 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 497
 498                 ret = dpcm_be_dai_hw_params(fe, stream);
 499                 if (ret < 0)
 500                         goto out;
 501
 502                 ret = dpcm_be_dai_prepare(fe, stream);
 503                 if (ret < 0)
 504                         goto out;
 505         } else {
 506                 /*
 507                  * Create an empty hw_params for the BE as the machine
 508                  * driver must fix this up to match DSP decoder and
 509                  * ASRC configuration.
 510                  * I.e. machine driver fixup for compressed BE is
 511                  * mandatory.
 512                  */
 513                 memset(&fe->dpcm[fe_substream->stream].hw_params, 0,
 514                                 sizeof(struct snd_pcm_hw_params));
 515
 516                 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 517
 518                 list_for_each_entry(dpcm,
 519                                 &fe->dpcm[stream].be_clients, list_be) {
 520                         struct snd_soc_pcm_runtime *be = dpcm->be;
 521
 522                         if (be->dai_link->async_ops &
 523                                 ASYNC_DPCM_SND_SOC_HW_PARAMS) {
 524                                 cstream->be = be;
 525                                 async_schedule_domain(
 526                                 dpcm_be_hw_params_prepare_async,
 527                                 cstream, &async_domain);
 528                         } else {
 529                                 be_list[j++] = be;
 530                                 if (j == DPCM_MAX_BE_USERS) {
 531                                         dev_dbg(fe->dev,
 532                                                 "ASoC: MAX backend users!\n");
 533                                         break;
 534                                 }
 535                         }
 536                 }
 537                 for (i = 0; i < j; i++) {
 538                         cstream->be = be_list[i];
 539                         dpcm_be_hw_params_prepare(cstream);
 540                 }
 541                 /* first we call set_params for the platform driver
 542                  * this should configure the soc side
 543                  * if the machine has compressed ops then we call that as well
 544                  * expectation is that platform and machine will configure
 545                  * everything this compress path, like configuring pcm port
 546                  * for codec
 547                  */
 548                 if (platform->driver->compr_ops &&
 549                                 platform->driver->compr_ops->set_params) {
 550                         ret = platform->driver->compr_ops->set_params(cstream,
 551                                                                     params);
 552                         if (ret < 0)
 553                                 goto exit;
 554                 }
 555
 556                 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
 557
 558                 if (fe->dai_link->compr_ops &&
 559                                 fe->dai_link->compr_ops->set_params) {
 560                         ret = fe->dai_link->compr_ops->set_params(cstream);
 561                         if (ret < 0)
 562                                 goto exit;
 563                 }
 564 exit:
 565                 async_synchronize_full_domain(&async_domain);
 566                 if (fe->err_ops < 0 || ret < 0)
 567                         goto out;
 568         }
 569         dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
 570         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
 571
 572 out:
 573         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 574         mutex_unlock(&fe->card->mutex);
 575         return ret;
 576 }
 577
 578 static int soc_compr_get_params(struct snd_compr_stream *cstream,
 579                                         struct snd_codec *params)
 580 {
 581         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 582         struct snd_soc_platform *platform = rtd->platform;
 583         int ret = 0;
 584
 585         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 586
 587         if (platform->driver->compr_ops && platform->driver->compr_ops->get_params)
 588                 ret = platform->driver->compr_ops->get_params(cstream, params);
 589
 590         mutex_unlock(&rtd->pcm_mutex);
 591         return ret;
 592 }
 593
 594 static int soc_compr_get_caps(struct snd_compr_stream *cstream,
 595                                 struct snd_compr_caps *caps)
 596 {
 597         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 598         struct snd_soc_platform *platform = rtd->platform;
 599         int ret = 0;
 600
 601         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 602
 603         if (platform->driver->compr_ops && platform->driver->compr_ops->get_caps)
 604                 ret = platform->driver->compr_ops->get_caps(cstream, caps);
 605
 606         mutex_unlock(&rtd->pcm_mutex);
 607         return ret;
 608 }
 609
 610 static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream,
 611                                 struct snd_compr_codec_caps *codec)
 612 {
 613         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 614         struct snd_soc_platform *platform = rtd->platform;
 615         int ret = 0;
 616
 617         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 618
 619         if (platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps)
 620                 ret = platform->driver->compr_ops->get_codec_caps(cstream, codec);
 621
 622         mutex_unlock(&rtd->pcm_mutex);
 623         return ret;
 624 }
 625
 626 static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
 627 {
 628         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 629         struct snd_soc_platform *platform = rtd->platform;
 630         int ret = 0;
 631
 632         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 633
 634         if (platform->driver->compr_ops && platform->driver->compr_ops->ack)
 635                 ret = platform->driver->compr_ops->ack(cstream, bytes);
 636
 637         mutex_unlock(&rtd->pcm_mutex);
 638         return ret;
 639 }
 640
 641 static int soc_compr_pointer(struct snd_compr_stream *cstream,
 642                         struct snd_compr_tstamp *tstamp)
 643 {
 644         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 645         struct snd_soc_platform *platform = rtd->platform;
 646         int ret = 0;
 647
 648         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 649
 650         if (platform->driver->compr_ops && platform->driver->compr_ops->pointer)
 651                 ret = platform->driver->compr_ops->pointer(cstream, tstamp);
 652
 653         mutex_unlock(&rtd->pcm_mutex);
 654         return ret;
 655 }
 656
 657 static int soc_compr_copy(struct snd_compr_stream *cstream,
 658                           char __user *buf, size_t count)
 659 {
 660         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 661         struct snd_soc_platform *platform = rtd->platform;
 662         int ret = 0;
 663
 664         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 665
 666         if (platform->driver->compr_ops && platform->driver->compr_ops->copy)
 667                 ret = platform->driver->compr_ops->copy(cstream, buf, count);
 668
 669         mutex_unlock(&rtd->pcm_mutex);
 670         return ret;
 671 }
 672
 673 static int sst_compr_set_next_track_param(struct snd_compr_stream *cstream,
 674                                 union snd_codec_options *codec_options)
 675 {
 676         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 677         struct snd_soc_platform *platform = rtd->platform;
 678         int ret = 0;
 679
 680         if (platform->driver->compr_ops &&
 681                         platform->driver->compr_ops->set_next_track_param)
 682                 ret = platform->driver->compr_ops->set_next_track_param(cstream,
 683                                                                 codec_options);
 684
 685         return ret;
 686 }
 687
 688
 689 static int soc_compr_set_metadata(struct snd_compr_stream *cstream,
 690                                 struct snd_compr_metadata *metadata)
 691 {
 692         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 693         struct snd_soc_platform *platform = rtd->platform;
 694         int ret = 0;
 695
 696         if (platform->driver->compr_ops && platform->driver->compr_ops->set_metadata)
 697                 ret = platform->driver->compr_ops->set_metadata(cstream, metadata);
 698
 699         return ret;
 700 }
 701
 702 static int soc_compr_get_metadata(struct snd_compr_stream *cstream,
 703                                 struct snd_compr_metadata *metadata)
 704 {
 705         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 706         struct snd_soc_platform *platform = rtd->platform;
 707         int ret = 0;
 708
 709         if (platform->driver->compr_ops && platform->driver->compr_ops->get_metadata)
 710                 ret = platform->driver->compr_ops->get_metadata(cstream, metadata);
 711
 712         return ret;
 713 }
 714
 715 /* ASoC Compress operations */
 716 static struct snd_compr_ops soc_compr_ops = {
 717         .open           = soc_compr_open,
 718         .free           = soc_compr_free,
 719         .set_params     = soc_compr_set_params,
 720         .set_metadata   = soc_compr_set_metadata,
 721         .set_next_track_param   = sst_compr_set_next_track_param,
 722         .get_metadata   = soc_compr_get_metadata,
 723         .get_params     = soc_compr_get_params,
 724         .trigger        = soc_compr_trigger,
 725         .pointer        = soc_compr_pointer,
 726         .ack            = soc_compr_ack,
 727         .get_caps       = soc_compr_get_caps,
 728         .get_codec_caps = soc_compr_get_codec_caps
 729 };
 730
 731 /* ASoC Dynamic Compress operations */
 732 static struct snd_compr_ops soc_compr_dyn_ops = {
 733         .open           = soc_compr_open_fe,
 734         .free           = soc_compr_free_fe,
 735         .set_params     = soc_compr_set_params_fe,
 736         .get_params     = soc_compr_get_params,
 737         .set_metadata   = soc_compr_set_metadata,
 738         .set_next_track_param   = sst_compr_set_next_track_param,
 739         .get_metadata   = soc_compr_get_metadata,
 740         .trigger        = soc_compr_trigger_fe,
 741         .pointer        = soc_compr_pointer,
 742         .ack            = soc_compr_ack,
 743         .get_caps       = soc_compr_get_caps,
 744         .get_codec_caps = soc_compr_get_codec_caps
 745 };
 746
 747 /**
 748  * snd_soc_new_compress - create a new compress.
 749  *
 750  * @rtd: The runtime for which we will create compress
 751  * @num: the device index number (zero based - shared with normal PCMs)
 752  *
 753  * Return: 0 for success, else error.
 754  */
 755 int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
 756 {
 757         struct snd_soc_codec *codec = rtd->codec;
 758         struct snd_soc_platform *platform = rtd->platform;
 759         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 760         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 761         struct snd_compr *compr;
 762         struct snd_pcm *be_pcm;
 763         char new_name[64];
 764         int ret = 0, direction = 0;
 765         int playback = 0, capture = 0;
 766
 767         if (rtd->num_codecs > 1) {
 768                 dev_err(rtd->card->dev, "Multicodec not supported for compressed stream\n");
 769                 return -EINVAL;
 770         }
 771
 772         /* check client and interface hw capabilities */
 773         snprintf(new_name, sizeof(new_name), "%s %s-%d",
 774                         rtd->dai_link->stream_name, codec_dai->name, num);
 775
 776         if (codec_dai->driver->playback.channels_min)
 777                 playback = 1;
 778         if (codec_dai->driver->capture.channels_min)
 779                 capture = 1;
 780
 781         capture = capture && cpu_dai->driver->capture.channels_min;
 782         playback = playback && cpu_dai->driver->playback.channels_min;
 783
 784         /*
 785          * Compress devices are unidirectional so only one of the directions
 786          * should be set, check for that (xor)
 787          */
 788         if (playback + capture != 1) {
 789                 dev_err(rtd->card->dev, "Invalid direction for compress P %d, C %d\n",
 790                                 playback, capture);
 791                 return -EINVAL;
 792         }
 793
 794         if(playback)
 795                 direction = SND_COMPRESS_PLAYBACK;
 796         else
 797                 direction = SND_COMPRESS_CAPTURE;
 798
 799         compr = kzalloc(sizeof(*compr), GFP_KERNEL);
 800         if (compr == NULL) {
 801                 snd_printk(KERN_ERR "Cannot allocate compr\n");
 802                 return -ENOMEM;
 803         }
 804
 805         compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops),
 806                                   GFP_KERNEL);
 807         if (compr->ops == NULL) {
 808                 dev_err(rtd->card->dev, "Cannot allocate compressed ops\n");
 809                 ret = -ENOMEM;
 810                 goto compr_err;
 811         }
 812
 813         if (rtd->dai_link->dynamic) {
 814                 snprintf(new_name, sizeof(new_name), "(%s)",
 815                         rtd->dai_link->stream_name);
 816
 817                 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
 818                                 rtd->dai_link->dpcm_playback,
 819                                 rtd->dai_link->dpcm_capture, &be_pcm);
 820                 if (ret < 0) {
 821                         dev_err(rtd->card->dev, "ASoC: can't create compressed for %s\n",
 822                                 rtd->dai_link->name);
 823                         goto compr_err;
 824                 }
 825
 826                 rtd->pcm = be_pcm;
 827                 rtd->fe_compr = 1;
 828                 if (rtd->dai_link->dpcm_playback)
 829                         be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
 830                 else if (rtd->dai_link->dpcm_capture)
 831                         be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
 832                 memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops));
 833         } else
 834                 memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));
 835
 836         /* Add copy callback for not memory mapped DSPs */
 837         if (platform->driver->compr_ops && platform->driver->compr_ops->copy)
 838                 compr->ops->copy = soc_compr_copy;
 839
 840         mutex_init(&compr->lock);
 841         ret = snd_compress_new(rtd->card->snd_card, num, direction, compr);
 842         if (ret < 0) {
 843                 pr_err("compress asoc: can't create compress for codec %s\n",
 844                         codec->component.name);
 845                 goto compr_err;
 846         }
 847
 848         /* DAPM dai link stream work */
 849         INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
 850
 851         rtd->compr = compr;
 852         compr->private_data = rtd;
 853
 854         if (platform->driver->pcm_new) {
 855                 ret = platform->driver->pcm_new(rtd);
 856                 if (ret < 0) {
 857                         pr_err("asoc: compress pcm constructor failed\n");
 858                         goto compr_err;
 859                 }
 860         }
 861
 862         dev_dbg(rtd->card->dev, "compress asoc: %s <-> %s mapping ok\n",
 863                 codec_dai->name, cpu_dai->name);
 864         return ret;
 865
 866 compr_err:
 867         kfree(compr);
 868         return ret;
 869 }
 870 EXPORT_SYMBOL_GPL(snd_soc_new_compress);