1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <linux/pci.h>
23#include <linux/firmware.h>
24#include <linux/sched.h>
25#include <linux/delay.h>
26#include <linux/pm_runtime.h>
27#include <sound/core.h>
28#include <sound/pcm.h>
29#include <sound/soc.h>
30#include <sound/compress_driver.h>
31#include <asm/platform_sst_audio.h>
32#include "../sst-mfld-platform.h"
33#include "sst.h"
34#include "../../common/sst-dsp.h"
35
36int sst_alloc_stream_mrfld(struct intel_sst_drv *sst_drv_ctx, void *params)
37{
38 struct snd_pcm_params *pcm_params;
39 struct snd_sst_params *str_params;
40 struct snd_sst_tstamp fw_tstamp;
41 struct stream_info *str_info;
42 int i, num_ch, str_id;
43
44 dev_dbg(sst_drv_ctx->dev, "Enter\n");
45
46 str_params = (struct snd_sst_params *)params;
47 str_id = str_params->stream_id;
48 str_info = get_stream_info(sst_drv_ctx, str_id);
49 if (!str_info)
50 return -EINVAL;
51
52 memset(&str_info->alloc_param, 0, sizeof(str_info->alloc_param));
53 str_info->alloc_param.operation = str_params->ops;
54 str_info->alloc_param.codec_type = str_params->codec;
55 str_info->alloc_param.sg_count = str_params->aparams.sg_count;
56 str_info->alloc_param.ring_buf_info[0].addr =
57 str_params->aparams.ring_buf_info[0].addr;
58 str_info->alloc_param.ring_buf_info[0].size =
59 str_params->aparams.ring_buf_info[0].size;
60 str_info->alloc_param.frag_size = str_params->aparams.frag_size;
61
62 memcpy(&str_info->alloc_param.codec_params, &str_params->sparams,
63 sizeof(struct snd_sst_stream_params));
64
65
66
67
68
69
70
71 num_ch = sst_get_num_channel(str_params);
72 pcm_params = &str_info->alloc_param.codec_params.uc.pcm_params;
73 for (i = 0; i < 8; i++) {
74 if (i < num_ch)
75 pcm_params->channel_map[i] = i;
76 else
77 pcm_params->channel_map[i] = 0xff;
78 }
79
80 sst_drv_ctx->streams[str_id].status = STREAM_INIT;
81 sst_drv_ctx->streams[str_id].prev = STREAM_UN_INIT;
82 sst_drv_ctx->streams[str_id].pipe_id = str_params->device_type;
83 sst_drv_ctx->streams[str_id].task_id = str_params->task;
84 sst_drv_ctx->streams[str_id].num_ch = num_ch;
85
86 if (sst_drv_ctx->info.lpe_viewpt_rqd)
87 str_info->alloc_param.ts = sst_drv_ctx->info.mailbox_start +
88 sst_drv_ctx->tstamp + (str_id * sizeof(fw_tstamp));
89 else
90 str_info->alloc_param.ts = sst_drv_ctx->mailbox_add +
91 sst_drv_ctx->tstamp + (str_id * sizeof(fw_tstamp));
92
93 dev_dbg(sst_drv_ctx->dev, "alloc tstamp location = 0x%x\n",
94 str_info->alloc_param.ts);
95 dev_dbg(sst_drv_ctx->dev, "assigned pipe id 0x%x to task %d\n",
96 str_info->pipe_id, str_info->task_id);
97
98 return sst_realloc_stream(sst_drv_ctx, str_id);
99}
100
101
102
103
104
105
106
107
108
109
110int sst_realloc_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
111{
112 struct snd_sst_alloc_response *response;
113 struct stream_info *str_info;
114 void *data = NULL;
115 int ret;
116
117 str_info = get_stream_info(sst_drv_ctx, str_id);
118 if (!str_info)
119 return -EINVAL;
120
121 dev_dbg(sst_drv_ctx->dev, "Alloc for str %d pipe %#x\n",
122 str_id, str_info->pipe_id);
123
124 ret = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
125 IPC_IA_ALLOC_STREAM_MRFLD, str_info->pipe_id,
126 sizeof(str_info->alloc_param), &str_info->alloc_param,
127 &data, true, true, false, true);
128
129 if (ret < 0) {
130 dev_err(sst_drv_ctx->dev, "FW alloc failed ret %d\n", ret);
131
132 str_info->status = STREAM_UN_INIT;
133 str_id = ret;
134 } else if (data) {
135 response = (struct snd_sst_alloc_response *)data;
136 ret = response->str_type.result;
137 if (!ret)
138 goto out;
139 dev_err(sst_drv_ctx->dev, "FW alloc failed ret %d\n", ret);
140 if (ret == SST_ERR_STREAM_IN_USE) {
141 dev_err(sst_drv_ctx->dev,
142 "FW not in clean state, send free for:%d\n", str_id);
143 sst_free_stream(sst_drv_ctx, str_id);
144 }
145 str_id = -ret;
146 }
147out:
148 kfree(data);
149 return str_id;
150}
151
152
153
154
155
156
157
158
159int sst_start_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
160{
161 int retval = 0;
162 struct stream_info *str_info;
163 u16 data = 0;
164
165 dev_dbg(sst_drv_ctx->dev, "sst_start_stream for %d\n", str_id);
166 str_info = get_stream_info(sst_drv_ctx, str_id);
167 if (!str_info)
168 return -EINVAL;
169 if (str_info->status != STREAM_RUNNING)
170 return -EBADRQC;
171
172 retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
173 IPC_CMD, IPC_IA_START_STREAM_MRFLD, str_info->pipe_id,
174 sizeof(u16), &data, NULL, true, true, true, false);
175
176 return retval;
177}
178
179int sst_send_byte_stream_mrfld(struct intel_sst_drv *sst_drv_ctx,
180 struct snd_sst_bytes_v2 *bytes)
181{ struct ipc_post *msg = NULL;
182 u32 length;
183 int pvt_id, ret = 0;
184 struct sst_block *block = NULL;
185
186 dev_dbg(sst_drv_ctx->dev,
187 "type:%u ipc_msg:%u block:%u task_id:%u pipe: %#x length:%#x\n",
188 bytes->type, bytes->ipc_msg, bytes->block, bytes->task_id,
189 bytes->pipe_id, bytes->len);
190
191 if (sst_create_ipc_msg(&msg, true))
192 return -ENOMEM;
193
194 pvt_id = sst_assign_pvt_id(sst_drv_ctx);
195 sst_fill_header_mrfld(&msg->mrfld_header, bytes->ipc_msg,
196 bytes->task_id, 1, pvt_id);
197 msg->mrfld_header.p.header_high.part.res_rqd = bytes->block;
198 length = bytes->len;
199 msg->mrfld_header.p.header_low_payload = length;
200 dev_dbg(sst_drv_ctx->dev, "length is %d\n", length);
201 memcpy(msg->mailbox_data, &bytes->bytes, bytes->len);
202 if (bytes->block) {
203 block = sst_create_block(sst_drv_ctx, bytes->ipc_msg, pvt_id);
204 if (block == NULL) {
205 kfree(msg);
206 ret = -ENOMEM;
207 goto out;
208 }
209 }
210
211 sst_add_to_dispatch_list_and_post(sst_drv_ctx, msg);
212 dev_dbg(sst_drv_ctx->dev, "msg->mrfld_header.p.header_low_payload:%d",
213 msg->mrfld_header.p.header_low_payload);
214
215 if (bytes->block) {
216 ret = sst_wait_timeout(sst_drv_ctx, block);
217 if (ret) {
218 dev_err(sst_drv_ctx->dev, "fw returned err %d\n", ret);
219 sst_free_block(sst_drv_ctx, block);
220 goto out;
221 }
222 }
223 if (bytes->type == SND_SST_BYTES_GET) {
224
225
226
227
228 if (bytes->block) {
229 unsigned char *r = block->data;
230
231 dev_dbg(sst_drv_ctx->dev, "read back %d bytes",
232 bytes->len);
233 memcpy(bytes->bytes, r, bytes->len);
234 }
235 }
236 if (bytes->block)
237 sst_free_block(sst_drv_ctx, block);
238out:
239 test_and_clear_bit(pvt_id, &sst_drv_ctx->pvt_id);
240 return ret;
241}
242
243
244
245
246
247
248
249
250int sst_pause_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
251{
252 int retval = 0;
253 struct stream_info *str_info;
254
255 dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_pause_stream for %d\n", str_id);
256 str_info = get_stream_info(sst_drv_ctx, str_id);
257 if (!str_info)
258 return -EINVAL;
259 if (str_info->status == STREAM_PAUSED)
260 return 0;
261 if (str_info->status == STREAM_RUNNING ||
262 str_info->status == STREAM_INIT) {
263 if (str_info->prev == STREAM_UN_INIT)
264 return -EBADRQC;
265
266 retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
267 IPC_IA_PAUSE_STREAM_MRFLD, str_info->pipe_id,
268 0, NULL, NULL, true, true, false, true);
269
270 if (retval == 0) {
271 str_info->prev = str_info->status;
272 str_info->status = STREAM_PAUSED;
273 } else if (retval == -SST_ERR_INVALID_STREAM_ID) {
274 retval = -EINVAL;
275 mutex_lock(&sst_drv_ctx->sst_lock);
276 sst_clean_stream(str_info);
277 mutex_unlock(&sst_drv_ctx->sst_lock);
278 }
279 } else {
280 retval = -EBADRQC;
281 dev_dbg(sst_drv_ctx->dev, "SST DBG:BADRQC for stream\n");
282 }
283
284 return retval;
285}
286
287
288
289
290
291
292
293
294int sst_resume_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
295{
296 int retval = 0;
297 struct stream_info *str_info;
298
299 dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_resume_stream for %d\n", str_id);
300 str_info = get_stream_info(sst_drv_ctx, str_id);
301 if (!str_info)
302 return -EINVAL;
303 if (str_info->status == STREAM_RUNNING)
304 return 0;
305
306 if (str_info->resume_status == STREAM_PAUSED &&
307 str_info->resume_prev == STREAM_RUNNING) {
308
309
310
311
312 dev_dbg(sst_drv_ctx->dev, "restart recreated stream after resume\n");
313 str_info->status = STREAM_RUNNING;
314 str_info->prev = STREAM_PAUSED;
315 retval = sst_start_stream(sst_drv_ctx, str_id);
316 str_info->resume_status = STREAM_UN_INIT;
317 } else if (str_info->resume_status == STREAM_PAUSED &&
318 str_info->resume_prev == STREAM_INIT) {
319
320
321
322
323 dev_dbg(sst_drv_ctx->dev, "leaving recreated stream idle after resume\n");
324 str_info->status = STREAM_INIT;
325 str_info->prev = STREAM_PAUSED;
326 str_info->resume_status = STREAM_UN_INIT;
327 } else if (str_info->status == STREAM_PAUSED) {
328 retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
329 IPC_CMD, IPC_IA_RESUME_STREAM_MRFLD,
330 str_info->pipe_id, 0, NULL, NULL,
331 true, true, false, true);
332
333 if (!retval) {
334 if (str_info->prev == STREAM_RUNNING)
335 str_info->status = STREAM_RUNNING;
336 else
337 str_info->status = STREAM_INIT;
338 str_info->prev = STREAM_PAUSED;
339 } else if (retval == -SST_ERR_INVALID_STREAM_ID) {
340 retval = -EINVAL;
341 mutex_lock(&sst_drv_ctx->sst_lock);
342 sst_clean_stream(str_info);
343 mutex_unlock(&sst_drv_ctx->sst_lock);
344 }
345 } else {
346 retval = -EBADRQC;
347 dev_err(sst_drv_ctx->dev, "SST ERR: BADQRC for stream\n");
348 }
349
350 return retval;
351}
352
353
354
355
356
357
358
359
360
361int sst_drop_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
362{
363 int retval = 0;
364 struct stream_info *str_info;
365
366 dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_drop_stream for %d\n", str_id);
367 str_info = get_stream_info(sst_drv_ctx, str_id);
368 if (!str_info)
369 return -EINVAL;
370
371 if (str_info->status != STREAM_UN_INIT) {
372 str_info->prev = STREAM_UN_INIT;
373 str_info->status = STREAM_INIT;
374 str_info->cumm_bytes = 0;
375 retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
376 IPC_CMD, IPC_IA_DROP_STREAM_MRFLD,
377 str_info->pipe_id, 0, NULL, NULL,
378 true, true, true, false);
379 } else {
380 retval = -EBADRQC;
381 dev_dbg(sst_drv_ctx->dev, "BADQRC for stream, state %x\n",
382 str_info->status);
383 }
384 return retval;
385}
386
387
388
389
390
391
392
393
394int sst_drain_stream(struct intel_sst_drv *sst_drv_ctx,
395 int str_id, bool partial_drain)
396{
397 int retval = 0;
398 struct stream_info *str_info;
399
400 dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_drain_stream for %d\n", str_id);
401 str_info = get_stream_info(sst_drv_ctx, str_id);
402 if (!str_info)
403 return -EINVAL;
404 if (str_info->status != STREAM_RUNNING &&
405 str_info->status != STREAM_INIT &&
406 str_info->status != STREAM_PAUSED) {
407 dev_err(sst_drv_ctx->dev, "SST ERR: BADQRC for stream = %d\n",
408 str_info->status);
409 return -EBADRQC;
410 }
411
412 retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
413 IPC_IA_DRAIN_STREAM_MRFLD, str_info->pipe_id,
414 sizeof(u8), &partial_drain, NULL, true, true, false, false);
415
416
417
418
419
420
421 return retval;
422}
423
424
425
426
427
428
429
430
431int sst_free_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
432{
433 int retval = 0;
434 struct stream_info *str_info;
435
436 dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_free_stream for %d\n", str_id);
437
438 mutex_lock(&sst_drv_ctx->sst_lock);
439 if (sst_drv_ctx->sst_state == SST_RESET) {
440 mutex_unlock(&sst_drv_ctx->sst_lock);
441 return -ENODEV;
442 }
443 mutex_unlock(&sst_drv_ctx->sst_lock);
444 str_info = get_stream_info(sst_drv_ctx, str_id);
445 if (!str_info)
446 return -EINVAL;
447
448 mutex_lock(&str_info->lock);
449 if (str_info->status != STREAM_UN_INIT) {
450 str_info->prev = str_info->status;
451 str_info->status = STREAM_UN_INIT;
452 mutex_unlock(&str_info->lock);
453
454 dev_dbg(sst_drv_ctx->dev, "Free for str %d pipe %#x\n",
455 str_id, str_info->pipe_id);
456 retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
457 IPC_IA_FREE_STREAM_MRFLD, str_info->pipe_id, 0,
458 NULL, NULL, true, true, false, true);
459
460 dev_dbg(sst_drv_ctx->dev, "sst: wait for free returned %d\n",
461 retval);
462 mutex_lock(&sst_drv_ctx->sst_lock);
463 sst_clean_stream(str_info);
464 mutex_unlock(&sst_drv_ctx->sst_lock);
465 dev_dbg(sst_drv_ctx->dev, "SST DBG:Stream freed\n");
466 } else {
467 mutex_unlock(&str_info->lock);
468 retval = -EBADRQC;
469 dev_dbg(sst_drv_ctx->dev, "SST DBG:BADQRC for stream\n");
470 }
471
472 return retval;
473}
474