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 | |
Mark Brown | da18396 | 2013-02-06 15:44:07 +0000 | [diff] [blame] | 124 | snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction); |
| 125 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 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 | |
Mark Brown | da18396 | 2013-02-06 15:44:07 +0000 | [diff] [blame] | 182 | switch (cmd) { |
| 183 | case SNDRV_PCM_TRIGGER_START: |
| 184 | snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction); |
| 185 | break; |
| 186 | case SNDRV_PCM_TRIGGER_STOP: |
| 187 | snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction); |
| 188 | break; |
Mark Brown | e38b9b7 | 2013-02-06 13:52:42 +0000 | [diff] [blame] | 189 | } |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 190 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 191 | out: |
| 192 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 193 | return ret; |
| 194 | } |
| 195 | |
| 196 | static int soc_compr_set_params(struct snd_compr_stream *cstream, |
| 197 | struct snd_compr_params *params) |
| 198 | { |
| 199 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 200 | struct snd_soc_platform *platform = rtd->platform; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 201 | int ret = 0; |
| 202 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 203 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 204 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 205 | /* first we call set_params for the platform driver |
| 206 | * this should configure the soc side |
| 207 | * if the machine has compressed ops then we call that as well |
| 208 | * expectation is that platform and machine will configure everything |
| 209 | * for this compress path, like configuring pcm port for codec |
| 210 | */ |
| 211 | if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) { |
| 212 | ret = platform->driver->compr_ops->set_params(cstream, params); |
| 213 | if (ret < 0) |
Charles Keepax | fa40ef2 | 2013-03-27 16:39:01 +0000 | [diff] [blame] | 214 | goto err; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 215 | } |
| 216 | |
| 217 | if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) { |
| 218 | ret = rtd->dai_link->compr_ops->set_params(cstream); |
| 219 | if (ret < 0) |
Charles Keepax | fa40ef2 | 2013-03-27 16:39:01 +0000 | [diff] [blame] | 220 | goto err; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 221 | } |
| 222 | |
| 223 | snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK, |
| 224 | SND_SOC_DAPM_STREAM_START); |
| 225 | |
Charles Keepax | fa40ef2 | 2013-03-27 16:39:01 +0000 | [diff] [blame] | 226 | /* cancel any delayed stream shutdown that is pending */ |
| 227 | rtd->pop_wait = 0; |
| 228 | mutex_unlock(&rtd->pcm_mutex); |
| 229 | |
| 230 | cancel_delayed_work_sync(&rtd->delayed_work); |
| 231 | |
| 232 | return ret; |
| 233 | |
| 234 | err: |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 235 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 236 | return ret; |
| 237 | } |
| 238 | |
| 239 | static int soc_compr_get_params(struct snd_compr_stream *cstream, |
| 240 | struct snd_codec *params) |
| 241 | { |
| 242 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 243 | struct snd_soc_platform *platform = rtd->platform; |
| 244 | int ret = 0; |
| 245 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 246 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 247 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 248 | if (platform->driver->compr_ops && platform->driver->compr_ops->get_params) |
| 249 | ret = platform->driver->compr_ops->get_params(cstream, params); |
| 250 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 251 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 252 | return ret; |
| 253 | } |
| 254 | |
| 255 | static int soc_compr_get_caps(struct snd_compr_stream *cstream, |
| 256 | struct snd_compr_caps *caps) |
| 257 | { |
| 258 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 259 | struct snd_soc_platform *platform = rtd->platform; |
| 260 | int ret = 0; |
| 261 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 262 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 263 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 264 | if (platform->driver->compr_ops && platform->driver->compr_ops->get_caps) |
| 265 | ret = platform->driver->compr_ops->get_caps(cstream, caps); |
| 266 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 267 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 268 | return ret; |
| 269 | } |
| 270 | |
| 271 | static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream, |
| 272 | struct snd_compr_codec_caps *codec) |
| 273 | { |
| 274 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 275 | struct snd_soc_platform *platform = rtd->platform; |
| 276 | int ret = 0; |
| 277 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 278 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 279 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 280 | if (platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps) |
| 281 | ret = platform->driver->compr_ops->get_codec_caps(cstream, codec); |
| 282 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 283 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 284 | return ret; |
| 285 | } |
| 286 | |
| 287 | static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes) |
| 288 | { |
| 289 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 290 | struct snd_soc_platform *platform = rtd->platform; |
| 291 | int ret = 0; |
| 292 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 293 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 294 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 295 | if (platform->driver->compr_ops && platform->driver->compr_ops->ack) |
| 296 | ret = platform->driver->compr_ops->ack(cstream, bytes); |
| 297 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 298 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 299 | return ret; |
| 300 | } |
| 301 | |
| 302 | static int soc_compr_pointer(struct snd_compr_stream *cstream, |
| 303 | struct snd_compr_tstamp *tstamp) |
| 304 | { |
| 305 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 306 | struct snd_soc_platform *platform = rtd->platform; |
| 307 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 308 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 309 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 310 | if (platform->driver->compr_ops && platform->driver->compr_ops->pointer) |
| 311 | platform->driver->compr_ops->pointer(cstream, tstamp); |
| 312 | |
Charles Keepax | 15e2e61 | 2013-01-24 09:44:29 +0000 | [diff] [blame] | 313 | mutex_unlock(&rtd->pcm_mutex); |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 314 | return 0; |
| 315 | } |
| 316 | |
Charles Keepax | 1f88eb0 | 2013-02-05 10:41:47 +0000 | [diff] [blame] | 317 | static int soc_compr_copy(struct snd_compr_stream *cstream, |
| 318 | const char __user *buf, size_t count) |
| 319 | { |
| 320 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; |
| 321 | struct snd_soc_platform *platform = rtd->platform; |
| 322 | int ret = 0; |
| 323 | |
| 324 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
| 325 | |
| 326 | if (platform->driver->compr_ops && platform->driver->compr_ops->copy) |
| 327 | ret = platform->driver->compr_ops->copy(cstream, buf, count); |
| 328 | |
| 329 | mutex_unlock(&rtd->pcm_mutex); |
| 330 | return ret; |
| 331 | } |
| 332 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 333 | /* ASoC Compress operations */ |
| 334 | static struct snd_compr_ops soc_compr_ops = { |
| 335 | .open = soc_compr_open, |
| 336 | .free = soc_compr_free, |
| 337 | .set_params = soc_compr_set_params, |
| 338 | .get_params = soc_compr_get_params, |
| 339 | .trigger = soc_compr_trigger, |
| 340 | .pointer = soc_compr_pointer, |
| 341 | .ack = soc_compr_ack, |
| 342 | .get_caps = soc_compr_get_caps, |
| 343 | .get_codec_caps = soc_compr_get_codec_caps |
| 344 | }; |
| 345 | |
| 346 | /* create a new compress */ |
| 347 | int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num) |
| 348 | { |
| 349 | struct snd_soc_codec *codec = rtd->codec; |
Charles Keepax | 1f88eb0 | 2013-02-05 10:41:47 +0000 | [diff] [blame] | 350 | struct snd_soc_platform *platform = rtd->platform; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 351 | struct snd_soc_dai *codec_dai = rtd->codec_dai; |
| 352 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; |
| 353 | struct snd_compr *compr; |
| 354 | char new_name[64]; |
| 355 | int ret = 0, direction = 0; |
| 356 | |
| 357 | /* check client and interface hw capabilities */ |
| 358 | snprintf(new_name, sizeof(new_name), "%s %s-%d", |
| 359 | rtd->dai_link->stream_name, codec_dai->name, num); |
| 360 | direction = SND_COMPRESS_PLAYBACK; |
| 361 | compr = kzalloc(sizeof(*compr), GFP_KERNEL); |
| 362 | if (compr == NULL) { |
| 363 | snd_printk(KERN_ERR "Cannot allocate compr\n"); |
| 364 | return -ENOMEM; |
| 365 | } |
| 366 | |
Charles Keepax | 1f88eb0 | 2013-02-05 10:41:47 +0000 | [diff] [blame] | 367 | compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops), |
| 368 | GFP_KERNEL); |
| 369 | if (compr->ops == NULL) { |
| 370 | dev_err(rtd->card->dev, "Cannot allocate compressed ops\n"); |
| 371 | ret = -ENOMEM; |
| 372 | goto compr_err; |
| 373 | } |
| 374 | memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops)); |
| 375 | |
| 376 | /* Add copy callback for not memory mapped DSPs */ |
| 377 | if (platform->driver->compr_ops && platform->driver->compr_ops->copy) |
| 378 | compr->ops->copy = soc_compr_copy; |
| 379 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 380 | mutex_init(&compr->lock); |
| 381 | ret = snd_compress_new(rtd->card->snd_card, num, direction, compr); |
| 382 | if (ret < 0) { |
| 383 | pr_err("compress asoc: can't create compress for codec %s\n", |
| 384 | codec->name); |
Charles Keepax | 1f88eb0 | 2013-02-05 10:41:47 +0000 | [diff] [blame] | 385 | goto compr_err; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 386 | } |
| 387 | |
Charles Keepax | 202c8f7 | 2013-01-24 09:44:30 +0000 | [diff] [blame] | 388 | /* DAPM dai link stream work */ |
| 389 | INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work); |
| 390 | |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 391 | rtd->compr = compr; |
| 392 | compr->private_data = rtd; |
| 393 | |
| 394 | printk(KERN_INFO "compress asoc: %s <-> %s mapping ok\n", codec_dai->name, |
| 395 | cpu_dai->name); |
| 396 | return ret; |
Charles Keepax | 1f88eb0 | 2013-02-05 10:41:47 +0000 | [diff] [blame] | 397 | |
| 398 | compr_err: |
| 399 | kfree(compr); |
| 400 | return ret; |
Namarta Kohli | 1245b70 | 2012-08-16 17:10:41 +0530 | [diff] [blame] | 401 | } |