projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ASoC: wm9713: Use WARN_ON() instead of BUG_ON()
[deliverable/linux.git] / sound / soc / mid-x86 / sst_platform.c
CommitLineData
d927fdae
VK		 1/*
2 * sst_platform.c - Intel MID Platform driver
3 *
0cd5751a 4 * Copyright (C) 2010-2013 Intel Corp
d927fdae
VK		 5 * Author: Vinod Koul <vinod.koul@intel.com>
6 * Author: Harsha Priya <priya.harsha@intel.com>
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; version 2 of the License.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
21 *
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23 *
24 *
25 */
26#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27
28#include <linux/slab.h>
29#include <linux/io.h>
da155d5b 30#include <linux/module.h>
d927fdae
VK		 31#include <sound/core.h>
32#include <sound/pcm.h>
33#include <sound/pcm_params.h>
34#include <sound/soc.h>
c514a911 35#include <sound/compress_driver.h>
d927fdae
VK		 36#include "sst_platform.h"
37
03c33042
VK		 38static struct sst_device *sst;
39static DEFINE_MUTEX(sst_lock);
40
41int sst_register_dsp(struct sst_device *dev)
42{
43 BUG_ON(!dev);
44 if (!try_module_get(dev->dev->driver->owner))
45 return -ENODEV;
46 mutex_lock(&sst_lock);
47 if (sst) {
48 pr_err("we already have a device %s\n", sst->name);
49 module_put(dev->dev->driver->owner);
50 mutex_unlock(&sst_lock);
51 return -EEXIST;
52 }
53 pr_debug("registering device %s\n", dev->name);
54 sst = dev;
55 mutex_unlock(&sst_lock);
56 return 0;
57}
58EXPORT_SYMBOL_GPL(sst_register_dsp);
59
60int sst_unregister_dsp(struct sst_device *dev)
61{
62 BUG_ON(!dev);
63 if (dev != sst)
64 return -EINVAL;
65
66 mutex_lock(&sst_lock);
67
68 if (!sst) {
69 mutex_unlock(&sst_lock);
70 return -EIO;
71 }
72
73 module_put(sst->dev->driver->owner);
74 pr_debug("unreg %s\n", sst->name);
75 sst = NULL;
76 mutex_unlock(&sst_lock);
77 return 0;
78}
79EXPORT_SYMBOL_GPL(sst_unregister_dsp);
80
d927fdae
VK		 81static struct snd_pcm_hardware sst_platform_pcm_hw = {
82 .info = (SNDRV_PCM_INFO_INTERLEAVED |
83 SNDRV_PCM_INFO_DOUBLE |
84 SNDRV_PCM_INFO_PAUSE |
85 SNDRV_PCM_INFO_RESUME |
86 SNDRV_PCM_INFO_MMAP|
87 SNDRV_PCM_INFO_MMAP_VALID |
88 SNDRV_PCM_INFO_BLOCK_TRANSFER |
89 SNDRV_PCM_INFO_SYNC_START),
90 .formats = (SNDRV_PCM_FMTBIT_S16 | SNDRV_PCM_FMTBIT_U16 |
91 SNDRV_PCM_FMTBIT_S24 | SNDRV_PCM_FMTBIT_U24 |
92 SNDRV_PCM_FMTBIT_S32 | SNDRV_PCM_FMTBIT_U32),
93 .rates = (SNDRV_PCM_RATE_8000|
94 SNDRV_PCM_RATE_44100 |
95 SNDRV_PCM_RATE_48000),
96 .rate_min = SST_MIN_RATE,
97 .rate_max = SST_MAX_RATE,
98 .channels_min = SST_MIN_CHANNEL,
99 .channels_max = SST_MAX_CHANNEL,
100 .buffer_bytes_max = SST_MAX_BUFFER,
101 .period_bytes_min = SST_MIN_PERIOD_BYTES,
102 .period_bytes_max = SST_MAX_PERIOD_BYTES,
103 .periods_min = SST_MIN_PERIODS,
104 .periods_max = SST_MAX_PERIODS,
105 .fifo_size = SST_FIFO_SIZE,
106};
107
108/* MFLD - MSIC */
d1b73287 109static struct snd_soc_dai_driver sst_platform_dai[] = {
d927fdae
VK		 110{
111 .name = "Headset-cpu-dai",
112 .id = 0,
113 .playback = {
114 .channels_min = SST_STEREO,
115 .channels_max = SST_STEREO,
116 .rates = SNDRV_PCM_RATE_48000,
117 .formats = SNDRV_PCM_FMTBIT_S24_LE,
118 },
a7bffdf7
HP		 119 .capture = {
120 .channels_min = 1,
121 .channels_max = 5,
122 .rates = SNDRV_PCM_RATE_48000,
123 .formats = SNDRV_PCM_FMTBIT_S24_LE,
124 },
d927fdae
VK		 125},
126{
127 .name = "Speaker-cpu-dai",
128 .id = 1,
129 .playback = {
130 .channels_min = SST_MONO,
131 .channels_max = SST_STEREO,
132 .rates = SNDRV_PCM_RATE_48000,
133 .formats = SNDRV_PCM_FMTBIT_S24_LE,
134 },
135},
136{
137 .name = "Vibra1-cpu-dai",
138 .id = 2,
139 .playback = {
140 .channels_min = SST_MONO,
141 .channels_max = SST_MONO,
142 .rates = SNDRV_PCM_RATE_48000,
143 .formats = SNDRV_PCM_FMTBIT_S24_LE,
144 },
145},
146{
147 .name = "Vibra2-cpu-dai",
148 .id = 3,
149 .playback = {
150 .channels_min = SST_MONO,
151 .channels_max = SST_STEREO,
152 .rates = SNDRV_PCM_RATE_48000,
153 .formats = SNDRV_PCM_FMTBIT_S24_LE,
154 },
155},
c514a911
VK		 156{
157 .name = "Compress-cpu-dai",
158 .compress_dai = 1,
159 .playback = {
160 .channels_min = SST_STEREO,
161 .channels_max = SST_STEREO,
162 .rates = SNDRV_PCM_RATE_44100|SNDRV_PCM_RATE_48000,
163 .formats = SNDRV_PCM_FMTBIT_S16_LE,
164 },
165},
d927fdae 166};
5c68536f 167
b1c36861
KM		 168static const struct snd_soc_component_driver sst_component = {
169 .name = "sst",
170};
171
d927fdae 172/* helper functions */
5c68536f
HP		 173static inline void sst_set_stream_status(struct sst_runtime_stream *stream,
174 int state)
175{
d89b0a13
LG		 176 unsigned long flags;
177 spin_lock_irqsave(&stream->status_lock, flags);
5c68536f 178 stream->stream_status = state;
d89b0a13 179 spin_unlock_irqrestore(&stream->status_lock, flags);
5c68536f
HP		 180}
181
182static inline int sst_get_stream_status(struct sst_runtime_stream *stream)
183{
184 int state;
d89b0a13 185 unsigned long flags;
5c68536f 186
d89b0a13 187 spin_lock_irqsave(&stream->status_lock, flags);
5c68536f 188 state = stream->stream_status;
d89b0a13 189 spin_unlock_irqrestore(&stream->status_lock, flags);
5c68536f
HP		 190 return state;
191}
192
193static void sst_fill_pcm_params(struct snd_pcm_substream *substream,
03c33042 194 struct sst_pcm_params *param)
5c68536f
HP		 195{
196
03c33042
VK		 197 param->codec = SST_CODEC_TYPE_PCM;
198 param->num_chan = (u8) substream->runtime->channels;
199 param->pcm_wd_sz = substream->runtime->sample_bits;
200 param->reserved = 0;
201 param->sfreq = substream->runtime->rate;
202 param->ring_buffer_size = snd_pcm_lib_buffer_bytes(substream);
203 param->period_count = substream->runtime->period_size;
204 param->ring_buffer_addr = virt_to_phys(substream->dma_buffer.area);
205 pr_debug("period_cnt = %d\n", param->period_count);
206 pr_debug("sfreq= %d, wd_sz = %d\n", param->sfreq, param->pcm_wd_sz);
5c68536f
HP		 207}
208
d927fdae
VK		 209static int sst_platform_alloc_stream(struct snd_pcm_substream *substream)
210{
211 struct sst_runtime_stream *stream =
212 substream->runtime->private_data;
03c33042
VK		 213 struct sst_pcm_params param = {0};
214 struct sst_stream_params str_params = {0};
d927fdae
VK		 215 int ret_val;
216
217 /* set codec params and inform SST driver the same */
5c68536f 218 sst_fill_pcm_params(substream, &param);
d927fdae 219 substream->runtime->dma_area = substream->dma_buffer.area;
d927fdae 220 str_params.sparams = param;
03c33042 221 str_params.codec = param.codec;
d927fdae
VK		 222 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
223 str_params.ops = STREAM_OPS_PLAYBACK;
224 str_params.device_type = substream->pcm->device + 1;
225 pr_debug("Playbck stream,Device %d\n",
226 substream->pcm->device);
227 } else {
228 str_params.ops = STREAM_OPS_CAPTURE;
229 str_params.device_type = SND_SST_DEVICE_CAPTURE;
230 pr_debug("Capture stream,Device %d\n",
231 substream->pcm->device);
232 }
03c33042 233 ret_val = stream->ops->open(&str_params);
d927fdae
VK		 234 pr_debug("SST_SND_PLAY/CAPTURE ret_val = %x\n", ret_val);
235 if (ret_val < 0)
236 return ret_val;
237
238 stream->stream_info.str_id = ret_val;
239 pr_debug("str id : %d\n", stream->stream_info.str_id);
d927fdae
VK		 240 return ret_val;
241}
242
d927fdae
VK		 243static void sst_period_elapsed(void *mad_substream)
244{
245 struct snd_pcm_substream *substream = mad_substream;
246 struct sst_runtime_stream *stream;
5c68536f 247 int status;
d927fdae
VK		 248
249 if (!substream || !substream->runtime)
250 return;
251 stream = substream->runtime->private_data;
252 if (!stream)
253 return;
5c68536f
HP		 254 status = sst_get_stream_status(stream);
255 if (status != SST_PLATFORM_RUNNING)
d927fdae 256 return;
d927fdae 257 snd_pcm_period_elapsed(substream);
d927fdae
VK		 258}
259
260static int sst_platform_init_stream(struct snd_pcm_substream *substream)
261{
262 struct sst_runtime_stream *stream =
263 substream->runtime->private_data;
264 int ret_val;
265
266 pr_debug("setting buffer ptr param\n");
5c68536f 267 sst_set_stream_status(stream, SST_PLATFORM_INIT);
d927fdae
VK		 268 stream->stream_info.period_elapsed = sst_period_elapsed;
269 stream->stream_info.mad_substream = substream;
270 stream->stream_info.buffer_ptr = 0;
271 stream->stream_info.sfreq = substream->runtime->rate;
03c33042 272 ret_val = stream->ops->device_control(
a211701e 273 SST_SND_STREAM_INIT, &stream->stream_info);
d927fdae
VK		 274 if (ret_val)
275 pr_err("control_set ret error %d\n", ret_val);
276 return ret_val;
277
278}
279/* end -- helper functions */
280
281static int sst_platform_open(struct snd_pcm_substream *substream)
282{
22be504a 283 struct snd_pcm_runtime *runtime = substream->runtime;
d927fdae 284 struct sst_runtime_stream *stream;
c45471ea 285 int ret_val;
d927fdae
VK		 286
287 pr_debug("sst_platform_open called\n");
22be504a
LG		 288
289 snd_soc_set_runtime_hwparams(substream, &sst_platform_pcm_hw);
283e42e0
LG		 290 ret_val = snd_pcm_hw_constraint_integer(runtime,
291 SNDRV_PCM_HW_PARAM_PERIODS);
292 if (ret_val < 0)
293 return ret_val;
22be504a 294
d927fdae
VK		 295 stream = kzalloc(sizeof(*stream), GFP_KERNEL);
296 if (!stream)
297 return -ENOMEM;
d927fdae 298 spin_lock_init(&stream->status_lock);
03c33042
VK		 299
300 /* get the sst ops */
301 mutex_lock(&sst_lock);
302 if (!sst) {
303 pr_err("no device available to run\n");
304 mutex_unlock(&sst_lock);
d927fdae 305 kfree(stream);
03c33042 306 return -ENODEV;
d927fdae 307 }
03c33042
VK		 308 if (!try_module_get(sst->dev->driver->owner)) {
309 mutex_unlock(&sst_lock);
83a3fd3c 310 kfree(stream);
03c33042 311 return -ENODEV;
d927fdae 312 }
03c33042
VK		 313 stream->ops = sst->ops;
314 mutex_unlock(&sst_lock);
315
316 stream->stream_info.str_id = 0;
317 sst_set_stream_status(stream, SST_PLATFORM_INIT);
318 stream->stream_info.mad_substream = substream;
319 /* allocate memory for SST API set */
d927fdae 320 runtime->private_data = stream;
283e42e0
LG		 321
322 return 0;
d927fdae
VK		 323}
324
325static int sst_platform_close(struct snd_pcm_substream *substream)
326{
327 struct sst_runtime_stream *stream;
328 int ret_val = 0, str_id;
329
330 pr_debug("sst_platform_close called\n");
d927fdae
VK		 331 stream = substream->runtime->private_data;
332 str_id = stream->stream_info.str_id;
d927fdae 333 if (str_id)
03c33042
VK		 334 ret_val = stream->ops->close(str_id);
335 module_put(sst->dev->driver->owner);
d927fdae
VK		 336 kfree(stream);
337 return ret_val;
338}
339
340static int sst_platform_pcm_prepare(struct snd_pcm_substream *substream)
341{
342 struct sst_runtime_stream *stream;
343 int ret_val = 0, str_id;
344
345 pr_debug("sst_platform_pcm_prepare called\n");
d927fdae
VK		 346 stream = substream->runtime->private_data;
347 str_id = stream->stream_info.str_id;
348 if (stream->stream_info.str_id) {
03c33042
VK		 349 ret_val = stream->ops->device_control(
350 SST_SND_DROP, &str_id);
d927fdae
VK		 351 return ret_val;
352 }
353
354 ret_val = sst_platform_alloc_stream(substream);
355 if (ret_val < 0)
356 return ret_val;
357 snprintf(substream->pcm->id, sizeof(substream->pcm->id),
358 "%d", stream->stream_info.str_id);
359
360 ret_val = sst_platform_init_stream(substream);
361 if (ret_val)
362 return ret_val;
363 substream->runtime->hw.info = SNDRV_PCM_INFO_BLOCK_TRANSFER;
364 return ret_val;
365}
366
367static int sst_platform_pcm_trigger(struct snd_pcm_substream *substream,
368 int cmd)
369{
370 int ret_val = 0, str_id;
371 struct sst_runtime_stream *stream;
a211701e 372 int str_cmd, status;
d927fdae
VK		 373
374 pr_debug("sst_platform_pcm_trigger called\n");
d927fdae 375 stream = substream->runtime->private_data;
d927fdae 376 str_id = stream->stream_info.str_id;
d927fdae
VK		 377 switch (cmd) {
378 case SNDRV_PCM_TRIGGER_START:
379 pr_debug("sst: Trigger Start\n");
a211701e
HP		 380 str_cmd = SST_SND_START;
381 status = SST_PLATFORM_RUNNING;
d927fdae
VK		 382 stream->stream_info.mad_substream = substream;
383 break;
384 case SNDRV_PCM_TRIGGER_STOP:
385 pr_debug("sst: in stop\n");
a211701e
HP		 386 str_cmd = SST_SND_DROP;
387 status = SST_PLATFORM_DROPPED;
d927fdae
VK		 388 break;
389 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
390 pr_debug("sst: in pause\n");
a211701e
HP		 391 str_cmd = SST_SND_PAUSE;
392 status = SST_PLATFORM_PAUSED;
d927fdae
VK		 393 break;
394 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
395 pr_debug("sst: in pause release\n");
a211701e
HP		 396 str_cmd = SST_SND_RESUME;
397 status = SST_PLATFORM_RUNNING;
d927fdae
VK		 398 break;
399 default:
a211701e 400 return -EINVAL;
d927fdae 401 }
03c33042 402 ret_val = stream->ops->device_control(str_cmd, &str_id);
a211701e
HP		 403 if (!ret_val)
404 sst_set_stream_status(stream, status);
405
d927fdae
VK		 406 return ret_val;
407}
408
409
410static snd_pcm_uframes_t sst_platform_pcm_pointer
411 (struct snd_pcm_substream *substream)
412{
413 struct sst_runtime_stream *stream;
5c68536f 414 int ret_val, status;
d927fdae
VK		 415 struct pcm_stream_info *str_info;
416
d927fdae 417 stream = substream->runtime->private_data;
5c68536f
HP		 418 status = sst_get_stream_status(stream);
419 if (status == SST_PLATFORM_INIT)
d927fdae 420 return 0;
d927fdae 421 str_info = &stream->stream_info;
03c33042 422 ret_val = stream->ops->device_control(
d927fdae
VK		 423 SST_SND_BUFFER_POINTER, str_info);
424 if (ret_val) {
425 pr_err("sst: error code = %d\n", ret_val);
426 return ret_val;
427 }
d927fdae
VK		 428 return stream->stream_info.buffer_ptr;
429}
430
5b499f8b
VK		 431static int sst_platform_pcm_hw_params(struct snd_pcm_substream *substream,
432 struct snd_pcm_hw_params *params)
433{
434 snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
435 memset(substream->runtime->dma_area, 0, params_buffer_bytes(params));
436
437 return 0;
438}
d927fdae 439
9ab88434 440static int sst_platform_pcm_hw_free(struct snd_pcm_substream *substream)
441{
442 return snd_pcm_lib_free_pages(substream);
443}
444
d927fdae
VK		 445static struct snd_pcm_ops sst_platform_ops = {
446 .open = sst_platform_open,
447 .close = sst_platform_close,
448 .ioctl = snd_pcm_lib_ioctl,
449 .prepare = sst_platform_pcm_prepare,
450 .trigger = sst_platform_pcm_trigger,
451 .pointer = sst_platform_pcm_pointer,
5b499f8b 452 .hw_params = sst_platform_pcm_hw_params,
9ab88434 453 .hw_free = sst_platform_pcm_hw_free,
d927fdae
VK		 454};
455
456static void sst_pcm_free(struct snd_pcm *pcm)
457{
458 pr_debug("sst_pcm_free called\n");
459 snd_pcm_lib_preallocate_free_for_all(pcm);
460}
461
8faa8c1a 462static int sst_pcm_new(struct snd_soc_pcm_runtime *rtd)
d927fdae 463{
552d1ef6 464 struct snd_pcm *pcm = rtd->pcm;
d927fdae
VK		 465 int retval = 0;
466
467 pr_debug("sst_pcm_new called\n");
25e9e756
JE		 468 if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream ||
469 pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
d927fdae
VK		 470 retval = snd_pcm_lib_preallocate_pages_for_all(pcm,
471 SNDRV_DMA_TYPE_CONTINUOUS,
472 snd_dma_continuous_data(GFP_KERNEL),
473 SST_MIN_BUFFER, SST_MAX_BUFFER);
474 if (retval) {
475 pr_err("dma buffer allocationf fail\n");
476 return retval;
477 }
478 }
d927fdae
VK		 479 return retval;
480}
c514a911
VK		 481
482/* compress stream operations */
483static void sst_compr_fragment_elapsed(void *arg)
484{
485 struct snd_compr_stream *cstream = (struct snd_compr_stream *)arg;
486
487 pr_debug("fragment elapsed by driver\n");
488 if (cstream)
489 snd_compr_fragment_elapsed(cstream);
490}
491
492static int sst_platform_compr_open(struct snd_compr_stream *cstream)
493{
494
495 int ret_val = 0;
496 struct snd_compr_runtime *runtime = cstream->runtime;
497 struct sst_runtime_stream *stream;
498
499 stream = kzalloc(sizeof(*stream), GFP_KERNEL);
500 if (!stream)
501 return -ENOMEM;
502
503 spin_lock_init(&stream->status_lock);
504
505 /* get the sst ops */
506 if (!sst || !try_module_get(sst->dev->driver->owner)) {
507 pr_err("no device available to run\n");
508 ret_val = -ENODEV;
509 goto out_ops;
510 }
511 stream->compr_ops = sst->compr_ops;
512
513 stream->id = 0;
514 sst_set_stream_status(stream, SST_PLATFORM_INIT);
515 runtime->private_data = stream;
516 return 0;
517out_ops:
518 kfree(stream);
519 return ret_val;
520}
521
522static int sst_platform_compr_free(struct snd_compr_stream *cstream)
523{
524 struct sst_runtime_stream *stream;
525 int ret_val = 0, str_id;
526
527 stream = cstream->runtime->private_data;
528 /*need to check*/
529 str_id = stream->id;
530 if (str_id)
531 ret_val = stream->compr_ops->close(str_id);
532 module_put(sst->dev->driver->owner);
533 kfree(stream);
534 pr_debug("%s: %d\n", __func__, ret_val);
535 return 0;
536}
537
538static int sst_platform_compr_set_params(struct snd_compr_stream *cstream,
539 struct snd_compr_params *params)
540{
541 struct sst_runtime_stream *stream;
542 int retval;
543 struct snd_sst_params str_params;
544 struct sst_compress_cb cb;
545
546 stream = cstream->runtime->private_data;
547 /* construct fw structure for this*/
548 memset(&str_params, 0, sizeof(str_params));
549
550 str_params.ops = STREAM_OPS_PLAYBACK;
551 str_params.stream_type = SST_STREAM_TYPE_MUSIC;
552 str_params.device_type = SND_SST_DEVICE_COMPRESS;
553
554 switch (params->codec.id) {
555 case SND_AUDIOCODEC_MP3: {
556 str_params.codec = SST_CODEC_TYPE_MP3;
557 str_params.sparams.uc.mp3_params.codec = SST_CODEC_TYPE_MP3;
558 str_params.sparams.uc.mp3_params.num_chan = params->codec.ch_in;
559 str_params.sparams.uc.mp3_params.pcm_wd_sz = 16;
560 break;
561 }
562
563 case SND_AUDIOCODEC_AAC: {
564 str_params.codec = SST_CODEC_TYPE_AAC;
565 str_params.sparams.uc.aac_params.codec = SST_CODEC_TYPE_AAC;
566 str_params.sparams.uc.aac_params.num_chan = params->codec.ch_in;
567 str_params.sparams.uc.aac_params.pcm_wd_sz = 16;
568 if (params->codec.format == SND_AUDIOSTREAMFORMAT_MP4ADTS)
569 str_params.sparams.uc.aac_params.bs_format =
570 AAC_BIT_STREAM_ADTS;
571 else if (params->codec.format == SND_AUDIOSTREAMFORMAT_RAW)
572 str_params.sparams.uc.aac_params.bs_format =
573 AAC_BIT_STREAM_RAW;
574 else {
575 pr_err("Undefined format%d\n", params->codec.format);
576 return -EINVAL;
577 }
578 str_params.sparams.uc.aac_params.externalsr =
579 params->codec.sample_rate;
580 break;
581 }
582
583 default:
584 pr_err("codec not supported, id =%d\n", params->codec.id);
585 return -EINVAL;
586 }
587
588 str_params.aparams.ring_buf_info[0].addr =
589 virt_to_phys(cstream->runtime->buffer);
590 str_params.aparams.ring_buf_info[0].size =
591 cstream->runtime->buffer_size;
592 str_params.aparams.sg_count = 1;
593 str_params.aparams.frag_size = cstream->runtime->fragment_size;
594
595 cb.param = cstream;
596 cb.compr_cb = sst_compr_fragment_elapsed;
597
598 retval = stream->compr_ops->open(&str_params, &cb);
599 if (retval < 0) {
600 pr_err("stream allocation failed %d\n", retval);
601 return retval;
602 }
603
604 stream->id = retval;
605 return 0;
606}
607
608static int sst_platform_compr_trigger(struct snd_compr_stream *cstream, int cmd)
609{
610 struct sst_runtime_stream *stream =
611 cstream->runtime->private_data;
612
613 return stream->compr_ops->control(cmd, stream->id);
614}
615
616static int sst_platform_compr_pointer(struct snd_compr_stream *cstream,
617 struct snd_compr_tstamp *tstamp)
618{
619 struct sst_runtime_stream *stream;
620
621 stream = cstream->runtime->private_data;
622 stream->compr_ops->tstamp(stream->id, tstamp);
623 tstamp->byte_offset = tstamp->copied_total %
624 (u32)cstream->runtime->buffer_size;
625 pr_debug("calc bytes offset/copied bytes as %d\n", tstamp->byte_offset);
626 return 0;
627}
628
629static int sst_platform_compr_ack(struct snd_compr_stream *cstream,
630 size_t bytes)
631{
632 struct sst_runtime_stream *stream;
633
634 stream = cstream->runtime->private_data;
635 stream->compr_ops->ack(stream->id, (unsigned long)bytes);
636 stream->bytes_written += bytes;
637
638 return 0;
639}
640
641static int sst_platform_compr_get_caps(struct snd_compr_stream *cstream,
642 struct snd_compr_caps *caps)
643{
644 struct sst_runtime_stream *stream =
645 cstream->runtime->private_data;
646
647 return stream->compr_ops->get_caps(caps);
648}
649
650static int sst_platform_compr_get_codec_caps(struct snd_compr_stream *cstream,
651 struct snd_compr_codec_caps *codec)
652{
653 struct sst_runtime_stream *stream =
654 cstream->runtime->private_data;
655
656 return stream->compr_ops->get_codec_caps(codec);
657}
658
0cd5751a
VK		 659static int sst_platform_compr_set_metadata(struct snd_compr_stream *cstream,
660 struct snd_compr_metadata *metadata)
661{
662 struct sst_runtime_stream *stream =
663 cstream->runtime->private_data;
664
665 return stream->compr_ops->set_metadata(stream->id, metadata);
666}
667
c514a911
VK		 668static struct snd_compr_ops sst_platform_compr_ops = {
669
670 .open = sst_platform_compr_open,
671 .free = sst_platform_compr_free,
672 .set_params = sst_platform_compr_set_params,
0cd5751a 673 .set_metadata = sst_platform_compr_set_metadata,
c514a911
VK		 674 .trigger = sst_platform_compr_trigger,
675 .pointer = sst_platform_compr_pointer,
676 .ack = sst_platform_compr_ack,
677 .get_caps = sst_platform_compr_get_caps,
678 .get_codec_caps = sst_platform_compr_get_codec_caps,
679};
680
8faa8c1a 681static struct snd_soc_platform_driver sst_soc_platform_drv = {
d927fdae 682 .ops = &sst_platform_ops,
c514a911 683 .compr_ops = &sst_platform_compr_ops,
d927fdae
VK		 684 .pcm_new = sst_pcm_new,
685 .pcm_free = sst_pcm_free,
686};
687
688static int sst_platform_probe(struct platform_device *pdev)
689{
690 int ret;
691
692 pr_debug("sst_platform_probe called\n");
03c33042 693 sst = NULL;
d927fdae
VK		 694 ret = snd_soc_register_platform(&pdev->dev, &sst_soc_platform_drv);
695 if (ret) {
696 pr_err("registering soc platform failed\n");
697 return ret;
698 }
5c68536f 699
b1c36861 700 ret = snd_soc_register_component(&pdev->dev, &sst_component,
d927fdae
VK		 701 sst_platform_dai, ARRAY_SIZE(sst_platform_dai));
702 if (ret) {
703 pr_err("registering cpu dais failed\n");
704 snd_soc_unregister_platform(&pdev->dev);
705 }
706 return ret;
707}
708
709static int sst_platform_remove(struct platform_device *pdev)
710{
711
b1c36861 712 snd_soc_unregister_component(&pdev->dev);
d927fdae 713 snd_soc_unregister_platform(&pdev->dev);
25985edc 714 pr_debug("sst_platform_remove success\n");
d927fdae
VK		 715 return 0;
716}
717
718static struct platform_driver sst_platform_driver = {
719 .driver = {
720 .name = "sst-platform",
721 .owner = THIS_MODULE,
722 },
723 .probe = sst_platform_probe,
724 .remove = sst_platform_remove,
725};
726
29515d62 727module_platform_driver(sst_platform_driver);
d927fdae
VK		 728
729MODULE_DESCRIPTION("ASoC Intel(R) MID Platform driver");
730MODULE_AUTHOR("Vinod Koul <vinod.koul@intel.com>");
731MODULE_AUTHOR("Harsha Priya <priya.harsha@intel.com>");
732MODULE_LICENSE("GPL v2");
f5c6b2aa 733MODULE_ALIAS("platform:sst-platform");
Linux kernel - Deliverables
This page took 0.161354 seconds and 5 git commands to generate.