2 * Intel SST Haswell/Broadwell PCM Support
4 * Copyright (C) 2013, Intel Corporation. All rights reserved.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License version
8 * 2 as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
17 #include <linux/module.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/slab.h>
20 #include <linux/delay.h>
21 #include <linux/pm_runtime.h>
23 #include <asm/pgtable.h>
24 #include <sound/core.h>
25 #include <sound/pcm.h>
26 #include <sound/pcm_params.h>
27 #include <sound/dmaengine_pcm.h>
28 #include <sound/soc.h>
29 #include <sound/tlv.h>
30 #include <sound/compress_driver.h>
32 #include "sst-haswell-ipc.h"
33 #include "sst-dsp-priv.h"
36 #define HSW_PCM_COUNT 6
37 #define HSW_VOLUME_MAX 0x7FFFFFFF /* 0dB */
39 /* simple volume table */
40 static const u32 volume_map
[] = {
74 #define HSW_PCM_PERIODS_MAX 64
75 #define HSW_PCM_PERIODS_MIN 2
77 #define HSW_PCM_DAI_ID_SYSTEM 0
78 #define HSW_PCM_DAI_ID_OFFLOAD0 1
79 #define HSW_PCM_DAI_ID_OFFLOAD1 2
80 #define HSW_PCM_DAI_ID_LOOPBACK 3
83 static const struct snd_pcm_hardware hsw_pcm_hardware
= {
84 .info
= SNDRV_PCM_INFO_MMAP
|
85 SNDRV_PCM_INFO_MMAP_VALID
|
86 SNDRV_PCM_INFO_INTERLEAVED
|
87 SNDRV_PCM_INFO_PAUSE
|
88 SNDRV_PCM_INFO_RESUME
|
89 SNDRV_PCM_INFO_NO_PERIOD_WAKEUP
,
90 .formats
= SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S24_LE
|
91 SNDRV_PCM_FMTBIT_S32_LE
,
92 .period_bytes_min
= PAGE_SIZE
,
93 .period_bytes_max
= (HSW_PCM_PERIODS_MAX
/ HSW_PCM_PERIODS_MIN
) * PAGE_SIZE
,
94 .periods_min
= HSW_PCM_PERIODS_MIN
,
95 .periods_max
= HSW_PCM_PERIODS_MAX
,
96 .buffer_bytes_max
= HSW_PCM_PERIODS_MAX
* PAGE_SIZE
,
99 struct hsw_pcm_module_map
{
102 enum sst_hsw_module_id mod_id
;
105 /* private data for each PCM DSP stream */
106 struct hsw_pcm_data
{
108 struct sst_hsw_stream
*stream
;
109 struct sst_module_runtime
*runtime
;
110 struct sst_module_runtime_context context
;
111 struct snd_pcm
*hsw_pcm
;
113 struct snd_pcm_substream
*substream
;
114 struct snd_compr_stream
*cstream
;
118 int persistent_offset
;
126 /* private data for the driver */
127 struct hsw_priv_data
{
131 enum hsw_pm_state pm_state
;
132 struct snd_soc_card
*soc_card
;
135 struct snd_dma_buffer dmab
[HSW_PCM_COUNT
][2];
138 struct hsw_pcm_data pcm
[HSW_PCM_COUNT
][2];
142 /* static mappings between PCMs and modules - may be dynamic in future */
143 static struct hsw_pcm_module_map mod_map
[] = {
144 {HSW_PCM_DAI_ID_SYSTEM
, 0, SST_HSW_MODULE_PCM_SYSTEM
},
145 {HSW_PCM_DAI_ID_OFFLOAD0
, 0, SST_HSW_MODULE_PCM
},
146 {HSW_PCM_DAI_ID_OFFLOAD1
, 0, SST_HSW_MODULE_PCM
},
147 {HSW_PCM_DAI_ID_LOOPBACK
, 1, SST_HSW_MODULE_PCM_REFERENCE
},
148 {HSW_PCM_DAI_ID_SYSTEM
, 1, SST_HSW_MODULE_PCM_CAPTURE
},
151 static u32
hsw_notify_pointer(struct sst_hsw_stream
*stream
, void *data
);
153 static inline u32
hsw_mixer_to_ipc(unsigned int value
)
155 if (value
>= ARRAY_SIZE(volume_map
))
156 return volume_map
[0];
158 return volume_map
[value
];
161 static inline unsigned int hsw_ipc_to_mixer(u32 value
)
165 for (i
= 0; i
< ARRAY_SIZE(volume_map
); i
++) {
166 if (volume_map
[i
] >= value
)
173 static int hsw_stream_volume_put(struct snd_kcontrol
*kcontrol
,
174 struct snd_ctl_elem_value
*ucontrol
)
176 struct snd_soc_platform
*platform
= snd_soc_kcontrol_platform(kcontrol
);
177 struct soc_mixer_control
*mc
=
178 (struct soc_mixer_control
*)kcontrol
->private_value
;
179 struct hsw_priv_data
*pdata
=
180 snd_soc_platform_get_drvdata(platform
);
181 struct hsw_pcm_data
*pcm_data
;
182 struct sst_hsw
*hsw
= pdata
->hsw
;
186 dai
= mod_map
[mc
->reg
].dai_id
;
187 stream
= mod_map
[mc
->reg
].stream
;
188 pcm_data
= &pdata
->pcm
[dai
][stream
];
190 mutex_lock(&pcm_data
->mutex
);
191 pm_runtime_get_sync(pdata
->dev
);
193 if (!pcm_data
->stream
) {
194 pcm_data
->volume
[0] =
195 hsw_mixer_to_ipc(ucontrol
->value
.integer
.value
[0]);
196 pcm_data
->volume
[1] =
197 hsw_mixer_to_ipc(ucontrol
->value
.integer
.value
[1]);
198 pm_runtime_mark_last_busy(pdata
->dev
);
199 pm_runtime_put_autosuspend(pdata
->dev
);
200 mutex_unlock(&pcm_data
->mutex
);
204 if (ucontrol
->value
.integer
.value
[0] ==
205 ucontrol
->value
.integer
.value
[1]) {
206 volume
= hsw_mixer_to_ipc(ucontrol
->value
.integer
.value
[0]);
207 /* apply volume value to all channels */
208 sst_hsw_stream_set_volume(hsw
, pcm_data
->stream
, 0, SST_HSW_CHANNELS_ALL
, volume
);
210 volume
= hsw_mixer_to_ipc(ucontrol
->value
.integer
.value
[0]);
211 sst_hsw_stream_set_volume(hsw
, pcm_data
->stream
, 0, 0, volume
);
212 volume
= hsw_mixer_to_ipc(ucontrol
->value
.integer
.value
[1]);
213 sst_hsw_stream_set_volume(hsw
, pcm_data
->stream
, 0, 1, volume
);
216 pm_runtime_mark_last_busy(pdata
->dev
);
217 pm_runtime_put_autosuspend(pdata
->dev
);
218 mutex_unlock(&pcm_data
->mutex
);
222 static int hsw_stream_volume_get(struct snd_kcontrol
*kcontrol
,
223 struct snd_ctl_elem_value
*ucontrol
)
225 struct snd_soc_platform
*platform
= snd_soc_kcontrol_platform(kcontrol
);
226 struct soc_mixer_control
*mc
=
227 (struct soc_mixer_control
*)kcontrol
->private_value
;
228 struct hsw_priv_data
*pdata
=
229 snd_soc_platform_get_drvdata(platform
);
230 struct hsw_pcm_data
*pcm_data
;
231 struct sst_hsw
*hsw
= pdata
->hsw
;
235 dai
= mod_map
[mc
->reg
].dai_id
;
236 stream
= mod_map
[mc
->reg
].stream
;
237 pcm_data
= &pdata
->pcm
[dai
][stream
];
239 mutex_lock(&pcm_data
->mutex
);
240 pm_runtime_get_sync(pdata
->dev
);
242 if (!pcm_data
->stream
) {
243 ucontrol
->value
.integer
.value
[0] =
244 hsw_ipc_to_mixer(pcm_data
->volume
[0]);
245 ucontrol
->value
.integer
.value
[1] =
246 hsw_ipc_to_mixer(pcm_data
->volume
[1]);
247 pm_runtime_mark_last_busy(pdata
->dev
);
248 pm_runtime_put_autosuspend(pdata
->dev
);
249 mutex_unlock(&pcm_data
->mutex
);
253 sst_hsw_stream_get_volume(hsw
, pcm_data
->stream
, 0, 0, &volume
);
254 ucontrol
->value
.integer
.value
[0] = hsw_ipc_to_mixer(volume
);
255 sst_hsw_stream_get_volume(hsw
, pcm_data
->stream
, 0, 1, &volume
);
256 ucontrol
->value
.integer
.value
[1] = hsw_ipc_to_mixer(volume
);
258 pm_runtime_mark_last_busy(pdata
->dev
);
259 pm_runtime_put_autosuspend(pdata
->dev
);
260 mutex_unlock(&pcm_data
->mutex
);
265 static int hsw_volume_put(struct snd_kcontrol
*kcontrol
,
266 struct snd_ctl_elem_value
*ucontrol
)
268 struct snd_soc_platform
*platform
= snd_soc_kcontrol_platform(kcontrol
);
269 struct hsw_priv_data
*pdata
= snd_soc_platform_get_drvdata(platform
);
270 struct sst_hsw
*hsw
= pdata
->hsw
;
273 pm_runtime_get_sync(pdata
->dev
);
275 if (ucontrol
->value
.integer
.value
[0] ==
276 ucontrol
->value
.integer
.value
[1]) {
278 volume
= hsw_mixer_to_ipc(ucontrol
->value
.integer
.value
[0]);
279 sst_hsw_mixer_set_volume(hsw
, 0, SST_HSW_CHANNELS_ALL
, volume
);
282 volume
= hsw_mixer_to_ipc(ucontrol
->value
.integer
.value
[0]);
283 sst_hsw_mixer_set_volume(hsw
, 0, 0, volume
);
285 volume
= hsw_mixer_to_ipc(ucontrol
->value
.integer
.value
[1]);
286 sst_hsw_mixer_set_volume(hsw
, 0, 1, volume
);
289 pm_runtime_mark_last_busy(pdata
->dev
);
290 pm_runtime_put_autosuspend(pdata
->dev
);
294 static int hsw_volume_get(struct snd_kcontrol
*kcontrol
,
295 struct snd_ctl_elem_value
*ucontrol
)
297 struct snd_soc_platform
*platform
= snd_soc_kcontrol_platform(kcontrol
);
298 struct hsw_priv_data
*pdata
= snd_soc_platform_get_drvdata(platform
);
299 struct sst_hsw
*hsw
= pdata
->hsw
;
300 unsigned int volume
= 0;
302 pm_runtime_get_sync(pdata
->dev
);
303 sst_hsw_mixer_get_volume(hsw
, 0, 0, &volume
);
304 ucontrol
->value
.integer
.value
[0] = hsw_ipc_to_mixer(volume
);
306 sst_hsw_mixer_get_volume(hsw
, 0, 1, &volume
);
307 ucontrol
->value
.integer
.value
[1] = hsw_ipc_to_mixer(volume
);
309 pm_runtime_mark_last_busy(pdata
->dev
);
310 pm_runtime_put_autosuspend(pdata
->dev
);
314 /* TLV used by both global and stream volumes */
315 static const DECLARE_TLV_DB_SCALE(hsw_vol_tlv
, -9000, 300, 1);
317 /* System Pin has no volume control */
318 static const struct snd_kcontrol_new hsw_volume_controls
[] = {
319 /* Global DSP volume */
320 SOC_DOUBLE_EXT_TLV("Master Playback Volume", 0, 0, 8,
321 ARRAY_SIZE(volume_map
) - 1, 0,
322 hsw_volume_get
, hsw_volume_put
, hsw_vol_tlv
),
323 /* Offload 0 volume */
324 SOC_DOUBLE_EXT_TLV("Media0 Playback Volume", 1, 0, 8,
325 ARRAY_SIZE(volume_map
) - 1, 0,
326 hsw_stream_volume_get
, hsw_stream_volume_put
, hsw_vol_tlv
),
327 /* Offload 1 volume */
328 SOC_DOUBLE_EXT_TLV("Media1 Playback Volume", 2, 0, 8,
329 ARRAY_SIZE(volume_map
) - 1, 0,
330 hsw_stream_volume_get
, hsw_stream_volume_put
, hsw_vol_tlv
),
331 /* Mic Capture volume */
332 SOC_DOUBLE_EXT_TLV("Mic Capture Volume", 4, 0, 8,
333 ARRAY_SIZE(volume_map
) - 1, 0,
334 hsw_stream_volume_get
, hsw_stream_volume_put
, hsw_vol_tlv
),
337 /* Create DMA buffer page table for DSP */
338 static int create_adsp_page_table(struct snd_pcm_substream
*substream
,
339 struct hsw_priv_data
*pdata
, struct snd_soc_pcm_runtime
*rtd
,
340 unsigned char *dma_area
, size_t size
, int pcm
)
342 struct snd_dma_buffer
*dmab
= snd_pcm_get_dma_buf(substream
);
343 int i
, pages
, stream
= substream
->stream
;
345 pages
= snd_sgbuf_aligned_pages(size
);
347 dev_dbg(rtd
->dev
, "generating page table for %p size 0x%zu pages %d\n",
348 dma_area
, size
, pages
);
350 for (i
= 0; i
< pages
; i
++) {
351 u32 idx
= (((i
<< 2) + i
)) >> 1;
352 u32 pfn
= snd_sgbuf_get_addr(dmab
, i
* PAGE_SIZE
) >> PAGE_SHIFT
;
355 dev_dbg(rtd
->dev
, "pfn i %i idx %d pfn %x\n", i
, idx
, pfn
);
357 pg_table
= (u32
*)(pdata
->dmab
[pcm
][stream
].area
+ idx
);
360 *pg_table
|= (pfn
<< 4);
368 /* this may get called several times by oss emulation */
369 static int hsw_pcm_hw_params(struct snd_pcm_substream
*substream
,
370 struct snd_pcm_hw_params
*params
)
372 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
373 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
374 struct hsw_priv_data
*pdata
=
375 snd_soc_platform_get_drvdata(rtd
->platform
);
376 struct hsw_pcm_data
*pcm_data
;
377 struct sst_hsw
*hsw
= pdata
->hsw
;
378 struct sst_module
*module_data
;
380 struct snd_dma_buffer
*dmab
;
381 enum sst_hsw_stream_type stream_type
;
382 enum sst_hsw_stream_path_id path_id
;
383 u32 rate
, bits
, map
, pages
, module_id
;
387 dai
= mod_map
[rtd
->cpu_dai
->id
].dai_id
;
388 pcm_data
= &pdata
->pcm
[dai
][substream
->stream
];
390 /* check if we are being called a subsequent time */
391 if (pcm_data
->allocated
) {
392 ret
= sst_hsw_stream_reset(hsw
, pcm_data
->stream
);
394 dev_dbg(rtd
->dev
, "error: reset stream failed %d\n",
397 ret
= sst_hsw_stream_free(hsw
, pcm_data
->stream
);
399 dev_dbg(rtd
->dev
, "error: free stream failed %d\n",
403 pcm_data
->allocated
= false;
405 pcm_data
->stream
= sst_hsw_stream_new(hsw
, rtd
->cpu_dai
->id
,
406 hsw_notify_pointer
, pcm_data
);
407 if (pcm_data
->stream
== NULL
) {
408 dev_err(rtd
->dev
, "error: failed to create stream\n");
413 /* stream direction */
414 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
415 path_id
= SST_HSW_STREAM_PATH_SSP0_OUT
;
417 path_id
= SST_HSW_STREAM_PATH_SSP0_IN
;
419 /* DSP stream type depends on DAI ID */
420 switch (rtd
->cpu_dai
->id
) {
422 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
423 stream_type
= SST_HSW_STREAM_TYPE_SYSTEM
;
424 module_id
= SST_HSW_MODULE_PCM_SYSTEM
;
427 stream_type
= SST_HSW_STREAM_TYPE_CAPTURE
;
428 module_id
= SST_HSW_MODULE_PCM_CAPTURE
;
433 stream_type
= SST_HSW_STREAM_TYPE_RENDER
;
434 module_id
= SST_HSW_MODULE_PCM
;
437 /* path ID needs to be OUT for loopback */
438 stream_type
= SST_HSW_STREAM_TYPE_LOOPBACK
;
439 path_id
= SST_HSW_STREAM_PATH_SSP0_OUT
;
440 module_id
= SST_HSW_MODULE_PCM_REFERENCE
;
443 dev_err(rtd
->dev
, "error: invalid DAI ID %d\n",
448 ret
= sst_hsw_stream_format(hsw
, pcm_data
->stream
,
449 path_id
, stream_type
, SST_HSW_STREAM_FORMAT_PCM_FORMAT
);
451 dev_err(rtd
->dev
, "error: failed to set format %d\n", ret
);
455 rate
= params_rate(params
);
456 ret
= sst_hsw_stream_set_rate(hsw
, pcm_data
->stream
, rate
);
458 dev_err(rtd
->dev
, "error: could not set rate %d\n", rate
);
462 switch (params_format(params
)) {
463 case SNDRV_PCM_FORMAT_S16_LE
:
464 bits
= SST_HSW_DEPTH_16BIT
;
465 sst_hsw_stream_set_valid(hsw
, pcm_data
->stream
, 16);
467 case SNDRV_PCM_FORMAT_S24_LE
:
468 bits
= SST_HSW_DEPTH_32BIT
;
469 sst_hsw_stream_set_valid(hsw
, pcm_data
->stream
, 24);
471 case SNDRV_PCM_FORMAT_S8
:
472 bits
= SST_HSW_DEPTH_8BIT
;
473 sst_hsw_stream_set_valid(hsw
, pcm_data
->stream
, 8);
475 case SNDRV_PCM_FORMAT_S32_LE
:
476 bits
= SST_HSW_DEPTH_32BIT
;
477 sst_hsw_stream_set_valid(hsw
, pcm_data
->stream
, 32);
480 dev_err(rtd
->dev
, "error: invalid format %d\n",
481 params_format(params
));
485 ret
= sst_hsw_stream_set_bits(hsw
, pcm_data
->stream
, bits
);
487 dev_err(rtd
->dev
, "error: could not set bits %d\n", bits
);
491 channels
= params_channels(params
);
492 map
= create_channel_map(SST_HSW_CHANNEL_CONFIG_STEREO
);
493 sst_hsw_stream_set_map_config(hsw
, pcm_data
->stream
,
494 map
, SST_HSW_CHANNEL_CONFIG_STEREO
);
496 ret
= sst_hsw_stream_set_channels(hsw
, pcm_data
->stream
, channels
);
498 dev_err(rtd
->dev
, "error: could not set channels %d\n",
503 ret
= snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(params
));
505 dev_err(rtd
->dev
, "error: could not allocate %d bytes for PCM %d\n",
506 params_buffer_bytes(params
), ret
);
510 dmab
= snd_pcm_get_dma_buf(substream
);
512 ret
= create_adsp_page_table(substream
, pdata
, rtd
, runtime
->dma_area
,
513 runtime
->dma_bytes
, rtd
->cpu_dai
->id
);
517 sst_hsw_stream_set_style(hsw
, pcm_data
->stream
,
518 SST_HSW_INTERLEAVING_PER_CHANNEL
);
520 if (runtime
->dma_bytes
% PAGE_SIZE
)
521 pages
= (runtime
->dma_bytes
/ PAGE_SIZE
) + 1;
523 pages
= runtime
->dma_bytes
/ PAGE_SIZE
;
525 ret
= sst_hsw_stream_buffer(hsw
, pcm_data
->stream
,
526 pdata
->dmab
[rtd
->cpu_dai
->id
][substream
->stream
].addr
,
527 pages
, runtime
->dma_bytes
, 0,
528 snd_sgbuf_get_addr(dmab
, 0) >> PAGE_SHIFT
);
530 dev_err(rtd
->dev
, "error: failed to set DMA buffer %d\n", ret
);
534 dsp
= sst_hsw_get_dsp(hsw
);
536 module_data
= sst_module_get_from_id(dsp
, module_id
);
537 if (module_data
== NULL
) {
538 dev_err(rtd
->dev
, "error: failed to get module config\n");
542 sst_hsw_stream_set_module_info(hsw
, pcm_data
->stream
,
545 ret
= sst_hsw_stream_commit(hsw
, pcm_data
->stream
);
547 dev_err(rtd
->dev
, "error: failed to commit stream %d\n", ret
);
551 if (!pcm_data
->allocated
) {
552 /* Set previous saved volume */
553 sst_hsw_stream_set_volume(hsw
, pcm_data
->stream
, 0,
554 0, pcm_data
->volume
[0]);
555 sst_hsw_stream_set_volume(hsw
, pcm_data
->stream
, 0,
556 1, pcm_data
->volume
[1]);
557 pcm_data
->allocated
= true;
560 ret
= sst_hsw_stream_pause(hsw
, pcm_data
->stream
, 1);
562 dev_err(rtd
->dev
, "error: failed to pause %d\n", ret
);
567 static int hsw_pcm_hw_free(struct snd_pcm_substream
*substream
)
569 snd_pcm_lib_free_pages(substream
);
573 static int hsw_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
575 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
576 struct hsw_priv_data
*pdata
=
577 snd_soc_platform_get_drvdata(rtd
->platform
);
578 struct hsw_pcm_data
*pcm_data
;
579 struct sst_hsw
*hsw
= pdata
->hsw
;
582 dai
= mod_map
[rtd
->cpu_dai
->id
].dai_id
;
583 pcm_data
= &pdata
->pcm
[dai
][substream
->stream
];
586 case SNDRV_PCM_TRIGGER_START
:
587 case SNDRV_PCM_TRIGGER_RESUME
:
588 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
589 sst_hsw_stream_resume(hsw
, pcm_data
->stream
, 0);
591 case SNDRV_PCM_TRIGGER_STOP
:
592 case SNDRV_PCM_TRIGGER_SUSPEND
:
593 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
594 sst_hsw_stream_pause(hsw
, pcm_data
->stream
, 0);
603 static u32
hsw_notify_pointer(struct sst_hsw_stream
*stream
, void *data
)
605 struct hsw_pcm_data
*pcm_data
= data
;
606 struct snd_pcm_substream
*substream
= pcm_data
->substream
;
607 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
608 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
611 pos
= frames_to_bytes(runtime
,
612 (runtime
->control
->appl_ptr
% runtime
->buffer_size
));
614 dev_vdbg(rtd
->dev
, "PCM: App pointer %d bytes\n", pos
);
616 /* let alsa know we have play a period */
617 snd_pcm_period_elapsed(substream
);
621 static snd_pcm_uframes_t
hsw_pcm_pointer(struct snd_pcm_substream
*substream
)
623 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
624 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
625 struct hsw_priv_data
*pdata
=
626 snd_soc_platform_get_drvdata(rtd
->platform
);
627 struct hsw_pcm_data
*pcm_data
;
628 struct sst_hsw
*hsw
= pdata
->hsw
;
629 snd_pcm_uframes_t offset
;
634 dai
= mod_map
[rtd
->cpu_dai
->id
].dai_id
;
635 pcm_data
= &pdata
->pcm
[dai
][substream
->stream
];
636 position
= sst_hsw_get_dsp_position(hsw
, pcm_data
->stream
);
638 offset
= bytes_to_frames(runtime
, position
);
639 ppos
= sst_hsw_get_dsp_presentation_position(hsw
, pcm_data
->stream
);
641 dev_vdbg(rtd
->dev
, "PCM: DMA pointer %du bytes, pos %llu\n",
646 static int hsw_pcm_open(struct snd_pcm_substream
*substream
)
648 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
649 struct hsw_priv_data
*pdata
=
650 snd_soc_platform_get_drvdata(rtd
->platform
);
651 struct hsw_pcm_data
*pcm_data
;
652 struct sst_hsw
*hsw
= pdata
->hsw
;
655 dai
= mod_map
[rtd
->cpu_dai
->id
].dai_id
;
656 pcm_data
= &pdata
->pcm
[dai
][substream
->stream
];
658 mutex_lock(&pcm_data
->mutex
);
659 pm_runtime_get_sync(pdata
->dev
);
661 snd_soc_pcm_set_drvdata(rtd
, pcm_data
);
662 pcm_data
->substream
= substream
;
664 snd_soc_set_runtime_hwparams(substream
, &hsw_pcm_hardware
);
666 pcm_data
->stream
= sst_hsw_stream_new(hsw
, rtd
->cpu_dai
->id
,
667 hsw_notify_pointer
, pcm_data
);
668 if (pcm_data
->stream
== NULL
) {
669 dev_err(rtd
->dev
, "error: failed to create stream\n");
670 pm_runtime_mark_last_busy(pdata
->dev
);
671 pm_runtime_put_autosuspend(pdata
->dev
);
672 mutex_unlock(&pcm_data
->mutex
);
676 mutex_unlock(&pcm_data
->mutex
);
680 static int hsw_pcm_close(struct snd_pcm_substream
*substream
)
682 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
683 struct hsw_priv_data
*pdata
=
684 snd_soc_platform_get_drvdata(rtd
->platform
);
685 struct hsw_pcm_data
*pcm_data
;
686 struct sst_hsw
*hsw
= pdata
->hsw
;
689 dai
= mod_map
[rtd
->cpu_dai
->id
].dai_id
;
690 pcm_data
= &pdata
->pcm
[dai
][substream
->stream
];
692 mutex_lock(&pcm_data
->mutex
);
693 ret
= sst_hsw_stream_reset(hsw
, pcm_data
->stream
);
695 dev_dbg(rtd
->dev
, "error: reset stream failed %d\n", ret
);
699 ret
= sst_hsw_stream_free(hsw
, pcm_data
->stream
);
701 dev_dbg(rtd
->dev
, "error: free stream failed %d\n", ret
);
704 pcm_data
->allocated
= 0;
705 pcm_data
->stream
= NULL
;
708 pm_runtime_mark_last_busy(pdata
->dev
);
709 pm_runtime_put_autosuspend(pdata
->dev
);
710 mutex_unlock(&pcm_data
->mutex
);
714 static struct snd_pcm_ops hsw_pcm_ops
= {
715 .open
= hsw_pcm_open
,
716 .close
= hsw_pcm_close
,
717 .ioctl
= snd_pcm_lib_ioctl
,
718 .hw_params
= hsw_pcm_hw_params
,
719 .hw_free
= hsw_pcm_hw_free
,
720 .trigger
= hsw_pcm_trigger
,
721 .pointer
= hsw_pcm_pointer
,
722 .page
= snd_pcm_sgbuf_ops_page
,
725 static int hsw_pcm_create_modules(struct hsw_priv_data
*pdata
)
727 struct sst_hsw
*hsw
= pdata
->hsw
;
728 struct hsw_pcm_data
*pcm_data
;
731 for (i
= 0; i
< ARRAY_SIZE(mod_map
); i
++) {
732 pcm_data
= &pdata
->pcm
[mod_map
[i
].dai_id
][mod_map
[i
].stream
];
734 /* create new runtime module, use same offset if recreated */
735 pcm_data
->runtime
= sst_hsw_runtime_module_create(hsw
,
736 mod_map
[i
].mod_id
, pcm_data
->persistent_offset
);
737 if (pcm_data
->runtime
== NULL
)
739 pcm_data
->persistent_offset
=
740 pcm_data
->runtime
->persistent_offset
;
746 for (--i
; i
>= 0; i
--) {
747 pcm_data
= &pdata
->pcm
[mod_map
[i
].dai_id
][mod_map
[i
].stream
];
748 sst_hsw_runtime_module_free(pcm_data
->runtime
);
754 static void hsw_pcm_free_modules(struct hsw_priv_data
*pdata
)
756 struct hsw_pcm_data
*pcm_data
;
759 for (i
= 0; i
< ARRAY_SIZE(mod_map
); i
++) {
760 pcm_data
= &pdata
->pcm
[mod_map
[i
].dai_id
][mod_map
[i
].stream
];
762 sst_hsw_runtime_module_free(pcm_data
->runtime
);
766 static int hsw_pcm_new(struct snd_soc_pcm_runtime
*rtd
)
768 struct snd_pcm
*pcm
= rtd
->pcm
;
769 struct snd_soc_platform
*platform
= rtd
->platform
;
770 struct sst_pdata
*pdata
= dev_get_platdata(platform
->dev
);
771 struct hsw_priv_data
*priv_data
= dev_get_drvdata(platform
->dev
);
772 struct device
*dev
= pdata
->dma_dev
;
775 if (pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
||
776 pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
) {
777 ret
= snd_pcm_lib_preallocate_pages_for_all(pcm
,
778 SNDRV_DMA_TYPE_DEV_SG
,
780 hsw_pcm_hardware
.buffer_bytes_max
,
781 hsw_pcm_hardware
.buffer_bytes_max
);
783 dev_err(rtd
->dev
, "dma buffer allocation failed %d\n",
788 if (pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
)
789 priv_data
->pcm
[rtd
->cpu_dai
->id
][SNDRV_PCM_STREAM_PLAYBACK
].hsw_pcm
= pcm
;
790 if (pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
)
791 priv_data
->pcm
[rtd
->cpu_dai
->id
][SNDRV_PCM_STREAM_CAPTURE
].hsw_pcm
= pcm
;
796 #define HSW_FORMATS \
797 (SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S16_LE)
799 static struct snd_soc_dai_driver hsw_dais
[] = {
801 .name
= "System Pin",
802 .id
= HSW_PCM_DAI_ID_SYSTEM
,
804 .stream_name
= "System Playback",
807 .rates
= SNDRV_PCM_RATE_48000
,
808 .formats
= SNDRV_PCM_FMTBIT_S24_LE
| SNDRV_PCM_FMTBIT_S16_LE
,
811 .stream_name
= "Analog Capture",
814 .rates
= SNDRV_PCM_RATE_48000
,
815 .formats
= SNDRV_PCM_FMTBIT_S24_LE
| SNDRV_PCM_FMTBIT_S16_LE
,
820 .name
= "Offload0 Pin",
821 .id
= HSW_PCM_DAI_ID_OFFLOAD0
,
823 .stream_name
= "Offload0 Playback",
826 .rates
= SNDRV_PCM_RATE_8000_192000
,
827 .formats
= HSW_FORMATS
,
832 .name
= "Offload1 Pin",
833 .id
= HSW_PCM_DAI_ID_OFFLOAD1
,
835 .stream_name
= "Offload1 Playback",
838 .rates
= SNDRV_PCM_RATE_8000_192000
,
839 .formats
= HSW_FORMATS
,
843 .name
= "Loopback Pin",
844 .id
= HSW_PCM_DAI_ID_LOOPBACK
,
846 .stream_name
= "Loopback Capture",
849 .rates
= SNDRV_PCM_RATE_48000
,
850 .formats
= SNDRV_PCM_FMTBIT_S24_LE
| SNDRV_PCM_FMTBIT_S16_LE
,
855 static const struct snd_soc_dapm_widget widgets
[] = {
858 SND_SOC_DAPM_AIF_IN("SSP0 CODEC IN", NULL
, 0, SND_SOC_NOPM
, 0, 0),
859 SND_SOC_DAPM_AIF_OUT("SSP0 CODEC OUT", NULL
, 0, SND_SOC_NOPM
, 0, 0),
860 SND_SOC_DAPM_AIF_IN("SSP1 BT IN", NULL
, 0, SND_SOC_NOPM
, 0, 0),
861 SND_SOC_DAPM_AIF_OUT("SSP1 BT OUT", NULL
, 0, SND_SOC_NOPM
, 0, 0),
863 /* Global Playback Mixer */
864 SND_SOC_DAPM_MIXER("Playback VMixer", SND_SOC_NOPM
, 0, 0, NULL
, 0),
867 static const struct snd_soc_dapm_route graph
[] = {
870 {"Playback VMixer", NULL
, "System Playback"},
871 {"Playback VMixer", NULL
, "Offload0 Playback"},
872 {"Playback VMixer", NULL
, "Offload1 Playback"},
874 {"SSP0 CODEC OUT", NULL
, "Playback VMixer"},
876 {"Analog Capture", NULL
, "SSP0 CODEC IN"},
879 static int hsw_pcm_probe(struct snd_soc_platform
*platform
)
881 struct hsw_priv_data
*priv_data
= snd_soc_platform_get_drvdata(platform
);
882 struct sst_pdata
*pdata
= dev_get_platdata(platform
->dev
);
883 struct device
*dma_dev
, *dev
;
890 dma_dev
= pdata
->dma_dev
;
892 priv_data
->hsw
= pdata
->dsp
;
893 priv_data
->dev
= platform
->dev
;
894 priv_data
->pm_state
= HSW_PM_STATE_D0
;
895 priv_data
->soc_card
= platform
->component
.card
;
897 /* allocate DSP buffer page tables */
898 for (i
= 0; i
< ARRAY_SIZE(hsw_dais
); i
++) {
901 if (hsw_dais
[i
].playback
.channels_min
) {
902 mutex_init(&priv_data
->pcm
[i
][SNDRV_PCM_STREAM_PLAYBACK
].mutex
);
903 ret
= snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, dma_dev
,
904 PAGE_SIZE
, &priv_data
->dmab
[i
][0]);
910 if (hsw_dais
[i
].capture
.channels_min
) {
911 mutex_init(&priv_data
->pcm
[i
][SNDRV_PCM_STREAM_CAPTURE
].mutex
);
912 ret
= snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, dma_dev
,
913 PAGE_SIZE
, &priv_data
->dmab
[i
][1]);
919 /* allocate runtime modules */
920 hsw_pcm_create_modules(priv_data
);
922 /* enable runtime PM with auto suspend */
923 pm_runtime_set_autosuspend_delay(platform
->dev
,
924 SST_RUNTIME_SUSPEND_DELAY
);
925 pm_runtime_use_autosuspend(platform
->dev
);
926 pm_runtime_enable(platform
->dev
);
927 pm_runtime_idle(platform
->dev
);
933 if (hsw_dais
[i
].playback
.channels_min
)
934 snd_dma_free_pages(&priv_data
->dmab
[i
][0]);
935 if (hsw_dais
[i
].capture
.channels_min
)
936 snd_dma_free_pages(&priv_data
->dmab
[i
][1]);
941 static int hsw_pcm_remove(struct snd_soc_platform
*platform
)
943 struct hsw_priv_data
*priv_data
=
944 snd_soc_platform_get_drvdata(platform
);
947 pm_runtime_disable(platform
->dev
);
948 hsw_pcm_free_modules(priv_data
);
950 for (i
= 0; i
< ARRAY_SIZE(hsw_dais
); i
++) {
951 if (hsw_dais
[i
].playback
.channels_min
)
952 snd_dma_free_pages(&priv_data
->dmab
[i
][0]);
953 if (hsw_dais
[i
].capture
.channels_min
)
954 snd_dma_free_pages(&priv_data
->dmab
[i
][1]);
960 static struct snd_soc_platform_driver hsw_soc_platform
= {
961 .probe
= hsw_pcm_probe
,
962 .remove
= hsw_pcm_remove
,
964 .pcm_new
= hsw_pcm_new
,
967 static const struct snd_soc_component_driver hsw_dai_component
= {
968 .name
= "haswell-dai",
969 .controls
= hsw_volume_controls
,
970 .num_controls
= ARRAY_SIZE(hsw_volume_controls
),
971 .dapm_widgets
= widgets
,
972 .num_dapm_widgets
= ARRAY_SIZE(widgets
),
973 .dapm_routes
= graph
,
974 .num_dapm_routes
= ARRAY_SIZE(graph
),
977 static int hsw_pcm_dev_probe(struct platform_device
*pdev
)
979 struct sst_pdata
*sst_pdata
= dev_get_platdata(&pdev
->dev
);
980 struct hsw_priv_data
*priv_data
;
986 priv_data
= devm_kzalloc(&pdev
->dev
, sizeof(*priv_data
), GFP_KERNEL
);
990 ret
= sst_hsw_dsp_init(&pdev
->dev
, sst_pdata
);
994 priv_data
->hsw
= sst_pdata
->dsp
;
995 platform_set_drvdata(pdev
, priv_data
);
997 ret
= snd_soc_register_platform(&pdev
->dev
, &hsw_soc_platform
);
1001 ret
= snd_soc_register_component(&pdev
->dev
, &hsw_dai_component
,
1002 hsw_dais
, ARRAY_SIZE(hsw_dais
));
1009 snd_soc_unregister_platform(&pdev
->dev
);
1011 sst_hsw_dsp_free(&pdev
->dev
, sst_pdata
);
1015 static int hsw_pcm_dev_remove(struct platform_device
*pdev
)
1017 struct sst_pdata
*sst_pdata
= dev_get_platdata(&pdev
->dev
);
1019 snd_soc_unregister_platform(&pdev
->dev
);
1020 snd_soc_unregister_component(&pdev
->dev
);
1021 sst_hsw_dsp_free(&pdev
->dev
, sst_pdata
);
1028 static int hsw_pcm_runtime_idle(struct device
*dev
)
1033 static int hsw_pcm_runtime_suspend(struct device
*dev
)
1035 struct hsw_priv_data
*pdata
= dev_get_drvdata(dev
);
1036 struct sst_hsw
*hsw
= pdata
->hsw
;
1038 if (pdata
->pm_state
== HSW_PM_STATE_D3
)
1041 sst_hsw_dsp_runtime_suspend(hsw
);
1042 sst_hsw_dsp_runtime_sleep(hsw
);
1043 pdata
->pm_state
= HSW_PM_STATE_D3
;
1048 static int hsw_pcm_runtime_resume(struct device
*dev
)
1050 struct hsw_priv_data
*pdata
= dev_get_drvdata(dev
);
1051 struct sst_hsw
*hsw
= pdata
->hsw
;
1054 if (pdata
->pm_state
== HSW_PM_STATE_D0
)
1057 ret
= sst_hsw_dsp_load(hsw
);
1059 dev_err(dev
, "failed to reload %d\n", ret
);
1063 ret
= hsw_pcm_create_modules(pdata
);
1065 dev_err(dev
, "failed to create modules %d\n", ret
);
1069 ret
= sst_hsw_dsp_runtime_resume(hsw
);
1072 else if (ret
== 1) /* no action required */
1075 pdata
->pm_state
= HSW_PM_STATE_D0
;
1080 #define hsw_pcm_runtime_idle NULL
1081 #define hsw_pcm_runtime_suspend NULL
1082 #define hsw_pcm_runtime_resume NULL
1087 static void hsw_pcm_complete(struct device
*dev
)
1089 struct hsw_priv_data
*pdata
= dev_get_drvdata(dev
);
1090 struct sst_hsw
*hsw
= pdata
->hsw
;
1091 struct hsw_pcm_data
*pcm_data
;
1094 if (pdata
->pm_state
== HSW_PM_STATE_D0
)
1097 err
= sst_hsw_dsp_load(hsw
);
1099 dev_err(dev
, "failed to reload %d\n", err
);
1103 err
= hsw_pcm_create_modules(pdata
);
1105 dev_err(dev
, "failed to create modules %d\n", err
);
1109 for (i
= 0; i
< ARRAY_SIZE(mod_map
); i
++) {
1110 pcm_data
= &pdata
->pcm
[mod_map
[i
].dai_id
][mod_map
[i
].stream
];
1112 if (!pcm_data
->substream
)
1115 err
= sst_module_runtime_restore(pcm_data
->runtime
,
1116 &pcm_data
->context
);
1118 dev_err(dev
, "failed to restore context for PCM %d\n", i
);
1121 snd_soc_resume(pdata
->soc_card
->dev
);
1123 err
= sst_hsw_dsp_runtime_resume(hsw
);
1126 else if (err
== 1) /* no action required */
1129 pdata
->pm_state
= HSW_PM_STATE_D0
;
1133 static int hsw_pcm_prepare(struct device
*dev
)
1135 struct hsw_priv_data
*pdata
= dev_get_drvdata(dev
);
1136 struct sst_hsw
*hsw
= pdata
->hsw
;
1137 struct hsw_pcm_data
*pcm_data
;
1140 if (pdata
->pm_state
== HSW_PM_STATE_D3
)
1142 /* suspend all active streams */
1143 for (i
= 0; i
< ARRAY_SIZE(mod_map
); i
++) {
1144 pcm_data
= &pdata
->pcm
[mod_map
[i
].dai_id
][mod_map
[i
].stream
];
1146 if (!pcm_data
->substream
)
1148 dev_dbg(dev
, "suspending pcm %d\n", i
);
1149 snd_pcm_suspend_all(pcm_data
->hsw_pcm
);
1151 /* We need to wait until the DSP FW stops the streams */
1155 snd_soc_suspend(pdata
->soc_card
->dev
);
1156 snd_soc_poweroff(pdata
->soc_card
->dev
);
1158 /* enter D3 state and stall */
1159 sst_hsw_dsp_runtime_suspend(hsw
);
1161 /* preserve persistent memory */
1162 for (i
= 0; i
< ARRAY_SIZE(mod_map
); i
++) {
1163 pcm_data
= &pdata
->pcm
[mod_map
[i
].dai_id
][mod_map
[i
].stream
];
1165 if (!pcm_data
->substream
)
1168 dev_dbg(dev
, "saving context pcm %d\n", i
);
1169 err
= sst_module_runtime_save(pcm_data
->runtime
,
1170 &pcm_data
->context
);
1172 dev_err(dev
, "failed to save context for PCM %d\n", i
);
1175 /* put the DSP to sleep */
1176 sst_hsw_dsp_runtime_sleep(hsw
);
1177 pdata
->pm_state
= HSW_PM_STATE_D3
;
1183 #define hsw_pcm_prepare NULL
1184 #define hsw_pcm_complete NULL
1187 static const struct dev_pm_ops hsw_pcm_pm
= {
1188 .runtime_idle
= hsw_pcm_runtime_idle
,
1189 .runtime_suspend
= hsw_pcm_runtime_suspend
,
1190 .runtime_resume
= hsw_pcm_runtime_resume
,
1191 .prepare
= hsw_pcm_prepare
,
1192 .complete
= hsw_pcm_complete
,
1195 static struct platform_driver hsw_pcm_driver
= {
1197 .name
= "haswell-pcm-audio",
1201 .probe
= hsw_pcm_dev_probe
,
1202 .remove
= hsw_pcm_dev_remove
,
1204 module_platform_driver(hsw_pcm_driver
);
1206 MODULE_AUTHOR("Liam Girdwood, Xingchao Wang");
1207 MODULE_DESCRIPTION("Haswell/Lynxpoint + Broadwell/Wildcatpoint PCM");
1208 MODULE_LICENSE("GPL v2");
1209 MODULE_ALIAS("platform:haswell-pcm-audio");