2 * intel_sst_interface.c - Intel SST Driver for audio engine
4 * Copyright (C) 2008-10 Intel Corp
5 * Authors: Vinod Koul <vinod.koul@intel.com>
6 * Harsha Priya <priya.harsha@intel.com>
7 * Dharageswari R <dharageswari.r@intel.com)
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2 of the License.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24 * This driver exposes the audio engine functionalities to the ALSA
26 * Upper layer interfaces (MAD driver, MMF) to SST driver
29 #include <linux/delay.h>
30 #include <linux/pci.h>
32 #include <linux/firmware.h>
33 #include "intel_sst.h"
34 #include "intel_sst_ioctl.h"
35 #include "intel_sst_fw_ipc.h"
36 #include "intel_sst_common.h"
40 * sst_download_fw - download the audio firmware to DSP
42 * This function is called when the FW needs to be downloaded to SST DSP engine
44 int sst_download_fw(void)
47 const struct firmware
*fw_sst
;
49 if (sst_drv_ctx
->sst_state
!= SST_UN_INIT
)
51 if (sst_drv_ctx
->pci_id
== SST_MRST_PCI_ID
)
52 name
= SST_FW_FILENAME_MRST
;
54 name
= SST_FW_FILENAME_MFLD
;
55 pr_debug("sst: Downloading %s FW now...\n", name
);
56 retval
= request_firmware(&fw_sst
, name
, &sst_drv_ctx
->pci
->dev
);
58 pr_err("sst: request fw failed %d\n", retval
);
61 sst_drv_ctx
->alloc_block
[0].sst_id
= FW_DWNL_ID
;
62 sst_drv_ctx
->alloc_block
[0].ops_block
.condition
= false;
63 retval
= sst_load_fw(fw_sst
, NULL
);
67 retval
= sst_wait_timeout(sst_drv_ctx
, &sst_drv_ctx
->alloc_block
[0]);
69 pr_err("sst: fw download failed %d\n" , retval
);
71 release_firmware(fw_sst
);
72 sst_drv_ctx
->alloc_block
[0].sst_id
= BLOCK_UNINIT
;
78 * sst_stalled - this function checks if the lpe is in stalled state
86 if (!sst_drv_ctx
->lpe_stalled
)
88 /*wait for time and re-check*/
93 pr_debug("sst: in Stalled State\n");
97 void free_stream_context(unsigned int str_id
)
99 struct stream_info
*stream
;
101 if (!sst_validate_strid(str_id
)) {
102 /* str_id is valid, so stream is alloacted */
103 stream
= &sst_drv_ctx
->streams
[str_id
];
104 if (stream
->ops
== STREAM_OPS_PLAYBACK
||
105 stream
->ops
== STREAM_OPS_PLAYBACK_DRM
) {
106 sst_drv_ctx
->pb_streams
--;
107 if (sst_drv_ctx
->pb_streams
== 0)
108 sst_drv_ctx
->scard_ops
->power_down_pmic_pb();
109 } else if (stream
->ops
== STREAM_OPS_CAPTURE
) {
110 sst_drv_ctx
->cp_streams
--;
111 if (sst_drv_ctx
->cp_streams
== 0)
112 sst_drv_ctx
->scard_ops
->power_down_pmic_cp();
114 if (sst_drv_ctx
->pb_streams
== 0
115 && sst_drv_ctx
->cp_streams
== 0)
116 sst_drv_ctx
->scard_ops
->power_down_pmic();
117 if (sst_free_stream(str_id
))
118 sst_clean_stream(&sst_drv_ctx
->streams
[str_id
]);
123 * sst_get_stream_allocated - this function gets a stream allocated with
126 * @str_param : stream params
127 * @lib_dnld : pointer to pointer of lib downlaod struct
129 * This creates new stream id for a stream, in case lib is to be downloaded to
130 * DSP, it downloads that
132 int sst_get_stream_allocated(struct snd_sst_params
*str_param
,
133 struct snd_sst_lib_download
**lib_dnld
)
136 struct stream_info
*str_info
;
138 retval
= sst_alloc_stream((char *) &str_param
->sparams
, str_param
->ops
,
139 str_param
->codec
, str_param
->device_type
);
141 pr_err("sst: sst_alloc_stream failed %d\n", retval
);
144 pr_debug("sst: Stream allocated %d\n", retval
);
146 str_info
= &sst_drv_ctx
->streams
[str_id
];
147 /* Block the call for reply */
148 retval
= sst_wait_interruptible_timeout(sst_drv_ctx
,
149 &str_info
->ctrl_blk
, SST_BLOCK_TIMEOUT
);
150 if ((retval
!= 0) || (str_info
->ctrl_blk
.ret_code
!= 0)) {
151 pr_debug("sst: FW alloc failed retval %d, ret_code %d\n",
152 retval
, str_info
->ctrl_blk
.ret_code
);
153 str_id
= -str_info
->ctrl_blk
.ret_code
; /*return error*/
154 *lib_dnld
= str_info
->ctrl_blk
.data
;
155 sst_clean_stream(str_info
);
157 pr_debug("sst: FW Stream allocated sucess\n");
158 return str_id
; /*will ret either error (in above if) or correct str id*/
162 * sst_get_sfreq - this function returns the frequency of the stream
164 * @str_param : stream params
166 static int sst_get_sfreq(struct snd_sst_params
*str_param
)
168 switch (str_param
->codec
) {
169 case SST_CODEC_TYPE_PCM
:
170 return 48000; /*str_param->sparams.uc.pcm_params.sfreq;*/
171 case SST_CODEC_TYPE_MP3
:
172 return str_param
->sparams
.uc
.mp3_params
.sfreq
;
173 case SST_CODEC_TYPE_AAC
:
174 return str_param
->sparams
.uc
.aac_params
.sfreq
;;
175 case SST_CODEC_TYPE_WMA9
:
176 return str_param
->sparams
.uc
.wma_params
.sfreq
;;
183 * sst_get_stream - this function prepares for stream allocation
185 * @str_param : stream param
187 int sst_get_stream(struct snd_sst_params
*str_param
)
190 struct stream_info
*str_info
;
191 struct snd_sst_lib_download
*lib_dnld
;
193 /* stream is not allocated, we are allocating */
194 retval
= sst_get_stream_allocated(str_param
, &lib_dnld
);
195 if (retval
== -(SST_LIB_ERR_LIB_DNLD_REQUIRED
)) {
196 /* codec download is required */
197 struct snd_sst_alloc_response
*response
;
199 pr_debug("sst: Codec is required.... trying that\n");
200 if (lib_dnld
== NULL
) {
201 pr_err("sst: lib download null!!! abort\n");
204 i
= sst_get_block_stream(sst_drv_ctx
);
205 response
= sst_drv_ctx
->alloc_block
[i
].ops_block
.data
;
206 pr_debug("sst: alloc block allocated = %d\n", i
);
211 retval
= sst_load_library(lib_dnld
, str_param
->ops
);
214 sst_drv_ctx
->alloc_block
[i
].sst_id
= BLOCK_UNINIT
;
216 pr_debug("sst: codec was downloaded sucesfully\n");
218 retval
= sst_get_stream_allocated(str_param
, &lib_dnld
);
222 pr_debug("sst: Alloc done stream id %d\n", retval
);
224 pr_debug("sst: codec download failed\n");
228 } else if (retval
<= 0)
231 set_port_params(str_param, str_param->ops);*/
233 /* store sampling freq */
234 str_info
= &sst_drv_ctx
->streams
[retval
];
235 str_info
->sfreq
= sst_get_sfreq(str_param
);
237 /* power on the analog, if reqd */
238 if (str_param
->ops
== STREAM_OPS_PLAYBACK
||
239 str_param
->ops
== STREAM_OPS_PLAYBACK_DRM
) {
240 if (sst_drv_ctx
->pci_id
== SST_MRST_PCI_ID
)
241 sst_drv_ctx
->scard_ops
->power_up_pmic_pb(
242 sst_drv_ctx
->pmic_port_instance
);
244 sst_drv_ctx
->scard_ops
->power_up_pmic_pb(
246 /*Only if the playback is MP3 - Send a message*/
247 sst_drv_ctx
->pb_streams
++;
248 } else if (str_param
->ops
== STREAM_OPS_CAPTURE
) {
250 sst_drv_ctx
->scard_ops
->power_up_pmic_cp(
251 sst_drv_ctx
->pmic_port_instance
);
252 /*Send a messageif not sent already*/
253 sst_drv_ctx
->cp_streams
++;
260 void sst_process_mad_ops(struct work_struct
*work
)
263 struct mad_ops_wq
*mad_ops
=
264 container_of(work
, struct mad_ops_wq
, wq
);
267 switch (mad_ops
->control_op
) {
269 retval
= sst_pause_stream(mad_ops
->stream_id
);
272 retval
= sst_resume_stream(mad_ops
->stream_id
);
275 /* retval = sst_drop_stream(mad_ops->stream_id);
278 pr_debug("SST Debug: start stream\n");
279 retval
= sst_start_stream(mad_ops
->stream_id
);
281 case SST_SND_STREAM_PROCESS
:
282 pr_debug("sst: play/capt frames...\n");
285 pr_err("sst: wrong control_ops reported\n");
290 * sst_control_set - Set Control params
292 * @control_list: list of controls to be set
294 * This function is called by MID sound card driver to set
295 * SST/Sound card controls. This is registered with MID driver
297 int sst_control_set(int control_element
, void *value
)
299 int retval
= 0, str_id
= 0;
300 struct stream_info
*stream
;
302 if (sst_drv_ctx
->sst_state
== SST_SUSPENDED
) {
303 /*LPE is suspended, resume it before proceding*/
304 pr_debug("sst: Resuming from Suspended state\n");
305 retval
= intel_sst_resume(sst_drv_ctx
->pci
);
307 pr_err("sst: Resume Failed = %#x, abort\n", retval
);
311 if (sst_drv_ctx
->sst_state
== SST_UN_INIT
) {
312 /* FW is not downloaded */
313 pr_debug("sst: DSP Downloading FW now...\n");
314 retval
= sst_download_fw();
316 pr_err("sst: FW download fail %x, abort\n", retval
);
319 if (sst_drv_ctx
->pci_id
== SST_MRST_PCI_ID
&&
320 sst_drv_ctx
->rx_time_slot_status
!= RX_TIMESLOT_UNINIT
321 && sst_drv_ctx
->pmic_vendor
!= SND_NC
)
322 sst_enable_rx_timeslot(
323 sst_drv_ctx
->rx_time_slot_status
);
326 switch (control_element
) {
327 case SST_SND_ALLOC
: {
328 struct snd_sst_params
*str_param
;
329 struct stream_info
*str_info
;
331 str_param
= (struct snd_sst_params
*)value
;
333 retval
= sst_get_stream(str_param
);
335 sst_drv_ctx
->stream_cnt
++;
336 str_info
= &sst_drv_ctx
->streams
[retval
];
337 str_info
->src
= MAD_DRV
;
345 sst_drv_ctx
->mad_ops
.control_op
= control_element
;
346 sst_drv_ctx
->mad_ops
.stream_id
= *(int *)value
;
347 queue_work(sst_drv_ctx
->mad_wq
, &sst_drv_ctx
->mad_ops
.wq
);
351 str_id
= *(int *)value
;
352 stream
= &sst_drv_ctx
->streams
[str_id
];
353 free_stream_context(str_id
);
354 stream
->pcm_substream
= NULL
;
355 stream
->status
= STREAM_UN_INIT
;
356 stream
->period_elapsed
= NULL
;
357 sst_drv_ctx
->stream_cnt
--;
360 case SST_SND_STREAM_INIT
: {
361 struct pcm_stream_info
*str_info
;
362 struct stream_info
*stream
;
364 pr_debug("sst: stream init called\n");
365 str_info
= (struct pcm_stream_info
*)value
;
366 str_id
= str_info
->str_id
;
367 retval
= sst_validate_strid(str_id
);
371 stream
= &sst_drv_ctx
->streams
[str_id
];
372 pr_debug("sst: setting the period ptrs\n");
373 stream
->pcm_substream
= str_info
->mad_substream
;
374 stream
->period_elapsed
= str_info
->period_elapsed
;
375 stream
->sfreq
= str_info
->sfreq
;
376 stream
->prev
= stream
->status
;
377 stream
->status
= STREAM_INIT
;
381 case SST_SND_BUFFER_POINTER
: {
382 struct pcm_stream_info
*stream_info
;
383 struct snd_sst_tstamp fw_tstamp
= {0,};
384 struct stream_info
*stream
;
387 stream_info
= (struct pcm_stream_info
*)value
;
388 str_id
= stream_info
->str_id
;
389 retval
= sst_validate_strid(str_id
);
392 stream
= &sst_drv_ctx
->streams
[str_id
];
394 if (!stream
->pcm_substream
)
396 memcpy_fromio(&fw_tstamp
,
397 ((void *)(sst_drv_ctx
->mailbox
+ SST_TIME_STAMP
)
398 +(str_id
* sizeof(fw_tstamp
))),
401 pr_debug("sst: Pointer Query on strid = %d ops %d\n",
402 str_id
, stream
->ops
);
404 if (stream
->ops
== STREAM_OPS_PLAYBACK
)
405 stream_info
->buffer_ptr
= fw_tstamp
.samples_rendered
;
407 stream_info
->buffer_ptr
= fw_tstamp
.samples_processed
;
408 pr_debug("sst: Samples rendered = %llu, buffer ptr %llu\n",
409 fw_tstamp
.samples_rendered
, stream_info
->buffer_ptr
);
412 case SST_ENABLE_RX_TIME_SLOT
: {
413 int status
= *(int *)value
;
414 sst_drv_ctx
->rx_time_slot_status
= status
;
415 sst_enable_rx_timeslot(status
);
420 pr_warn("sst: illegal req\n");
428 struct intel_sst_card_ops sst_pmic_ops
= {
429 .control_set
= sst_control_set
,
433 * register_sst_card - function for sound card to register
435 * @card: pointer to structure of operations
437 * This function is called card driver loads and is ready for registration
439 int register_sst_card(struct intel_sst_card_ops
*card
)
442 pr_err("sst: No SST driver register card reject\n");
446 if (!card
|| !card
->module_name
) {
447 pr_err("sst: Null Pointer Passed\n");
450 if (sst_drv_ctx
->pmic_state
== SND_MAD_UN_INIT
) {
451 /* register this driver */
452 if ((strncmp(SST_CARD_NAMES
, card
->module_name
,
453 strlen(SST_CARD_NAMES
))) == 0) {
454 sst_drv_ctx
->pmic_vendor
= card
->vendor_id
;
455 sst_drv_ctx
->scard_ops
= card
->scard_ops
;
456 sst_pmic_ops
.module_name
= card
->module_name
;
457 sst_drv_ctx
->pmic_state
= SND_MAD_INIT_DONE
;
458 sst_drv_ctx
->rx_time_slot_status
= 0; /*default AMIC*/
459 card
->control_set
= sst_pmic_ops
.control_set
;
460 sst_drv_ctx
->scard_ops
->card_status
= SND_CARD_UN_INIT
;
463 pr_err("sst: strcmp fail %s\n", card
->module_name
);
468 /* already registered a driver */
469 pr_err("sst: Repeat for registeration..denied\n");
474 EXPORT_SYMBOL_GPL(register_sst_card
);
477 * unregister_sst_card- function for sound card to un-register
479 * @card: pointer to structure of operations
481 * This function is called when card driver unloads
483 void unregister_sst_card(struct intel_sst_card_ops
*card
)
485 if (sst_pmic_ops
.control_set
== card
->control_set
) {
487 sst_pmic_ops
.module_name
= "";
488 sst_drv_ctx
->pmic_state
= SND_MAD_UN_INIT
;
489 pr_debug("sst: Unregistered %s\n", card
->module_name
);
493 EXPORT_SYMBOL_GPL(unregister_sst_card
);