Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 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 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 36 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 37 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 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 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 66 | mutex_unlock(&rtd->pcm_mutex); |
| 67 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 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: |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 74 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 75 | return ret; |
| 76 | } |
| 77 | |
Charles Keepax | 202c8f7 | 2013-01-24 09:44:30 +0000 | [diff] [blame^] | 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 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 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 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 114 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 115 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 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); |
| 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); |
Vinod Koul | 9d2667a | 2012-08-21 12:15:02 +0530 | [diff] [blame] | 142 | cpu_dai->runtime = NULL; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 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); |
Charles Keepax | 8c3d2aa | 2013-01-24 09:44:28 +0000 | [diff] [blame] | 150 | } else { |
Misael Lopez Cruz | 9bffb1f | 2012-12-13 12:23:05 -0600 | [diff] [blame] | 151 | rtd->pop_wait = 1; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 152 | schedule_delayed_work(&rtd->delayed_work, |
| 153 | msecs_to_jiffies(rtd->pmdown_time)); |
Charles Keepax | 8c3d2aa | 2013-01-24 09:44:28 +0000 | [diff] [blame] | 154 | } |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 155 | } else { |
| 156 | /* capture streams can be powered down now */ |
| 157 | snd_soc_dapm_stream_event(rtd, |
| 158 | SNDRV_PCM_STREAM_CAPTURE, |
| 159 | SND_SOC_DAPM_STREAM_STOP); |
| 160 | } |
| 161 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 162 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 163 | return 0; |
| 164 | } |
| 165 | |
| 166 | static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd) |
| 167 | { |
| 168 | |
| 169 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 170 | struct snd_soc_platform *platform = rtd->platform; |
| 171 | struct snd_soc_dai *codec_dai = rtd->codec_dai; |
| 172 | int ret = 0; |
| 173 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 174 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 175 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 176 | if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) { |
| 177 | ret = platform->driver->compr_ops->trigger(cstream, cmd); |
| 178 | if (ret < 0) |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 179 | goto out; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | if (cmd == SNDRV_PCM_TRIGGER_START) |
| 183 | snd_soc_dai_digital_mute(codec_dai, 0); |
| 184 | else if (cmd == SNDRV_PCM_TRIGGER_STOP) |
| 185 | snd_soc_dai_digital_mute(codec_dai, 1); |
| 186 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 187 | out: |
| 188 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 189 | return ret; |
| 190 | } |
| 191 | |
| 192 | static int soc_compr_set_params(struct snd_compr_stream *cstream, |
| 193 | struct snd_compr_params *params) |
| 194 | { |
| 195 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 196 | struct snd_soc_platform *platform = rtd->platform; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 197 | int ret = 0; |
| 198 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 199 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 200 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 201 | /* first we call set_params for the platform driver |
| 202 | * this should configure the soc side |
| 203 | * if the machine has compressed ops then we call that as well |
| 204 | * expectation is that platform and machine will configure everything |
| 205 | * for this compress path, like configuring pcm port for codec |
| 206 | */ |
| 207 | if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) { |
| 208 | ret = platform->driver->compr_ops->set_params(cstream, params); |
| 209 | if (ret < 0) |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 210 | goto out; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 211 | } |
| 212 | |
| 213 | if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) { |
| 214 | ret = rtd->dai_link->compr_ops->set_params(cstream); |
| 215 | if (ret < 0) |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 216 | goto out; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 217 | } |
| 218 | |
| 219 | snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK, |
| 220 | SND_SOC_DAPM_STREAM_START); |
| 221 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 222 | out: |
| 223 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 224 | return ret; |
| 225 | } |
| 226 | |
| 227 | static int soc_compr_get_params(struct snd_compr_stream *cstream, |
| 228 | struct snd_codec *params) |
| 229 | { |
| 230 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 231 | struct snd_soc_platform *platform = rtd->platform; |
| 232 | int ret = 0; |
| 233 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 234 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 235 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 236 | if (platform->driver->compr_ops && platform->driver->compr_ops->get_params) |
| 237 | ret = platform->driver->compr_ops->get_params(cstream, params); |
| 238 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 239 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 240 | return ret; |
| 241 | } |
| 242 | |
| 243 | static int soc_compr_get_caps(struct snd_compr_stream *cstream, |
| 244 | struct snd_compr_caps *caps) |
| 245 | { |
| 246 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 247 | struct snd_soc_platform *platform = rtd->platform; |
| 248 | int ret = 0; |
| 249 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 250 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 251 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 252 | if (platform->driver->compr_ops && platform->driver->compr_ops->get_caps) |
| 253 | ret = platform->driver->compr_ops->get_caps(cstream, caps); |
| 254 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 255 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 256 | return ret; |
| 257 | } |
| 258 | |
| 259 | static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream, |
| 260 | struct snd_compr_codec_caps *codec) |
| 261 | { |
| 262 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 263 | struct snd_soc_platform *platform = rtd->platform; |
| 264 | int ret = 0; |
| 265 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 266 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 267 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 268 | if (platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps) |
| 269 | ret = platform->driver->compr_ops->get_codec_caps(cstream, codec); |
| 270 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 271 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 272 | return ret; |
| 273 | } |
| 274 | |
| 275 | static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes) |
| 276 | { |
| 277 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 278 | struct snd_soc_platform *platform = rtd->platform; |
| 279 | int ret = 0; |
| 280 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 281 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 282 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 283 | if (platform->driver->compr_ops && platform->driver->compr_ops->ack) |
| 284 | ret = platform->driver->compr_ops->ack(cstream, bytes); |
| 285 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 286 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 287 | return ret; |
| 288 | } |
| 289 | |
| 290 | static int soc_compr_pointer(struct snd_compr_stream *cstream, |
| 291 | struct snd_compr_tstamp *tstamp) |
| 292 | { |
| 293 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 294 | struct snd_soc_platform *platform = rtd->platform; |
| 295 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 296 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 297 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 298 | if (platform->driver->compr_ops && platform->driver->compr_ops->pointer) |
| 299 | platform->driver->compr_ops->pointer(cstream, tstamp); |
| 300 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 301 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 302 | return 0; |
| 303 | } |
| 304 | |
| 305 | /* ASoC Compress operations */ |
| 306 | static struct snd_compr_ops soc_compr_ops = { |
| 307 | .open = soc_compr_open, |
| 308 | .free = soc_compr_free, |
| 309 | .set_params = soc_compr_set_params, |
| 310 | .get_params = soc_compr_get_params, |
| 311 | .trigger = soc_compr_trigger, |
| 312 | .pointer = soc_compr_pointer, |
| 313 | .ack = soc_compr_ack, |
| 314 | .get_caps = soc_compr_get_caps, |
| 315 | .get_codec_caps = soc_compr_get_codec_caps |
| 316 | }; |
| 317 | |
| 318 | /* create a new compress */ |
| 319 | int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num) |
| 320 | { |
| 321 | struct snd_soc_codec *codec = rtd->codec; |
| 322 | struct snd_soc_dai *codec_dai = rtd->codec_dai; |
| 323 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; |
| 324 | struct snd_compr *compr; |
| 325 | char new_name[64]; |
| 326 | int ret = 0, direction = 0; |
| 327 | |
| 328 | /* check client and interface hw capabilities */ |
| 329 | snprintf(new_name, sizeof(new_name), "%s %s-%d", |
| 330 | rtd->dai_link->stream_name, codec_dai->name, num); |
| 331 | direction = SND_COMPRESS_PLAYBACK; |
| 332 | compr = kzalloc(sizeof(*compr), GFP_KERNEL); |
| 333 | if (compr == NULL) { |
| 334 | snd_printk(KERN_ERR "Cannot allocate compr\n"); |
| 335 | return -ENOMEM; |
| 336 | } |
| 337 | |
| 338 | compr->ops = &soc_compr_ops; |
| 339 | mutex_init(&compr->lock); |
| 340 | ret = snd_compress_new(rtd->card->snd_card, num, direction, compr); |
| 341 | if (ret < 0) { |
| 342 | pr_err("compress asoc: can't create compress for codec %s\n", |
| 343 | codec->name); |
| 344 | kfree(compr); |
| 345 | return ret; |
| 346 | } |
| 347 | |
Charles Keepax | 202c8f7 | 2013-01-24 09:44:30 +0000 | [diff] [blame^] | 348 | /* DAPM dai link stream work */ |
| 349 | INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work); |
| 350 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 351 | rtd->compr = compr; |
| 352 | compr->private_data = rtd; |
| 353 | |
| 354 | printk(KERN_INFO "compress asoc: %s <-> %s mapping ok\n", codec_dai->name, |
| 355 | cpu_dai->name); |
| 356 | return ret; |
| 357 | } |