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
  28 static int soc_compr_open(struct snd_compr_stream *cstream)
  29 {
  30         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
  31         struct snd_soc_platform *platform = rtd->platform;
  32         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
  33         struct snd_soc_dai *codec_dai = rtd->codec_dai;
  34         int ret = 0;
  35
  36         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
  37
  38         if (platform->driver->compr_ops && platform->driver->compr_ops->open) {
  39                 ret = platform->driver->compr_ops->open(cstream);
  40                 if (ret < 0) {
  41                         pr_err("compress asoc: can't open platform %s\n", platform->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         if (cstream->direction == SND_COMPRESS_PLAYBACK) {
  55                 cpu_dai->playback_active++;
  56                 codec_dai->playback_active++;
  57         } else {
  58                 cpu_dai->capture_active++;
  59                 codec_dai->capture_active++;
  60         }
  61
  62         cpu_dai->active++;
  63         codec_dai->active++;
  64         rtd->codec->active++;
  65
  66         mutex_unlock(&rtd->pcm_mutex);
  67
  68         return 0;
  69
  70 machine_err:
  71         if (platform->driver->compr_ops && platform->driver->compr_ops->free)
  72                 platform->driver->compr_ops->free(cstream);
  73 out:
  74         mutex_unlock(&rtd->pcm_mutex);
  75         return ret;
  76 }
  77
  78 /*
  79  * Power down the audio subsystem pmdown_time msecs after close is called.
  80  * This is to ensure there are no pops or clicks in between any music tracks
  81  * due to DAPM power cycling.
  82  */
  83 static void close_delayed_work(struct work_struct *work)
  84 {
  85         struct snd_soc_pcm_runtime *rtd =
  86                         container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
  87         struct snd_soc_dai *codec_dai = rtd->codec_dai;
  88
  89         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
  90
  91         dev_dbg(rtd->dev, "ASoC: pop wq checking: %s status: %s waiting: %s\n",
  92                  codec_dai->driver->playback.stream_name,
  93                  codec_dai->playback_active ? "active" : "inactive",
  94                  rtd->pop_wait ? "yes" : "no");
  95
  96         /* are we waiting on this codec DAI stream */
  97         if (rtd->pop_wait == 1) {
  98                 rtd->pop_wait = 0;
  99                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
 100                                           SND_SOC_DAPM_STREAM_STOP);
 101         }
 102
 103         mutex_unlock(&rtd->pcm_mutex);
 104 }
 105
 106 static int soc_compr_free(struct snd_compr_stream *cstream)
 107 {
 108         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 109         struct snd_soc_platform *platform = rtd->platform;
 110         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 111         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 112         struct snd_soc_codec *codec = rtd->codec;
 113
 114         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 115
 116         if (cstream->direction == SND_COMPRESS_PLAYBACK) {
 117                 cpu_dai->playback_active--;
 118                 codec_dai->playback_active--;
 119         } else {
 120                 cpu_dai->capture_active--;
 121                 codec_dai->capture_active--;
 122         }
 123
 124         snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
 125
 126         cpu_dai->active--;
 127         codec_dai->active--;
 128         codec->active--;
 129
 130         if (!cpu_dai->active)
 131                 cpu_dai->rate = 0;
 132
 133         if (!codec_dai->active)
 134                 codec_dai->rate = 0;
 135
 136
 137         if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown)
 138                 rtd->dai_link->compr_ops->shutdown(cstream);
 139
 140         if (platform->driver->compr_ops && platform->driver->compr_ops->free)
 141                 platform->driver->compr_ops->free(cstream);
 142         cpu_dai->runtime = NULL;
 143
 144         if (cstream->direction == SND_COMPRESS_PLAYBACK) {
 145                 if (!rtd->pmdown_time || codec->ignore_pmdown_time ||
 146                     rtd->dai_link->ignore_pmdown_time) {
 147                         snd_soc_dapm_stream_event(rtd,
 148                                         SNDRV_PCM_STREAM_PLAYBACK,
 149                                         SND_SOC_DAPM_STREAM_STOP);
 150                 } else {
 151                         rtd->pop_wait = 1;
 152                         queue_delayed_work(system_power_efficient_wq,
 153                                            &rtd->delayed_work,
 154                                            msecs_to_jiffies(rtd->pmdown_time));
 155                 }
 156         } else {
 157                 /* capture streams can be powered down now */
 158                 snd_soc_dapm_stream_event(rtd,
 159                         SNDRV_PCM_STREAM_CAPTURE,
 160                         SND_SOC_DAPM_STREAM_STOP);
 161         }
 162
 163         mutex_unlock(&rtd->pcm_mutex);
 164         return 0;
 165 }
 166
 167 static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)
 168 {
 169
 170         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 171         struct snd_soc_platform *platform = rtd->platform;
 172         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 173         int ret = 0;
 174
 175         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 176
 177         if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
 178                 ret = platform->driver->compr_ops->trigger(cstream, cmd);
 179                 if (ret < 0)
 180                         goto out;
 181         }
 182
 183         switch (cmd) {
 184         case SNDRV_PCM_TRIGGER_START:
 185                 snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction);
 186                 break;
 187         case SNDRV_PCM_TRIGGER_STOP:
 188                 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
 189                 break;
 190         }
 191
 192 out:
 193         mutex_unlock(&rtd->pcm_mutex);
 194         return ret;
 195 }
 196
 197 static int soc_compr_set_params(struct snd_compr_stream *cstream,
 198                                         struct snd_compr_params *params)
 199 {
 200         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 201         struct snd_soc_platform *platform = rtd->platform;
 202         int ret = 0;
 203
 204         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 205
 206         /* first we call set_params for the platform driver
 207          * this should configure the soc side
 208          * if the machine has compressed ops then we call that as well
 209          * expectation is that platform and machine will configure everything
 210          * for this compress path, like configuring pcm port for codec
 211          */
 212         if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
 213                 ret = platform->driver->compr_ops->set_params(cstream, params);
 214                 if (ret < 0)
 215                         goto err;
 216         }
 217
 218         if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) {
 219                 ret = rtd->dai_link->compr_ops->set_params(cstream);
 220                 if (ret < 0)
 221                         goto err;
 222         }
 223
 224         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 225                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
 226                                         SND_SOC_DAPM_STREAM_START);
 227         else
 228                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE,
 229                                         SND_SOC_DAPM_STREAM_START);
 230
 231         /* cancel any delayed stream shutdown that is pending */
 232         rtd->pop_wait = 0;
 233         mutex_unlock(&rtd->pcm_mutex);
 234
 235         cancel_delayed_work_sync(&rtd->delayed_work);
 236
 237         return ret;
 238
 239 err:
 240         mutex_unlock(&rtd->pcm_mutex);
 241         return ret;
 242 }
 243
 244 static int soc_compr_get_params(struct snd_compr_stream *cstream,
 245                                         struct snd_codec *params)
 246 {
 247         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 248         struct snd_soc_platform *platform = rtd->platform;
 249         int ret = 0;
 250
 251         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 252
 253         if (platform->driver->compr_ops && platform->driver->compr_ops->get_params)
 254                 ret = platform->driver->compr_ops->get_params(cstream, params);
 255
 256         mutex_unlock(&rtd->pcm_mutex);
 257         return ret;
 258 }
 259
 260 static int soc_compr_get_caps(struct snd_compr_stream *cstream,
 261                                 struct snd_compr_caps *caps)
 262 {
 263         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 264         struct snd_soc_platform *platform = rtd->platform;
 265         int ret = 0;
 266
 267         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 268
 269         if (platform->driver->compr_ops && platform->driver->compr_ops->get_caps)
 270                 ret = platform->driver->compr_ops->get_caps(cstream, caps);
 271
 272         mutex_unlock(&rtd->pcm_mutex);
 273         return ret;
 274 }
 275
 276 static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream,
 277                                 struct snd_compr_codec_caps *codec)
 278 {
 279         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 280         struct snd_soc_platform *platform = rtd->platform;
 281         int ret = 0;
 282
 283         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 284
 285         if (platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps)
 286                 ret = platform->driver->compr_ops->get_codec_caps(cstream, codec);
 287
 288         mutex_unlock(&rtd->pcm_mutex);
 289         return ret;
 290 }
 291
 292 static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
 293 {
 294         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 295         struct snd_soc_platform *platform = rtd->platform;
 296         int ret = 0;
 297
 298         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 299
 300         if (platform->driver->compr_ops && platform->driver->compr_ops->ack)
 301                 ret = platform->driver->compr_ops->ack(cstream, bytes);
 302
 303         mutex_unlock(&rtd->pcm_mutex);
 304         return ret;
 305 }
 306
 307 static int soc_compr_pointer(struct snd_compr_stream *cstream,
 308                         struct snd_compr_tstamp *tstamp)
 309 {
 310         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 311         struct snd_soc_platform *platform = rtd->platform;
 312
 313         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 314
 315         if (platform->driver->compr_ops && platform->driver->compr_ops->pointer)
 316                  platform->driver->compr_ops->pointer(cstream, tstamp);
 317
 318         mutex_unlock(&rtd->pcm_mutex);
 319         return 0;
 320 }
 321
 322 static int soc_compr_copy(struct snd_compr_stream *cstream,
 323                           char __user *buf, size_t count)
 324 {
 325         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 326         struct snd_soc_platform *platform = rtd->platform;
 327         int ret = 0;
 328
 329         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 330
 331         if (platform->driver->compr_ops && platform->driver->compr_ops->copy)
 332                 ret = platform->driver->compr_ops->copy(cstream, buf, count);
 333
 334         mutex_unlock(&rtd->pcm_mutex);
 335         return ret;
 336 }
 337
 338 static int soc_compr_set_metadata(struct snd_compr_stream *cstream,
 339                                 struct snd_compr_metadata *metadata)
 340 {
 341         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 342         struct snd_soc_platform *platform = rtd->platform;
 343         int ret = 0;
 344
 345         if (platform->driver->compr_ops && platform->driver->compr_ops->set_metadata)
 346                 ret = platform->driver->compr_ops->set_metadata(cstream, metadata);
 347
 348         return ret;
 349 }
 350
 351 static int soc_compr_get_metadata(struct snd_compr_stream *cstream,
 352                                 struct snd_compr_metadata *metadata)
 353 {
 354         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
 355         struct snd_soc_platform *platform = rtd->platform;
 356         int ret = 0;
 357
 358         if (platform->driver->compr_ops && platform->driver->compr_ops->get_metadata)
 359                 ret = platform->driver->compr_ops->get_metadata(cstream, metadata);
 360
 361         return ret;
 362 }
 363 /* ASoC Compress operations */
 364 static struct snd_compr_ops soc_compr_ops = {
 365         .open           = soc_compr_open,
 366         .free           = soc_compr_free,
 367         .set_params     = soc_compr_set_params,
 368         .set_metadata   = soc_compr_set_metadata,
 369         .get_metadata   = soc_compr_get_metadata,
 370         .get_params     = soc_compr_get_params,
 371         .trigger        = soc_compr_trigger,
 372         .pointer        = soc_compr_pointer,
 373         .ack            = soc_compr_ack,
 374         .get_caps       = soc_compr_get_caps,
 375         .get_codec_caps = soc_compr_get_codec_caps
 376 };
 377
 378 /* create a new compress */
 379 int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
 380 {
 381         struct snd_soc_codec *codec = rtd->codec;
 382         struct snd_soc_platform *platform = rtd->platform;
 383         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 384         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 385         struct snd_compr *compr;
 386         char new_name[64];
 387         int ret = 0, direction = 0;
 388         int playback = 0, capture = 0;
 389
 390         /* check client and interface hw capabilities */
 391         snprintf(new_name, sizeof(new_name), "%s %s-%d",
 392                         rtd->dai_link->stream_name, codec_dai->name, num);
 393
 394         if (codec_dai->driver->playback.channels_min)
 395                 playback = 1;
 396         if (codec_dai->driver->capture.channels_min)
 397                 capture = 1;
 398
 399         capture = capture && cpu_dai->driver->capture.channels_min;
 400         playback = playback && cpu_dai->driver->playback.channels_min;
 401
 402         /*
 403          * Compress devices are unidirectional so only one of the directions
 404          * should be set, check for that (xor)
 405          */
 406         if (playback + capture != 1) {
 407                 dev_err(rtd->card->dev, "Invalid direction for compress P %d, C %d\n",
 408                                 playback, capture);
 409                 return -EINVAL;
 410         }
 411
 412         if(playback)
 413                 direction = SND_COMPRESS_PLAYBACK;
 414         else
 415                 direction = SND_COMPRESS_CAPTURE;
 416
 417         compr = kzalloc(sizeof(*compr), GFP_KERNEL);
 418         if (compr == NULL) {
 419                 snd_printk(KERN_ERR "Cannot allocate compr\n");
 420                 return -ENOMEM;
 421         }
 422
 423         compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops),
 424                                   GFP_KERNEL);
 425         if (compr->ops == NULL) {
 426                 dev_err(rtd->card->dev, "Cannot allocate compressed ops\n");
 427                 ret = -ENOMEM;
 428                 goto compr_err;
 429         }
 430         memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));
 431
 432         /* Add copy callback for not memory mapped DSPs */
 433         if (platform->driver->compr_ops && platform->driver->compr_ops->copy)
 434                 compr->ops->copy = soc_compr_copy;
 435
 436         mutex_init(&compr->lock);
 437         ret = snd_compress_new(rtd->card->snd_card, num, direction, compr);
 438         if (ret < 0) {
 439                 pr_err("compress asoc: can't create compress for codec %s\n",
 440                         codec->name);
 441                 goto compr_err;
 442         }
 443
 444         /* DAPM dai link stream work */
 445         INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
 446
 447         rtd->compr = compr;
 448         compr->private_data = rtd;
 449
 450         printk(KERN_INFO "compress asoc: %s <-> %s mapping ok\n", codec_dai->name,
 451                 cpu_dai->name);
 452         return ret;
 453
 454 compr_err:
 455         kfree(compr);
 456         return ret;
 457 }