?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging:iio:trigger handle name attr in core, remove old alloc and register any contr...
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / intel_sst / intel_sst_ipc.c
blob5c3444f6ab4146ba2f828921d9f8d0482a049cbb
1 /*
2 * intel_sst_ipc.c - Intel SST Driver for audio engine
3 *
4 * Copyright (C) 2008-10 Intel Corporation
5 * Authors: Vinod Koul <vinod.koul@intel.com>
6 * Harsha Priya <priya.harsha@intel.com>
7 * Dharageswari R <dharageswari.r@intel.com>
8 * KP Jeeja <jeeja.kp@intel.com>
9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; version 2 of the License.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 *
24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 *
26 * This file defines all ipc functions
27 */
28
29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30
31 #include <linux/pci.h>
32 #include <linux/firmware.h>
33 #include <linux/sched.h>
34 #include "intel_sst.h"
35 #include "intel_sst_ioctl.h"
36 #include "intel_sst_fw_ipc.h"
37 #include "intel_sst_common.h"
38
39 /*
40 * sst_send_sound_card_type - send sound card type
41 *
42 * this function sends the sound card type to sst dsp engine
43 */
44 static void sst_send_sound_card_type(void)
45 {
46 struct ipc_post *msg = NULL;
47
48 if (sst_create_short_msg(&msg))
49 return;
50
51 sst_fill_header(&msg->header, IPC_IA_SET_PMIC_TYPE, 0, 0);
52 msg->header.part.data = sst_drv_ctx->pmic_vendor;
53 spin_lock(&sst_drv_ctx->list_spin_lock);
54 list_add_tail(&msg->node, &sst_drv_ctx->ipc_dispatch_list);
55 spin_unlock(&sst_drv_ctx->list_spin_lock);
56 sst_post_message(&sst_drv_ctx->ipc_post_msg_wq);
57 return;
58 }
59
60 /**
61 * sst_post_message - Posts message to SST
62 *
63 * @work: Pointer to work structure
64 *
65 * This function is called by any component in driver which
66 * wants to send an IPC message. This will post message only if
67 * busy bit is free
68 */
69 void sst_post_message(struct work_struct *work)
70 {
71 struct ipc_post *msg;
72 union ipc_header header;
73 union interrupt_reg imr;
74 int retval = 0;
75 imr.full = 0;
76
77 /*To check if LPE is in stalled state.*/
78 retval = sst_stalled();
79 if (retval < 0) {
80 pr_err("in stalled state\n");
81 return;
82 }
83 pr_debug("post message called\n");
84 spin_lock(&sst_drv_ctx->list_spin_lock);
85
86 /* check list */
87 if (list_empty(&sst_drv_ctx->ipc_dispatch_list)) {
88 /* list is empty, mask imr */
89 pr_debug("Empty msg queue... masking\n");
90 imr.full = readl(sst_drv_ctx->shim + SST_IMRX);
91 imr.part.done_interrupt = 1;
92 /* dummy register for shim workaround */
93 sst_shim_write(sst_drv_ctx->shim, SST_IMRX, imr.full);
94 spin_unlock(&sst_drv_ctx->list_spin_lock);
95 return;
96 }
97
98 /* check busy bit */
99 header.full = sst_shim_read(sst_drv_ctx->shim, SST_IPCX);
100 if (header.part.busy) {
101 /* busy, unmask */
102 pr_debug("Busy not free... unmasking\n");
103 imr.full = readl(sst_drv_ctx->shim + SST_IMRX);
104 imr.part.done_interrupt = 0;
105 /* dummy register for shim workaround */
106 sst_shim_write(sst_drv_ctx->shim, SST_IMRX, imr.full);
107 spin_unlock(&sst_drv_ctx->list_spin_lock);
108 return;
109 }
110 /* copy msg from list */
111 msg = list_entry(sst_drv_ctx->ipc_dispatch_list.next,
112 struct ipc_post, node);
113 list_del(&msg->node);
114 pr_debug("Post message: header = %x\n", msg->header.full);
115 pr_debug("size: = %x\n", msg->header.part.data);
116 if (msg->header.part.large)
117 memcpy_toio(sst_drv_ctx->mailbox + SST_MAILBOX_SEND,
118 msg->mailbox_data, msg->header.part.data);
119 /* dummy register for shim workaround */
120
121 sst_shim_write(sst_drv_ctx->shim, SST_IPCX, msg->header.full);
122 spin_unlock(&sst_drv_ctx->list_spin_lock);
123
124 kfree(msg->mailbox_data);
125 kfree(msg);
126 return;
127 }
128
129 /*
130 * sst_clear_interrupt - clear the SST FW interrupt
131 *
132 * This function clears the interrupt register after the interrupt
133 * bottom half is complete allowing next interrupt to arrive
134 */
135 void sst_clear_interrupt(void)
136 {
137 union interrupt_reg isr;
138 union interrupt_reg imr;
139 union ipc_header clear_ipc;
140
141 imr.full = sst_shim_read(sst_drv_ctx->shim, SST_IMRX);
142 isr.full = sst_shim_read(sst_drv_ctx->shim, SST_ISRX);
143 /* write 1 to clear */;
144 isr.part.busy_interrupt = 1;
145 sst_shim_write(sst_drv_ctx->shim, SST_ISRX, isr.full);
146 /* Set IA done bit */
147 clear_ipc.full = sst_shim_read(sst_drv_ctx->shim, SST_IPCD);
148 clear_ipc.part.busy = 0;
149 clear_ipc.part.done = 1;
150 clear_ipc.part.data = IPC_ACK_SUCCESS;
151 sst_shim_write(sst_drv_ctx->shim, SST_IPCD, clear_ipc.full);
152 /* un mask busy interrupt */
153 imr.part.busy_interrupt = 0;
154 sst_shim_write(sst_drv_ctx->shim, SST_IMRX, imr.full);
155 }
156
157 void sst_restore_fw_context(void)
158 {
159 struct snd_sst_ctxt_params fw_context;
160 struct ipc_post *msg = NULL;
161
162 pr_debug("restore_fw_context\n");
163 /*check cpu type*/
164 if (sst_drv_ctx->pci_id != SST_MFLD_PCI_ID)
165 return;
166 /*not supported for rest*/
167 if (!sst_drv_ctx->fw_cntx_size)
168 return;
169 /*nothing to restore*/
170 pr_debug("restoring context......\n");
171 /*send msg to fw*/
172 if (sst_create_large_msg(&msg))
173 return;
174
175 sst_fill_header(&msg->header, IPC_IA_SET_FW_CTXT, 1, 0);
176 msg->header.part.data = sizeof(fw_context) + sizeof(u32);
177 fw_context.address = virt_to_phys((void *)sst_drv_ctx->fw_cntx);
178 fw_context.size = sst_drv_ctx->fw_cntx_size;
179 memcpy(msg->mailbox_data, &msg->header, sizeof(u32));
180 memcpy(msg->mailbox_data + sizeof(u32),
181 &fw_context, sizeof(fw_context));
182 spin_lock(&sst_drv_ctx->list_spin_lock);
183 list_add_tail(&msg->node, &sst_drv_ctx->ipc_dispatch_list);
184 spin_unlock(&sst_drv_ctx->list_spin_lock);
185 sst_post_message(&sst_drv_ctx->ipc_post_msg_wq);
186 return;
187 }
188 /*
189 * process_fw_init - process the FW init msg
190 *
191 * @msg: IPC message from FW
192 *
193 * This function processes the FW init msg from FW
194 * marks FW state and prints debug info of loaded FW
195 */
196 int process_fw_init(struct sst_ipc_msg_wq *msg)
197 {
198 struct ipc_header_fw_init *init =
199 (struct ipc_header_fw_init *)msg->mailbox;
200 int retval = 0;
201
202 pr_debug("*** FW Init msg came***\n");
203 if (init->result) {
204 mutex_lock(&sst_drv_ctx->sst_lock);
205 sst_drv_ctx->sst_state = SST_ERROR;
206 mutex_unlock(&sst_drv_ctx->sst_lock);
207 pr_debug("FW Init failed, Error %x\n", init->result);
208 pr_err("FW Init failed, Error %x\n", init->result);
209 retval = -init->result;
210 return retval;
211 }
212 if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID)
213 sst_send_sound_card_type();
214 mutex_lock(&sst_drv_ctx->sst_lock);
215 sst_drv_ctx->sst_state = SST_FW_RUNNING;
216 sst_drv_ctx->lpe_stalled = 0;
217 mutex_unlock(&sst_drv_ctx->sst_lock);
218 pr_debug("FW Version %02x.%02x.%02x\n", init->fw_version.major,
219 init->fw_version.minor, init->fw_version.build);
220 pr_debug("Build Type %x\n", init->fw_version.type);
221 pr_debug(" Build date %s Time %s\n",
222 init->build_info.date, init->build_info.time);
223 sst_wake_up_alloc_block(sst_drv_ctx, FW_DWNL_ID, retval, NULL);
224 sst_restore_fw_context();
225 return retval;
226 }
227 /**
228 * sst_process_message - Processes message from SST
229 *
230 * @work: Pointer to work structure
231 *
232 * This function is scheduled by ISR
233 * It take a msg from process_queue and does action based on msg
234 */
235 void sst_process_message(struct work_struct *work)
236 {
237 struct sst_ipc_msg_wq *msg =
238 container_of(work, struct sst_ipc_msg_wq, wq);
239 int str_id = msg->header.part.str_id;
240
241 pr_debug("IPC process for %x\n", msg->header.full);
242
243 /* based on msg in list call respective handler */
244 switch (msg->header.part.msg_id) {
245 case IPC_SST_BUF_UNDER_RUN:
246 case IPC_SST_BUF_OVER_RUN:
247 if (sst_validate_strid(str_id)) {
248 pr_err("stream id %d invalid\n", str_id);
249 break;
250 }
251 pr_err("Buffer under/overrun for %d\n",
252 msg->header.part.str_id);
253 pr_err("Got Underrun & not to send data...ignore\n");
254 break;
255
256 case IPC_SST_GET_PLAY_FRAMES:
257 if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID) {
258 struct stream_info *stream ;
259
260 if (sst_validate_strid(str_id)) {
261 pr_err("strid %d invalid\n", str_id);
262 break;
263 }
264 /* call sst_play_frame */
265 stream = &sst_drv_ctx->streams[str_id];
266 pr_debug("sst_play_frames for %d\n",
267 msg->header.part.str_id);
268 mutex_lock(&sst_drv_ctx->streams[str_id].lock);
269 sst_play_frame(msg->header.part.str_id);
270 mutex_unlock(&sst_drv_ctx->streams[str_id].lock);
271 break;
272 } else
273 pr_err("sst_play_frames for Penwell!!\n");
274
275 case IPC_SST_GET_CAPT_FRAMES:
276 if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID) {
277 struct stream_info *stream;
278 /* call sst_capture_frame */
279 if (sst_validate_strid(str_id)) {
280 pr_err("str id %d invalid\n", str_id);
281 break;
282 }
283 stream = &sst_drv_ctx->streams[str_id];
284 pr_debug("sst_capture_frames for %d\n",
285 msg->header.part.str_id);
286 mutex_lock(&stream->lock);
287 if (stream->mmapped == false &&
288 stream->src == SST_DRV) {
289 pr_debug("waking up block for copy.\n");
290 stream->data_blk.ret_code = 0;
291 stream->data_blk.condition = true;
292 stream->data_blk.on = false;
293 wake_up(&sst_drv_ctx->wait_queue);
294 } else
295 sst_capture_frame(msg->header.part.str_id);
296 mutex_unlock(&stream->lock);
297 } else
298 pr_err("sst_play_frames for Penwell!!\n");
299 break;
300
301 case IPC_IA_PRINT_STRING:
302 pr_debug("been asked to print something by fw\n");
303 /* TBD */
304 break;
305
306 case IPC_IA_FW_INIT_CMPLT: {
307 /* send next data to FW */
308 process_fw_init(msg);
309 break;
310 }
311
312 case IPC_SST_STREAM_PROCESS_FATAL_ERR:
313 if (sst_validate_strid(str_id)) {
314 pr_err("stream id %d invalid\n", str_id);
315 break;
316 }
317 pr_err("codec fatal error %x stream %d...\n",
318 msg->header.full, msg->header.part.str_id);
319 pr_err("Dropping the stream\n");
320 sst_drop_stream(msg->header.part.str_id);
321 break;
322 case IPC_IA_LPE_GETTING_STALLED:
323 sst_drv_ctx->lpe_stalled = 1;
324 break;
325 case IPC_IA_LPE_UNSTALLED:
326 sst_drv_ctx->lpe_stalled = 0;
327 break;
328 default:
329 /* Illegal case */
330 pr_err("Unhandled msg %x header %x\n",
331 msg->header.part.msg_id, msg->header.full);
332 }
333 sst_clear_interrupt();
334 return;
335 }
336
337 /**
338 * sst_process_reply - Processes reply message from SST
339 *
340 * @work: Pointer to work structure
341 *
342 * This function is scheduled by ISR
343 * It take a reply msg from response_queue and
344 * does action based on msg
345 */
346 void sst_process_reply(struct work_struct *work)
347 {
348 struct sst_ipc_msg_wq *msg =
349 container_of(work, struct sst_ipc_msg_wq, wq);
350
351 int str_id = msg->header.part.str_id;
352 struct stream_info *str_info;
353
354 switch (msg->header.part.msg_id) {
355 case IPC_IA_TARGET_DEV_SELECT:
356 if (!msg->header.part.data) {
357 sst_drv_ctx->tgt_dev_blk.ret_code = 0;
358 } else {
359 pr_err(" Msg %x reply error %x\n",
360 msg->header.part.msg_id, msg->header.part.data);
361 sst_drv_ctx->tgt_dev_blk.ret_code =
362 -msg->header.part.data;
363 }
364
365 if (sst_drv_ctx->tgt_dev_blk.on == true) {
366 sst_drv_ctx->tgt_dev_blk.condition = true;
367 wake_up(&sst_drv_ctx->wait_queue);
368 }
369 break;
370 case IPC_IA_ALG_PARAMS: {
371 pr_debug("sst:IPC_ALG_PARAMS response %x\n", msg->header.full);
372 pr_debug("sst: data value %x\n", msg->header.part.data);
373 pr_debug("sst: large value %x\n", msg->header.part.large);
374
375 if (!msg->header.part.large) {
376 if (!msg->header.part.data) {
377 pr_debug("sst: alg set success\n");
378 sst_drv_ctx->ppp_params_blk.ret_code = 0;
379 } else {
380 pr_debug("sst: alg set failed\n");
381 sst_drv_ctx->ppp_params_blk.ret_code =
382 -msg->header.part.data;
383 }
384
385 } else if (msg->header.part.data) {
386 struct snd_ppp_params *mailbox_params, *get_params;
387 char *params;
388
389 pr_debug("sst: alg get success\n");
390 mailbox_params = (struct snd_ppp_params *)msg->mailbox;
391 get_params = kzalloc(sizeof(*get_params), GFP_KERNEL);
392 if (get_params == NULL) {
393 pr_err("sst: out of memory for ALG PARAMS");
394 break;
395 }
396 memcpy_fromio(get_params, mailbox_params,
397 sizeof(*get_params));
398 get_params->params = kzalloc(mailbox_params->size,
399 GFP_KERNEL);
400 if (get_params->params == NULL) {
401 kfree(get_params);
402 pr_err("sst: out of memory for ALG PARAMS block");
403 break;
404 }
405 params = msg->mailbox;
406 params = params + sizeof(*mailbox_params) - sizeof(u32);
407 memcpy_fromio(get_params->params, params,
408 get_params->size);
409 sst_drv_ctx->ppp_params_blk.ret_code = 0;
410 sst_drv_ctx->ppp_params_blk.data = get_params;
411 }
412
413 if (sst_drv_ctx->ppp_params_blk.on == true) {
414 sst_drv_ctx->ppp_params_blk.condition = true;
415 wake_up(&sst_drv_ctx->wait_queue);
416 }
417 break;
418 }
419
420 case IPC_IA_TUNING_PARAMS: {
421 pr_debug("sst:IPC_TUNING_PARAMS resp: %x\n", msg->header.full);
422 pr_debug("data value %x\n", msg->header.part.data);
423 if (msg->header.part.large) {
424 pr_debug("alg set failed\n");
425 sst_drv_ctx->ppp_params_blk.ret_code =
426 -msg->header.part.data;
427 } else {
428 pr_debug("alg set success\n");
429 sst_drv_ctx->ppp_params_blk.ret_code = 0;
430 }
431 if (sst_drv_ctx->ppp_params_blk.on == true) {
432 sst_drv_ctx->ppp_params_blk.condition = true;
433 wake_up(&sst_drv_ctx->wait_queue);
434 }
435 }
436
437 case IPC_IA_GET_FW_INFO: {
438 struct snd_sst_fw_info *fw_info =
439 (struct snd_sst_fw_info *)msg->mailbox;
440 if (msg->header.part.large) {
441 int major = fw_info->fw_version.major;
442 int minor = fw_info->fw_version.minor;
443 int build = fw_info->fw_version.build;
444 pr_debug("Msg succeeded %x\n",
445 msg->header.part.msg_id);
446 pr_debug("INFO: ***FW*** = %02d.%02d.%02d\n",
447 major, minor, build);
448 memcpy_fromio(sst_drv_ctx->fw_info_blk.data,
449 ((struct snd_sst_fw_info *)(msg->mailbox)),
450 sizeof(struct snd_sst_fw_info));
451 sst_drv_ctx->fw_info_blk.ret_code = 0;
452 } else {
453 pr_err(" Msg %x reply error %x\n",
454 msg->header.part.msg_id, msg->header.part.data);
455 sst_drv_ctx->fw_info_blk.ret_code =
456 -msg->header.part.data;
457 }
458 if (sst_drv_ctx->fw_info_blk.on == true) {
459 pr_debug("Memcopy succeeded\n");
460 sst_drv_ctx->fw_info_blk.on = false;
461 sst_drv_ctx->fw_info_blk.condition = true;
462 wake_up(&sst_drv_ctx->wait_queue);
463 }
464 break;
465 }
466 case IPC_IA_SET_STREAM_MUTE:
467 if (!msg->header.part.data) {
468 pr_debug("Msg succeeded %x\n",
469 msg->header.part.msg_id);
470 sst_drv_ctx->mute_info_blk.ret_code = 0;
471 } else {
472 pr_err(" Msg %x reply error %x\n",
473 msg->header.part.msg_id, msg->header.part.data);
474 sst_drv_ctx->mute_info_blk.ret_code =
475 -msg->header.part.data;
476
477 }
478 if (sst_drv_ctx->mute_info_blk.on == true) {
479 sst_drv_ctx->mute_info_blk.on = false;
480 sst_drv_ctx->mute_info_blk.condition = true;
481 wake_up(&sst_drv_ctx->wait_queue);
482 }
483 break;
484 case IPC_IA_SET_STREAM_VOL:
485 if (!msg->header.part.data) {
486 pr_debug("Msg succeeded %x\n",
487 msg->header.part.msg_id);
488 sst_drv_ctx->vol_info_blk.ret_code = 0;
489 } else {
490 pr_err(" Msg %x reply error %x\n",
491 msg->header.part.msg_id,
492 msg->header.part.data);
493 sst_drv_ctx->vol_info_blk.ret_code =
494 -msg->header.part.data;
495
496 }
497
498 if (sst_drv_ctx->vol_info_blk.on == true) {
499 sst_drv_ctx->vol_info_blk.on = false;
500 sst_drv_ctx->vol_info_blk.condition = true;
501 wake_up(&sst_drv_ctx->wait_queue);
502 }
503 break;
504 case IPC_IA_GET_STREAM_VOL:
505 if (msg->header.part.large) {
506 pr_debug("Large Msg Received Successfully\n");
507 pr_debug("Msg succeeded %x\n",
508 msg->header.part.msg_id);
509 memcpy_fromio(sst_drv_ctx->vol_info_blk.data,
510 (void *) msg->mailbox,
511 sizeof(struct snd_sst_vol));
512 sst_drv_ctx->vol_info_blk.ret_code = 0;
513 } else {
514 pr_err("Msg %x reply error %x\n",
515 msg->header.part.msg_id, msg->header.part.data);
516 sst_drv_ctx->vol_info_blk.ret_code =
517 -msg->header.part.data;
518 }
519 if (sst_drv_ctx->vol_info_blk.on == true) {
520 sst_drv_ctx->vol_info_blk.on = false;
521 sst_drv_ctx->vol_info_blk.condition = true;
522 wake_up(&sst_drv_ctx->wait_queue);
523 }
524 break;
525
526 case IPC_IA_GET_STREAM_PARAMS:
527 if (sst_validate_strid(str_id)) {
528 pr_err("stream id %d invalid\n", str_id);
529 break;
530 }
531 str_info = &sst_drv_ctx->streams[str_id];
532 if (msg->header.part.large) {
533 pr_debug("Get stream large success\n");
534 memcpy_fromio(str_info->ctrl_blk.data,
535 ((void *)(msg->mailbox)),
536 sizeof(struct snd_sst_fw_get_stream_params));
537 str_info->ctrl_blk.ret_code = 0;
538 } else {
539 pr_err("Msg %x reply error %x\n",
540 msg->header.part.msg_id, msg->header.part.data);
541 str_info->ctrl_blk.ret_code = -msg->header.part.data;
542 }
543 if (str_info->ctrl_blk.on == true) {
544 str_info->ctrl_blk.on = false;
545 str_info->ctrl_blk.condition = true;
546 wake_up(&sst_drv_ctx->wait_queue);
547 }
548 break;
549 case IPC_IA_DECODE_FRAMES:
550 if (sst_validate_strid(str_id)) {
551 pr_err("stream id %d invalid\n", str_id);
552 break;
553 }
554 str_info = &sst_drv_ctx->streams[str_id];
555 if (msg->header.part.large) {
556 pr_debug("Msg succeeded %x\n",
557 msg->header.part.msg_id);
558 memcpy_fromio(str_info->data_blk.data,
559 ((void *)(msg->mailbox)),
560 sizeof(struct snd_sst_decode_info));
561 str_info->data_blk.ret_code = 0;
562 } else {
563 pr_err("Msg %x reply error %x\n",
564 msg->header.part.msg_id, msg->header.part.data);
565 str_info->data_blk.ret_code = -msg->header.part.data;
566 }
567 if (str_info->data_blk.on == true) {
568 str_info->data_blk.on = false;
569 str_info->data_blk.condition = true;
570 wake_up(&sst_drv_ctx->wait_queue);
571 }
572 break;
573 case IPC_IA_DRAIN_STREAM:
574 if (sst_validate_strid(str_id)) {
575 pr_err("stream id %d invalid\n", str_id);
576 break;
577 }
578 str_info = &sst_drv_ctx->streams[str_id];
579 if (!msg->header.part.data) {
580 pr_debug("Msg succeeded %x\n",
581 msg->header.part.msg_id);
582 str_info->ctrl_blk.ret_code = 0;
583
584 } else {
585 pr_err(" Msg %x reply error %x\n",
586 msg->header.part.msg_id, msg->header.part.data);
587 str_info->ctrl_blk.ret_code = -msg->header.part.data;
588
589 }
590 str_info = &sst_drv_ctx->streams[str_id];
591 if (str_info->data_blk.on == true) {
592 str_info->data_blk.on = false;
593 str_info->data_blk.condition = true;
594 wake_up(&sst_drv_ctx->wait_queue);
595 }
596 break;
597
598 case IPC_IA_DROP_STREAM:
599 if (sst_validate_strid(str_id)) {
600 pr_err("str id %d invalid\n", str_id);
601 break;
602 }
603 str_info = &sst_drv_ctx->streams[str_id];
604 if (msg->header.part.large) {
605 struct snd_sst_drop_response *drop_resp =
606 (struct snd_sst_drop_response *)msg->mailbox;
607
608 pr_debug("Drop ret bytes %x\n", drop_resp->bytes);
609
610 str_info->curr_bytes = drop_resp->bytes;
611 str_info->ctrl_blk.ret_code = 0;
612 } else {
613 pr_err(" Msg %x reply error %x\n",
614 msg->header.part.msg_id, msg->header.part.data);
615 str_info->ctrl_blk.ret_code = -msg->header.part.data;
616 }
617 if (str_info->ctrl_blk.on == true) {
618 str_info->ctrl_blk.on = false;
619 str_info->ctrl_blk.condition = true;
620 wake_up(&sst_drv_ctx->wait_queue);
621 }
622 break;
623 case IPC_IA_ENABLE_RX_TIME_SLOT:
624 if (!msg->header.part.data) {
625 pr_debug("RX_TIME_SLOT success\n");
626 sst_drv_ctx->hs_info_blk.ret_code = 0;
627 } else {
628 pr_err(" Msg %x reply error %x\n",
629 msg->header.part.msg_id,
630 msg->header.part.data);
631 sst_drv_ctx->hs_info_blk.ret_code =
632 -msg->header.part.data;
633 }
634 if (sst_drv_ctx->hs_info_blk.on == true) {
635 sst_drv_ctx->hs_info_blk.on = false;
636 sst_drv_ctx->hs_info_blk.condition = true;
637 wake_up(&sst_drv_ctx->wait_queue);
638 }
639 break;
640 case IPC_IA_PAUSE_STREAM:
641 case IPC_IA_RESUME_STREAM:
642 case IPC_IA_SET_STREAM_PARAMS:
643 str_info = &sst_drv_ctx->streams[str_id];
644 if (!msg->header.part.data) {
645 pr_debug("Msg succeeded %x\n",
646 msg->header.part.msg_id);
647 str_info->ctrl_blk.ret_code = 0;
648 } else {
649 pr_err(" Msg %x reply error %x\n",
650 msg->header.part.msg_id,
651 msg->header.part.data);
652 str_info->ctrl_blk.ret_code = -msg->header.part.data;
653 }
654 if (sst_validate_strid(str_id)) {
655 pr_err(" stream id %d invalid\n", str_id);
656 break;
657 }
658
659 if (str_info->ctrl_blk.on == true) {
660 str_info->ctrl_blk.on = false;
661 str_info->ctrl_blk.condition = true;
662 wake_up(&sst_drv_ctx->wait_queue);
663 }
664 break;
665
666 case IPC_IA_FREE_STREAM:
667 str_info = &sst_drv_ctx->streams[str_id];
668 if (!msg->header.part.data) {
669 pr_debug("Stream %d freed\n", str_id);
670 } else {
671 pr_err("Free for %d ret error %x\n",
672 str_id, msg->header.part.data);
673 }
674 if (str_info->ctrl_blk.on == true) {
675 str_info->ctrl_blk.on = false;
676 str_info->ctrl_blk.condition = true;
677 wake_up(&sst_drv_ctx->wait_queue);
678 }
679 break;
680 case IPC_IA_ALLOC_STREAM: {
681 /* map to stream, call play */
682 struct snd_sst_alloc_response *resp =
683 (struct snd_sst_alloc_response *)msg->mailbox;
684 if (resp->str_type.result)
685 pr_err("error alloc stream = %x\n",
686 resp->str_type.result);
687 sst_alloc_stream_response(str_id, resp);
688 break;
689 }
690
691 case IPC_IA_PLAY_FRAMES:
692 case IPC_IA_CAPT_FRAMES:
693 if (sst_validate_strid(str_id)) {
694 pr_err("stream id %d invalid\n", str_id);
695 break;
696 }
697 pr_debug("Ack for play/capt frames received\n");
698 break;
699
700 case IPC_IA_PREP_LIB_DNLD: {
701 struct snd_sst_str_type *str_type =
702 (struct snd_sst_str_type *)msg->mailbox;
703 pr_debug("Prep Lib download %x\n",
704 msg->header.part.msg_id);
705 if (str_type->result)
706 pr_err("Prep lib download %x\n", str_type->result);
707 else
708 pr_debug("Can download codec now...\n");
709 sst_wake_up_alloc_block(sst_drv_ctx, str_id,
710 str_type->result, NULL);
711 break;
712 }
713
714 case IPC_IA_LIB_DNLD_CMPLT: {
715 struct snd_sst_lib_download_info *resp =
716 (struct snd_sst_lib_download_info *)msg->mailbox;
717 int retval = resp->result;
718
719 pr_debug("Lib downloaded %x\n", msg->header.part.msg_id);
720 if (resp->result) {
721 pr_err("err in lib dload %x\n", resp->result);
722 } else {
723 pr_debug("Codec download complete...\n");
724 pr_debug("codec Type %d Ver %d Built %s: %s\n",
725 resp->dload_lib.lib_info.lib_type,
726 resp->dload_lib.lib_info.lib_version,
727 resp->dload_lib.lib_info.b_date,
728 resp->dload_lib.lib_info.b_time);
729 }
730 sst_wake_up_alloc_block(sst_drv_ctx, str_id,
731 retval, NULL);
732 break;
733 }
734
735 case IPC_IA_GET_FW_VERSION: {
736 struct ipc_header_fw_init *version =
737 (struct ipc_header_fw_init *)msg->mailbox;
738 int major = version->fw_version.major;
739 int minor = version->fw_version.minor;
740 int build = version->fw_version.build;
741 dev_info(&sst_drv_ctx->pci->dev,
742 "INFO: ***LOADED SST FW VERSION*** = %02d.%02d.%02d\n",
743 major, minor, build);
744 break;
745 }
746 case IPC_IA_GET_FW_BUILD_INF: {
747 struct sst_fw_build_info *build =
748 (struct sst_fw_build_info *)msg->mailbox;
749 pr_debug("Build date:%sTime:%s", build->date, build->time);
750 break;
751 }
752 case IPC_IA_SET_PMIC_TYPE:
753 break;
754 case IPC_IA_START_STREAM:
755 pr_debug("reply for START STREAM %x\n", msg->header.full);
756 break;
757
758 case IPC_IA_GET_FW_CTXT:
759 pr_debug("reply for get fw ctxt %x\n", msg->header.full);
760 if (msg->header.part.data)
761 sst_drv_ctx->fw_cntx_size = 0;
762 else
763 sst_drv_ctx->fw_cntx_size = *sst_drv_ctx->fw_cntx;
764 pr_debug("fw copied data %x\n", sst_drv_ctx->fw_cntx_size);
765 sst_wake_up_alloc_block(
766 sst_drv_ctx, str_id, msg->header.part.data, NULL);
767 break;
768 default:
769 /* Illegal case */
770 pr_err("process reply:default = %x\n", msg->header.full);
771 }
772 sst_clear_interrupt();
773 return;
774 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree