soc-compress.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 //
   3 // soc-compress.c  --  ALSA SoC Compress
   4 //
   5 // Copyright (C) 2012 Intel Corp.
   6 //
   7 // Authors: Namarta Kohli <namartax.kohli@intel.com>
   8 //          Ramesh Babu K V <ramesh.babu@linux.intel.com>
   9 //          Vinod Koul <vinod.koul@linux.intel.com>
  10
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/delay.h>
  14 #include <linux/slab.h>
  15 #include <linux/workqueue.h>
  16 #include <sound/core.h>
  17 #include <sound/compress_params.h>
  18 #include <sound/compress_driver.h>
  19 #include <sound/soc.h>
  20 #include <sound/initval.h>
  21 #include <sound/soc-dpcm.h>
  22 #include <sound/soc-link.h>
  23 #include <linux/pm_runtime.h>
  24
  25 static int snd_soc_compr_components_open(struct snd_compr_stream *cstream)
  26 {
  27         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
  28         struct snd_soc_component *component;
  29         int ret = 0;
  30         int i;
  31
  32         for_each_rtd_components(rtd, i, component) {
  33                 ret = snd_soc_component_module_get_when_open(component, cstream);
  34                 if (ret < 0)
  35                         break;
  36
  37                 ret = snd_soc_component_compr_open(component, cstream);
  38                 if (ret < 0)
  39                         break;
  40         }
  41
  42         return ret;
  43 }
  44
  45 static void snd_soc_compr_components_free(struct snd_compr_stream *cstream,
  46                                           int rollback)
  47 {
  48         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
  49         struct snd_soc_component *component;
  50         int i;
  51
  52         for_each_rtd_components(rtd, i, component) {
  53                 snd_soc_component_compr_free(component, cstream, rollback);
  54                 snd_soc_component_module_put_when_close(component, cstream, rollback);
  55         }
  56 }
  57
  58 static int soc_compr_clean(struct snd_compr_stream *cstream, int rollback)
  59 {
  60         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
  61         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
  62         struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
  63         int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
  64
  65         mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
  66
  67         if (!rollback)
  68                 snd_soc_runtime_deactivate(rtd, stream);
  69
  70         snd_soc_dai_digital_mute(codec_dai, 1, stream);
  71
  72         if (!snd_soc_dai_active(cpu_dai))
  73                 cpu_dai->rate = 0;
  74
  75         if (!snd_soc_dai_active(codec_dai))
  76                 codec_dai->rate = 0;
  77
  78         snd_soc_link_compr_shutdown(cstream, rollback);
  79
  80         snd_soc_compr_components_free(cstream, rollback);
  81
  82         snd_soc_dai_compr_shutdown(cpu_dai, cstream, rollback);
  83
  84         if (!rollback)
  85                 snd_soc_dapm_stream_stop(rtd, stream);
  86
  87         mutex_unlock(&rtd->card->pcm_mutex);
  88
  89         snd_soc_pcm_component_pm_runtime_put(rtd, cstream, rollback);
  90
  91         return 0;
  92 }
  93
  94 static int soc_compr_free(struct snd_compr_stream *cstream)
  95 {
  96         return soc_compr_clean(cstream, 0);
  97 }
  98
  99 static int soc_compr_open(struct snd_compr_stream *cstream)
 100 {
 101         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 102         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
 103         int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
 104         int ret;
 105
 106         ret = snd_soc_pcm_component_pm_runtime_get(rtd, cstream);
 107         if (ret < 0)
 108                 goto err_no_lock;
 109
 110         mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
 111
 112         ret = snd_soc_dai_compr_startup(cpu_dai, cstream);
 113         if (ret < 0)
 114                 goto err;
 115
 116         ret = snd_soc_compr_components_open(cstream);
 117         if (ret < 0)
 118                 goto err;
 119
 120         ret = snd_soc_link_compr_startup(cstream);
 121         if (ret < 0)
 122                 goto err;
 123
 124         snd_soc_runtime_activate(rtd, stream);
 125 err:
 126         mutex_unlock(&rtd->card->pcm_mutex);
 127 err_no_lock:
 128         if (ret < 0)
 129                 soc_compr_clean(cstream, 1);
 130
 131         return ret;
 132 }
 133
 134 static int soc_compr_open_fe(struct snd_compr_stream *cstream)
 135 {
 136         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 137         struct snd_pcm_substream *fe_substream =
 138                  fe->pcm->streams[cstream->direction].substream;
 139         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0);
 140         struct snd_soc_dpcm *dpcm;
 141         struct snd_soc_dapm_widget_list *list;
 142         int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
 143         int ret;
 144
 145         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 146         fe->dpcm[stream].runtime = fe_substream->runtime;
 147
 148         ret = dpcm_path_get(fe, stream, &list);
 149         if (ret < 0)
 150                 goto be_err;
 151
 152         mutex_lock_nested(&fe->card->pcm_mutex, fe->card->pcm_subclass);
 153
 154         /* calculate valid and active FE <-> BE dpcms */
 155         dpcm_process_paths(fe, stream, &list, 1);
 156         fe->dpcm[stream].runtime = fe_substream->runtime;
 157
 158         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 159
 160         ret = dpcm_be_dai_startup(fe, stream);
 161         if (ret < 0) {
 162                 /* clean up all links */
 163                 for_each_dpcm_be(fe, stream, dpcm)
 164                         dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
 165
 166                 dpcm_be_disconnect(fe, stream);
 167                 fe->dpcm[stream].runtime = NULL;
 168                 goto out;
 169         }
 170
 171         ret = snd_soc_dai_compr_startup(cpu_dai, cstream);
 172         if (ret < 0)
 173                 goto out;
 174
 175         ret = snd_soc_compr_components_open(cstream);
 176         if (ret < 0)
 177                 goto open_err;
 178
 179         ret = snd_soc_link_compr_startup(cstream);
 180         if (ret < 0)
 181                 goto machine_err;
 182
 183         dpcm_clear_pending_state(fe, stream);
 184         dpcm_path_put(&list);
 185
 186         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
 187         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 188
 189         snd_soc_runtime_activate(fe, stream);
 190         mutex_unlock(&fe->card->pcm_mutex);
 191
 192         mutex_unlock(&fe->card->mutex);
 193
 194         return 0;
 195
 196 machine_err:
 197         snd_soc_compr_components_free(cstream, 1);
 198 open_err:
 199         snd_soc_dai_compr_shutdown(cpu_dai, cstream, 1);
 200 out:
 201         dpcm_path_put(&list);
 202 be_err:
 203         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 204         mutex_unlock(&fe->card->mutex);
 205         return ret;
 206 }
 207
 208 static int soc_compr_free_fe(struct snd_compr_stream *cstream)
 209 {
 210         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 211         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0);
 212         struct snd_soc_dpcm *dpcm;
 213         int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
 214
 215         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 216
 217         mutex_lock_nested(&fe->card->pcm_mutex, fe->card->pcm_subclass);
 218         snd_soc_runtime_deactivate(fe, stream);
 219
 220         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 221
 222         dpcm_be_dai_hw_free(fe, stream);
 223
 224         dpcm_be_dai_shutdown(fe, stream);
 225
 226         /* mark FE's links ready to prune */
 227         for_each_dpcm_be(fe, stream, dpcm)
 228                 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
 229
 230         dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
 231
 232         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
 233         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 234
 235         dpcm_be_disconnect(fe, stream);
 236
 237         mutex_unlock(&fe->card->pcm_mutex);
 238
 239         fe->dpcm[stream].runtime = NULL;
 240
 241         snd_soc_link_compr_shutdown(cstream, 0);
 242
 243         snd_soc_compr_components_free(cstream, 0);
 244
 245         snd_soc_dai_compr_shutdown(cpu_dai, cstream, 0);
 246
 247         mutex_unlock(&fe->card->mutex);
 248         return 0;
 249 }
 250
 251 static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)
 252 {
 253         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 254         struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
 255         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
 256         int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
 257         int ret;
 258
 259         mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
 260
 261         ret = snd_soc_component_compr_trigger(cstream, cmd);
 262         if (ret < 0)
 263                 goto out;
 264
 265         ret = snd_soc_dai_compr_trigger(cpu_dai, cstream, cmd);
 266         if (ret < 0)
 267                 goto out;
 268
 269         switch (cmd) {
 270         case SNDRV_PCM_TRIGGER_START:
 271                 snd_soc_dai_digital_mute(codec_dai, 0, stream);
 272                 break;
 273         case SNDRV_PCM_TRIGGER_STOP:
 274                 snd_soc_dai_digital_mute(codec_dai, 1, stream);
 275                 break;
 276         }
 277
 278 out:
 279         mutex_unlock(&rtd->card->pcm_mutex);
 280         return ret;
 281 }
 282
 283 static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)
 284 {
 285         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 286         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0);
 287         int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
 288         int ret;
 289
 290         if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN ||
 291             cmd == SND_COMPR_TRIGGER_DRAIN)
 292                 return snd_soc_component_compr_trigger(cstream, cmd);
 293
 294         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 295
 296         ret = snd_soc_dai_compr_trigger(cpu_dai, cstream, cmd);
 297         if (ret < 0)
 298                 goto out;
 299
 300         ret = snd_soc_component_compr_trigger(cstream, cmd);
 301         if (ret < 0)
 302                 goto out;
 303
 304         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 305
 306         ret = dpcm_be_dai_trigger(fe, stream, cmd);
 307
 308         switch (cmd) {
 309         case SNDRV_PCM_TRIGGER_START:
 310         case SNDRV_PCM_TRIGGER_RESUME:
 311         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 312                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
 313                 break;
 314         case SNDRV_PCM_TRIGGER_STOP:
 315         case SNDRV_PCM_TRIGGER_SUSPEND:
 316                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
 317                 break;
 318         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 319                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
 320                 break;
 321         }
 322
 323 out:
 324         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 325         mutex_unlock(&fe->card->mutex);
 326         return ret;
 327 }
 328
 329 static int soc_compr_set_params(struct snd_compr_stream *cstream,
 330                                 struct snd_compr_params *params)
 331 {
 332         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 333         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
 334         int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
 335         int ret;
 336
 337         mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
 338
 339         /*
 340          * First we call set_params for the CPU DAI, then the component
 341          * driver this should configure the SoC side. If the machine has
 342          * compressed ops then we call that as well. The expectation is
 343          * that these callbacks will configure everything for this compress
 344          * path, like configuring a PCM port for a CODEC.
 345          */
 346         ret = snd_soc_dai_compr_set_params(cpu_dai, cstream, params);
 347         if (ret < 0)
 348                 goto err;
 349
 350         ret = snd_soc_component_compr_set_params(cstream, params);
 351         if (ret < 0)
 352                 goto err;
 353
 354         ret = snd_soc_link_compr_set_params(cstream);
 355         if (ret < 0)
 356                 goto err;
 357
 358         snd_soc_dapm_stream_event(rtd, stream, SND_SOC_DAPM_STREAM_START);
 359
 360         /* cancel any delayed stream shutdown that is pending */
 361         rtd->pop_wait = 0;
 362         mutex_unlock(&rtd->card->pcm_mutex);
 363
 364         cancel_delayed_work_sync(&rtd->delayed_work);
 365
 366         return 0;
 367
 368 err:
 369         mutex_unlock(&rtd->card->pcm_mutex);
 370         return ret;
 371 }
 372
 373 static int soc_compr_set_params_fe(struct snd_compr_stream *cstream,
 374                                    struct snd_compr_params *params)
 375 {
 376         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 377         struct snd_pcm_substream *fe_substream =
 378                  fe->pcm->streams[cstream->direction].substream;
 379         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0);
 380         int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
 381         int ret;
 382
 383         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 384
 385         /*
 386          * Create an empty hw_params for the BE as the machine driver must
 387          * fix this up to match DSP decoder and ASRC configuration.
 388          * I.e. machine driver fixup for compressed BE is mandatory.
 389          */
 390         memset(&fe->dpcm[fe_substream->stream].hw_params, 0,
 391                 sizeof(struct snd_pcm_hw_params));
 392
 393         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 394
 395         ret = dpcm_be_dai_hw_params(fe, stream);
 396         if (ret < 0)
 397                 goto out;
 398
 399         ret = dpcm_be_dai_prepare(fe, stream);
 400         if (ret < 0)
 401                 goto out;
 402
 403         ret = snd_soc_dai_compr_set_params(cpu_dai, cstream, params);
 404         if (ret < 0)
 405                 goto out;
 406
 407         ret = snd_soc_component_compr_set_params(cstream, params);
 408         if (ret < 0)
 409                 goto out;
 410
 411         ret = snd_soc_link_compr_set_params(cstream);
 412         if (ret < 0)
 413                 goto out;
 414         mutex_lock_nested(&fe->card->pcm_mutex, fe->card->pcm_subclass);
 415         dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
 416         mutex_unlock(&fe->card->pcm_mutex);
 417         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
 418
 419 out:
 420         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
 421         mutex_unlock(&fe->card->mutex);
 422         return ret;
 423 }
 424
 425 static int soc_compr_get_params(struct snd_compr_stream *cstream,
 426                                 struct snd_codec *params)
 427 {
 428         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 429         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
 430         int ret = 0;
 431
 432         mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
 433
 434         ret = snd_soc_dai_compr_get_params(cpu_dai, cstream, params);
 435         if (ret < 0)
 436                 goto err;
 437
 438         ret = snd_soc_component_compr_get_params(cstream, params);
 439 err:
 440         mutex_unlock(&rtd->card->pcm_mutex);
 441         return ret;
 442 }
 443
 444 static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
 445 {
 446         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 447         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
 448         int ret;
 449
 450         mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
 451
 452         ret = snd_soc_dai_compr_ack(cpu_dai, cstream, bytes);
 453         if (ret < 0)
 454                 goto err;
 455
 456         ret = snd_soc_component_compr_ack(cstream, bytes);
 457 err:
 458         mutex_unlock(&rtd->card->pcm_mutex);
 459         return ret;
 460 }
 461
 462 static int soc_compr_pointer(struct snd_compr_stream *cstream,
 463                              struct snd_compr_tstamp *tstamp)
 464 {
 465         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 466         int ret;
 467         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
 468
 469         mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
 470
 471         ret = snd_soc_dai_compr_pointer(cpu_dai, cstream, tstamp);
 472         if (ret < 0)
 473                 goto out;
 474
 475         ret = snd_soc_component_compr_pointer(cstream, tstamp);
 476 out:
 477         mutex_unlock(&rtd->card->pcm_mutex);
 478         return ret;
 479 }
 480
 481 static int soc_compr_set_metadata(struct snd_compr_stream *cstream,
 482                                   struct snd_compr_metadata *metadata)
 483 {
 484         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 485         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
 486         int ret;
 487
 488         ret = snd_soc_dai_compr_set_metadata(cpu_dai, cstream, metadata);
 489         if (ret < 0)
 490                 return ret;
 491
 492         return snd_soc_component_compr_set_metadata(cstream, metadata);
 493 }
 494
 495 static int soc_compr_get_metadata(struct snd_compr_stream *cstream,
 496                                   struct snd_compr_metadata *metadata)
 497 {
 498         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 499         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
 500         int ret;
 501
 502         ret = snd_soc_dai_compr_get_metadata(cpu_dai, cstream, metadata);
 503         if (ret < 0)
 504                 return ret;
 505
 506         return snd_soc_component_compr_get_metadata(cstream, metadata);
 507 }
 508
 509 /* ASoC Compress operations */
 510 static struct snd_compr_ops soc_compr_ops = {
 511         .open           = soc_compr_open,
 512         .free           = soc_compr_free,
 513         .set_params     = soc_compr_set_params,
 514         .set_metadata   = soc_compr_set_metadata,
 515         .get_metadata   = soc_compr_get_metadata,
 516         .get_params     = soc_compr_get_params,
 517         .trigger        = soc_compr_trigger,
 518         .pointer        = soc_compr_pointer,
 519         .ack            = soc_compr_ack,
 520         .get_caps       = snd_soc_component_compr_get_caps,
 521         .get_codec_caps = snd_soc_component_compr_get_codec_caps,
 522 };
 523
 524 /* ASoC Dynamic Compress operations */
 525 static struct snd_compr_ops soc_compr_dyn_ops = {
 526         .open           = soc_compr_open_fe,
 527         .free           = soc_compr_free_fe,
 528         .set_params     = soc_compr_set_params_fe,
 529         .get_params     = soc_compr_get_params,
 530         .set_metadata   = soc_compr_set_metadata,
 531         .get_metadata   = soc_compr_get_metadata,
 532         .trigger        = soc_compr_trigger_fe,
 533         .pointer        = soc_compr_pointer,
 534         .ack            = soc_compr_ack,
 535         .get_caps       = snd_soc_component_compr_get_caps,
 536         .get_codec_caps = snd_soc_component_compr_get_codec_caps,
 537 };
 538
 539 /**
 540  * snd_soc_new_compress - create a new compress.
 541  *
 542  * @rtd: The runtime for which we will create compress
 543  * @num: the device index number (zero based - shared with normal PCMs)
 544  *
 545  * Return: 0 for success, else error.
 546  */
 547 int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
 548 {
 549         struct snd_soc_component *component;
 550         struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
 551         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
 552         struct snd_compr *compr;
 553         struct snd_pcm *be_pcm;
 554         char new_name[64];
 555         int ret = 0, direction = 0;
 556         int playback = 0, capture = 0;
 557         int i;
 558
 559         /*
 560          * make sure these are same value,
 561          * and then use these as equally
 562          */
 563         BUILD_BUG_ON((int)SNDRV_PCM_STREAM_PLAYBACK != (int)SND_COMPRESS_PLAYBACK);
 564         BUILD_BUG_ON((int)SNDRV_PCM_STREAM_CAPTURE  != (int)SND_COMPRESS_CAPTURE);
 565
 566         if (rtd->dai_link->num_cpus > 1 ||
 567             rtd->dai_link->num_codecs > 1) {
 568                 dev_err(rtd->card->dev,
 569                         "Compress ASoC: Multi CPU/Codec not supported\n");
 570                 return -EINVAL;
 571         }
 572
 573         if (!codec_dai) {
 574                 dev_err(rtd->card->dev, "Missing codec\n");
 575                 return -EINVAL;
 576         }
 577
 578         /* check client and interface hw capabilities */
 579         if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_PLAYBACK) &&
 580             snd_soc_dai_stream_valid(cpu_dai,   SNDRV_PCM_STREAM_PLAYBACK))
 581                 playback = 1;
 582         if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_CAPTURE) &&
 583             snd_soc_dai_stream_valid(cpu_dai,   SNDRV_PCM_STREAM_CAPTURE))
 584                 capture = 1;
 585
 586         /*
 587          * Compress devices are unidirectional so only one of the directions
 588          * should be set, check for that (xor)
 589          */
 590         if (playback + capture != 1) {
 591                 dev_err(rtd->card->dev,
 592                         "Compress ASoC: Invalid direction for P %d, C %d\n",
 593                         playback, capture);
 594                 return -EINVAL;
 595         }
 596
 597         if (playback)
 598                 direction = SND_COMPRESS_PLAYBACK;
 599         else
 600                 direction = SND_COMPRESS_CAPTURE;
 601
 602         compr = devm_kzalloc(rtd->card->dev, sizeof(*compr), GFP_KERNEL);
 603         if (!compr)
 604                 return -ENOMEM;
 605
 606         compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops),
 607                                   GFP_KERNEL);
 608         if (!compr->ops)
 609                 return -ENOMEM;
 610
 611         if (rtd->dai_link->dynamic) {
 612                 snprintf(new_name, sizeof(new_name), "(%s)",
 613                         rtd->dai_link->stream_name);
 614
 615                 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
 616                                 rtd->dai_link->dpcm_playback,
 617                                 rtd->dai_link->dpcm_capture, &be_pcm);
 618                 if (ret < 0) {
 619                         dev_err(rtd->card->dev,
 620                                 "Compress ASoC: can't create compressed for %s: %d\n",
 621                                 rtd->dai_link->name, ret);
 622                         return ret;
 623                 }
 624
 625                 /* inherit atomicity from DAI link */
 626                 be_pcm->nonatomic = rtd->dai_link->nonatomic;
 627
 628                 rtd->pcm = be_pcm;
 629                 rtd->fe_compr = 1;
 630                 if (rtd->dai_link->dpcm_playback)
 631                         be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
 632                 if (rtd->dai_link->dpcm_capture)
 633                         be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
 634                 memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops));
 635         } else {
 636                 snprintf(new_name, sizeof(new_name), "%s %s-%d",
 637                         rtd->dai_link->stream_name, codec_dai->name, num);
 638
 639                 memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));
 640         }
 641
 642         for_each_rtd_components(rtd, i, component) {
 643                 if (!component->driver->compress_ops ||
 644                     !component->driver->compress_ops->copy)
 645                         continue;
 646
 647                 compr->ops->copy = snd_soc_component_compr_copy;
 648                 break;
 649         }
 650
 651         ret = snd_compress_new(rtd->card->snd_card, num, direction,
 652                                 new_name, compr);
 653         if (ret < 0) {
 654                 component = asoc_rtd_to_codec(rtd, 0)->component;
 655                 dev_err(component->dev,
 656                         "Compress ASoC: can't create compress for codec %s: %d\n",
 657                         component->name, ret);
 658                 return ret;
 659         }
 660
 661         /* DAPM dai link stream work */
 662         rtd->close_delayed_work_func = snd_soc_close_delayed_work;
 663
 664         rtd->compr = compr;
 665         compr->private_data = rtd;
 666
 667         dev_dbg(rtd->card->dev, "Compress ASoC: %s <-> %s mapping ok\n",
 668                 codec_dai->name, cpu_dai->name);
 669
 670         return 0;
 671 }
 672 EXPORT_SYMBOL_GPL(snd_soc_new_compress);