[alsa-devel] [PATCH] [RFC 6/13] Intel SST driver dsp engine interface module
Vinod Koul
vinod.koul at intel.com
Fri Jul 3 09:04:39 CEST 2009
This adds the IPC module which uses Inter process mechanism
to communicate between driver & SST engine (DSP processor).
To communicate between IA processor and DSP, IPC doorbell
registers are used. A write to these registers triggers
an interrupt to other side. The format of messages
and "mailbox" for message payload is defined in intel_lpe_fw_ipc.h
Signed-off-by: Vinod Koul <vinod.koul at intel.com>
Signed-off-by: Harsha Priya <priya.harsha at intel.com>
new file: sound/pci/sst/intel_sst_fw_ipc.h
new file: sound/pci/sst/intel_sst_ipc.c
---
sound/pci/sst/intel_sst_fw_ipc.h | 368 ++++++++++++++++++++++++++
sound/pci/sst/intel_sst_ipc.c | 536 ++++++++++++++++++++++++++++++++++++++
2 files changed, 904 insertions(+), 0 deletions(-)
create mode 100644 sound/pci/sst/intel_sst_fw_ipc.h
create mode 100644 sound/pci/sst/intel_sst_ipc.c
diff --git a/sound/pci/sst/intel_sst_fw_ipc.h b/sound/pci/sst/intel_sst_fw_ipc.h
new file mode 100644
index 0000000..6520e4e
--- /dev/null
+++ b/sound/pci/sst/intel_sst_fw_ipc.h
@@ -0,0 +1,368 @@
+#ifndef __INTEL_SST_FW_IPC_H__
+#define __INTEL_SST_FW_IPC_H__
+/*
+* intel_sst_fw_ipc.h - Intel SST Driver for audio engine
+*
+* Copyright (C) 2008-09 Intel Corporation
+* Author: Vinod Koul <vinod.koul at intel.com>
+* Harsha Priya <priya.harsha at intel.com>
+* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+*
+* This program is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation; version 2 of the License.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License along
+* with this program; if not, write to the Free Software Foundation, Inc.,
+* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+*
+* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+*
+* This driver exposes the audio engine functionalities to the ALSA
+* and middleware.
+* This file has definitions shared between the firmware and driver
+*/
+
+#define MAX_NUM_STREAMS 4
+#define MAX_DBG_RW_BYTES 80
+#define MAX_NUM_SCATTER_BUFFERS 8
+#define MAX_LOOP_BACK_DWORDS 8
+/* IPC base address and mailbox, timestamp offsets */
+#define SST_MAILBOX_SIZE 0x0400
+#define SST_MAILBOX_SEND 0x0000
+#define SST_MAILBOX_RCV 0x0804
+#define SST_TIME_STAMP 0x1800
+#define SST_RESERVED_OFFSET 0x1840
+#define SST_CHEKPOINT_OFFSET 0x1C00
+#define REPLY_MSG 0x80
+
+/* Message ID's for IPC messages */
+/* Bits B7: SST or IA/SC ; B6-B4: Msg Category; B3-B0: Msg Type */
+
+/* I2L Firmware/Codec Download msgs */
+#define IPC_IA_PREP_LIB_DNLD 0x01
+#define IPC_IA_LIB_DNLD_CMPLT 0x02
+
+#define IPC_IA_SET_PMIC_TYPE 0x03
+#define IPC_IA_GET_FW_VERSION 0x04
+#define IPC_IA_GET_FW_BUILD_INF 0x05
+#define IPC_IA_GET_FW_INFO 0x06
+
+/* I2L Codec Config/control msgs */
+#define IPC_IA_SET_CODEC_PARAMS 0x10
+#define IPC_IA_GET_CODEC_PARAMS 0x11
+#define IPC_IA_SET_PPP_PARAMS 0x12
+#define IPC_IA_GET_PPP_PARAMS 0x13
+#define IPC_IA_PLAY_FRAMES 0x14
+#define IPC_IA_CAPT_FRAMES 0x15
+#define IPC_IA_PLAY_VOICE 0x16
+#define IPC_IA_CAPT_VOICE 0x17
+#define IPC_IA_DECODE_FRAMES 0x18
+
+/* I2L Stream config/control msgs */
+#define IPC_IA_ALLOC_STREAM 0x20 /* Allocate a stream ID */
+#define IPC_IA_FREE_STREAM 0x21 /* Free the stream ID */
+#define IPC_IA_SET_STREAM_PARAMS 0x22
+#define IPC_IA_GET_STREAM_PARAMS 0x23
+#define IPC_IA_PAUSE_STREAM 0x24
+#define IPC_IA_RESUME_STREAM 0x25
+#define IPC_IA_DROP_STREAM 0x26
+#define IPC_IA_DRAIN_STREAM 0x27 /* Short msg with str_id */
+#define IPC_IA_TARGET_DEV_SELECT 0x28
+#define IPC_IA_CONTROL_ROUTING 0x29
+
+/* Debug msgs */
+#define IPC_IA_DBG_MEM_READ 0x40
+#define IPC_IA_DBG_MEM_WRITE 0x41
+#define IPC_IA_DBG_LOOP_BACK 0x42
+
+/* L2I Firmware/Codec Download msgs */
+#define IPC_IA_FW_INIT_CMPLT 0x81
+
+/* L2I Codec Config/control msgs */
+#define IPC_SST_GET_PLAY_FRAMES 0x90 /* Request IA more data */
+#define IPC_SST_GET_CAPT_FRAMES 0x91 /* Request IA more data */
+#define IPC_SST_BUF_UNDER_RUN 0x92 /* PB Under run and stopped */
+#define IPC_SST_BUF_OVER_RUN 0x93 /* CAP Under run and stopped */
+#define IPC_SST_DRAIN_END 0x94 /* PB Drain complete and stopped */
+#define IPC_SST_CHNGE_SSP_PARAMS 0x95 /* PB SSP parameters changed */
+#define IPC_SST_STREAM_PROCESS_FATAL_ERR 0x96/*error in processing a stream*/
+#define IPC_SST_PERIOD_ELAPSED 0x97 /*period elapsed*/
+#define IPC_IA_TARGET_DEV_CHNGD 0x98 /* error in processing a stream */
+
+/* L2S messages */
+#define IPC_SC_DDR_LINK_UP 0xC0
+#define IPC_SC_DDR_LINK_DOWN 0xC1
+
+/* L2I Error reporting msgs */
+#define IPC_IA_MEM_ALLOC_FAIL 0xE0
+#define IPC_IA_PROC_ERR 0xE1 /* error in processing a
+ stream can be used by playback and
+ capture modules */
+
+/* L2I Debug msgs*/
+#define IPC_IA_PRINT_STRING 0xF0
+
+/* Command Response or Acknowledge message to any IPC message will have
+ * same message ID and stream ID information which is sent.
+ * There is no specific Ack message ID. The data field is used as response
+ * meaning.
+ */
+enum ackData {
+ IPC_ACK_SUCCESS = 0,
+ IPC_ACK_FAILURE
+};
+
+
+enum sst_error_codes {
+ /* Error code,response to msgId: Description */
+ /* Common error codes */
+ SST_SUCCESS = 0, /*Success*/
+ SST_ERR_INVALID_STREAM_ID, /*Invalid stream ID */
+ SST_ERR_INVALID_MSG_ID, /*Invalid message ID */
+ SST_ERR_INVALID_STREAM_OP, /*Invalid stream operation request */
+ SST_ERR_INVALID_PARAMS, /*Invalid params */
+ SST_ERR_INVALID_CODEC, /*Invalid codec type */
+ SST_ERR_INVALID_MEDIA_TYPE, /*Invalid media type */
+ SST_ERR_STREAM_ERR, /*ANY: Stream control or config or
+ processing error */
+
+ /* IPC specific error codes */
+ SST_IPC_ERR_CALL_BACK_NOT_REGD, /*Call back for msg not regd*/
+ SST_IPC_ERR_STREAM_NOT_ALLOCATED, /*Stream is not allocated */
+ SST_IPC_ERR_STREAM_ALLOC_FAILED, /*ALLOC:Stream alloc failed*/
+ SST_IPC_ERR_GET_STREAM_FAILED, /*ALLOC:Get stream id failed*/
+ SST_ERR_MOD_NOT_AVAIL, /* SET/GET: Mod(AEC/AGC/ALC) not available */
+ SST_ERR_MOD_DNLD_RQD, /* SET/GET: Mod(AEC/AGC/ALC) download required*/
+ SST_ERR_STREAM_STOPPED, /* ANY: Stream is in stopped state */
+ SST_ERR_STREAM_IN_USE, /* ANY: Stream is already in use */
+
+ /* Capture specific error codes*/
+ SST_CAP_ERR_INCMPLTE_CAPTURE_MSG,/*ANY:Incomplete message */
+ SST_CAP_ERR_CAPTURE_FAIL, /*ANY:Capture op failed */
+ SST_CAP_ERR_GET_DDR_NEW_SGLIST, /*AR: Meena */
+ SST_CAP_ERR_UNDER_RUN, /* lack of input data */
+ SST_CAP_ERR_OVERFLOW, /* lack of output space */
+
+ /* Playback specific error codes*/
+ SST_PB_ERR_INCMPLTE_PLAY_MSG, /* ANY: Incomplete message */
+ SST_PB_ERR_PLAY_FAIL, /* ANY: Playback operation failed */
+ SST_PB_ERR_GET_DDR_NEW_SGLIST, /* AR: Ashok */
+
+ /* Codec manager specific error codes*/
+ SST_LIB_ERR_LIB_DNLD_REQUIRED, /* ALLOC: Codec download required */
+ SST_LIB_ERR_LIB_NOT_SUPPORTED, /* Library is not supported */
+
+ /* Library manager specific error codes*/
+ SST_SCC_ERR_PREP_DNLD_FAILED, /* Failed to prepare for codec download */
+ SST_SCC_ERR_LIB_DNLD_RES_FAILED, /* Lib download resume failed */
+ /* Scheduler specific error codes*/
+ SST_SCH_ERR_FAIL, /* REPORT: */
+
+ /* DMA specific error codes */
+ SST_DMA_ERR_NO_CHNL_AVAILABLE, /* DMA Ch not available*/
+ SST_DMA_ERR_INVALID_INPUT_PARAMS, /* Invalid input params */
+ SST_DMA_ERR_CHNL_ALREADY_SUSPENDED, /* Ch is suspended */
+ SST_DMA_ERR_CHNL_ALREADY_STARTED, /* Ch already started */
+ SST_DMA_ERR_CHNL_NOT_ENABLED, /* Ch not enabled */
+ SST_DMA_ERR_TRANSFER_FAILED, /* Transfer failed */
+ SST_SSP_ERR_ALREADY_ENABLED, /* REPORT: SSP already enabled*/
+ SST_SSP_ERR_ALREADY_DISABLED, /* REPORT: SSP already disabled*/
+ SST_SSP_ERR_NOT_INITIALIZED,
+
+ /* Other error codes */
+ SST_ERR_MOD_INIT_FAIL, /* Firmware Module init failed */
+
+ /* FW init error codes */
+ SST_RDR_ERR_IO_DEV_SEL_NOT_ALLOWED,
+ SST_RDR_ERR_ROUTE_ALREADY_STARTED,
+ SST_RDR_PREP_CODEC_DNLD_FAILED,
+
+ /* Memory debug error codes */
+ SST_ERR_DBG_MEM_READ_FAIL,
+ SST_ERR_DBG_MEM_WRITE_FAIL,
+
+
+};
+
+enum dbg_mem_data_type {
+ /* Data type of debug read/write */
+ DATA_TYPE_U32,
+ DATA_TYPE_U16,
+ DATA_TYPE_U8,
+};
+
+/* CAUTION NOTE: All IPC message body must be multiple of 32 bits.*/
+
+/* IPC Header */
+union ipc_header {
+ struct {
+ u32 msg_id:8; /* Message ID - Max 256 Message Types */
+ u32 str_id:3; /* Undefined for SC communication */
+ u32 large:1; /* Large Message if large = 1 */
+ u32 reserved:4;/* Reserved for future use */
+ u32 data:14; /* Ack/Info for msg, size of msg in Mailbox */
+ u32 done:1; /* bit 30 */
+ u32 busy:1; /* bit 31 */
+ } part;
+ u32 full;
+} __attribute__ ((packed));
+
+struct ipc_header_fw_init {
+ struct snd_sst_fw_version fw_version;/* Firmware version details*/
+ u16 result; /* Fw init result */
+ u8 module_id; /* Module ID in case of error */
+ u8 debug_info; /* Debug info from Module ID in case of fail */
+} __attribute__ ((packed));
+
+/* Firmware build info */
+struct sst_fw_build_info {
+ unsigned char date[16]; /* Firmware build date */
+ unsigned char time[16]; /* Firmware build time */
+} __attribute__ ((packed));
+
+/* Address and size info of a frame buffer in DDR */
+struct sst_address_info {
+ u32 addr; /* Address at IA */
+ u32 size; /* Size of the buffer */
+} __attribute__ ((packed));
+
+/* Time stamp */
+struct snd_sst_tstamp {
+ u64 samples_processed;
+ u64 samples_rendered;
+ u32 sampling_frequency;
+};
+
+/* Frame info to play or capture */
+struct sst_frame_info {
+ u16 num_entries; /* number of entries to follow */
+ u16 rsrvd;
+ struct sst_address_info addr[MAX_NUM_SCATTER_BUFFERS];
+} __attribute__ ((packed));
+
+/* Frames info for decode */
+struct snd_sst_decode_info {
+ struct snd_sst_dbufs frames_in;
+ struct snd_sst_dbufs frames_out;
+} __attribute__ ((packed));
+/* SST to IA print debug message*/
+struct ipc_sst_ia_print_params {
+ u32 string_size; /* Max value is 160 */
+ u8 prt_string[160]; /* Null terminated Char string */
+} __attribute__ ((packed));
+/* Voice data message */
+struct snd_sst_voice_data {
+ u16 num_bytes; /* Number of valid voice data bytes */
+ u8 pcm_wd_size; /* 0=8 bit, 1=16 bit 2=32 bit*/
+ u8 reserved; /* Reserved */
+ u8 voice_data_buf[0]; /* Voice data buffer in bytes, little endian */
+} __attribute__ ((packed));
+
+/* SST to IA memory read debug message */
+struct ipc_sst_ia_dbg_mem_rw {
+ u16 num_bytes; /* Maximum of MAX_DBG_RW_BYTES */
+ u16 data_type; /* enum: dbg_mem_data_type */
+ u32 address; /* Memory address of data memory of data_type */
+ u8 rw_bytes[MAX_DBG_RW_BYTES];/* Maximum of 64 bytes can be RW */
+} __attribute__ ((packed));
+
+struct ipc_sst_ia_dbg_loop_back {
+ u16 num_dwords; /* Maximum of MAX_DBG_RW_BYTES */
+ u16 increment_val;/* Increments dwords by this value, 0- no increment */
+ u32 lpbk_dwords[MAX_LOOP_BACK_DWORDS];/* Maximum of 8 dwords loopback */
+} __attribute__ ((packed));
+
+/* Stream type params struture for Alloc stream */
+struct snd_sst_str_type {
+ u8 codec_type; /* Codec type */
+ u8 str_type; /* 1 = voice 2 = music */
+ u8 operation; /* Playback or Capture */
+ u8 protected_str; /* 0=Non DRM, 1=DRM */
+ u8 pvt_id; /* Driver Private ID */
+ u8 reserved; /* Reserved */
+ u16 result; /* Result used for acknowledgment */
+} __attribute__ ((packed));
+
+/* Library info structure */
+struct module_info {
+ u32 lib_version;
+ u32 lib_type;
+ u32 media_type;
+ u8 lib_name[12];
+ u32 lib_caps;
+ unsigned char b_date[16]; /* Lib build date */
+ unsigned char b_time[16]; /* Lib build time */
+} __attribute__ ((packed));
+
+/* Library slot info */
+struct lib_slot_info {
+ u8 slot_num; /* 1 or 2*/
+ u8 reserved1;
+ u16 reserved2;
+ u32 iram_size; /* slot size in IRAM */
+ u32 dram_size; /* slot size in DRAM */
+ u32 iram_offset; /* starting offset of slot in IRAM */
+ u32 dram_offset; /* starting offset of slot in DRAM */
+} __attribute__ ((packed));
+
+struct snd_sst_lib_download {
+ struct module_info lib_info; /* library info type, capabilities etc*/
+ struct lib_slot_info slot_info; /* slot info to be downloaded */
+ u32 mod_entry_pt;
+};
+
+struct snd_sst_lib_download_info {
+ struct snd_sst_lib_download dload_lib;
+ u16 result; /* Result used for acknowledgment */
+ u8 pvt_id; /*Private ID*/
+ u8 reserved; /*for alignment*/
+};
+
+/* Alloc stream params structure */
+struct snd_sst_alloc_params {
+ struct snd_sst_str_type str_type;
+ struct snd_sst_stream_params stream_params;
+};
+
+struct snd_sst_fw_get_stream_params {
+ struct snd_sst_str_type str_type;
+ struct snd_sst_params codec_params;
+ struct snd_sst_pmic_config pcm_params;
+};
+
+/* Alloc stream response message */
+struct snd_sst_alloc_response {
+ struct snd_sst_str_type str_type; /* Stream type for allocation*/
+ struct snd_sst_lib_download lib_dnld; /*Valid only for codec dnld*/
+};
+
+/*struct ipc_msg_body {
+ union {
+ CODEC_PARAM_STRUCTURES;
+ PPP_PARAM_STRUCTURES;
+ struct snd_sst_alloc_params alloc_params;
+ struct snd_sst_alloc_response alloc_response;
+ struct snd_sst_stream_params stream_params;
+ struct sst_frame_info frames_info;
+ struct ipc_sst_ia_print_params print_params;
+ struct ipc_sst_ia_dbg_mem_rw dbg_mem_rw;
+ struct ipc_sst_ia_dbg_loop_back loop_back;
+ struct pmic_pcm_params ssp_params;
+ } u;
+};*/
+
+
+
+struct ipc_post {
+ struct list_head node;
+ union ipc_header header; /* driver specific */
+ char *mailbox_data;
+};
+
+#endif /*__INTEL_SST_FW_IPC_H__*/
diff --git a/sound/pci/sst/intel_sst_ipc.c b/sound/pci/sst/intel_sst_ipc.c
new file mode 100644
index 0000000..98b4031
--- /dev/null
+++ b/sound/pci/sst/intel_sst_ipc.c
@@ -0,0 +1,536 @@
+/*
+ * intel_sst_ipc.c - Intel SST Driver for audio engine
+ *
+ * Copyright (C) 2008-09 Intel Corporation
+ * Authors: Vinod Koul <vinod.koul at intel.com>
+ * Harsha Priya <priya.harsha at intel.com>
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This file defines all ipc functions
+ */
+
+#include <linux/cdev.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/syscalls.h>
+#include <linux/file.h>
+#include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/workqueue.h>
+#include <linux/mutex.h>
+#include <linux/firmware.h>
+#include <sound/intel_sst.h>
+#include <sound/intel_sst_ioctl.h>
+#include "intel_sst_fw_ipc.h"
+#include "intel_sst_common.h"
+#include "intel_sst_pvt.h"
+
+void sst_send_loop_test(int loop_no)
+{
+ struct ipc_post *msg = NULL;
+ struct ipc_sst_ia_dbg_loop_back loop_msg;
+ static int large_num;
+
+ sst_dbg("Loop testing %d \n", loop_no);
+
+ if (large_num >= 4) {
+ sst_dbg("Loop testing complete.....\n");
+ return;
+ }
+ if (loop_no >= 4) {
+ /*large loop*/
+ large_num++;
+ sst_dbg("Large msg \n");
+ if (0 != sst_create_large_msg(&msg))
+ return;
+
+ loop_msg.increment_val = 1;
+ loop_msg.lpbk_dwords[0] = 0x11111111;
+ loop_msg.lpbk_dwords[1] = 0x22222222;
+ loop_msg.lpbk_dwords[2] = 0x33333333;
+ loop_msg.lpbk_dwords[3] = 0x44444444;
+ loop_msg.num_dwords = 4;
+ sst_fill_header(&msg->header, IPC_IA_DBG_LOOP_BACK, 1, loop_no);
+ msg->header.part.data = sizeof(u32) + sizeof(loop_msg);
+ memcpy(msg->mailbox_data, &msg->header, sizeof(u32));
+ memcpy(msg->mailbox_data + sizeof(u32),
+ &loop_msg, sizeof(loop_msg));
+ } else {
+ /*short loop*/
+ sst_dbg("Loop Short msg \n");
+ if (0 != sst_create_short_msg(&msg))
+ return;
+ sst_fill_header(&msg->header, IPC_IA_DBG_LOOP_BACK, 0, loop_no);
+ }
+ list_add_tail(&msg->node, &sst_ops->ipc_dispatch_list);
+ sst_post_message(&sst_ops->ipc_post_msg_wq);
+ return;
+}
+
+void sst_send_pmic_type(void)
+{
+ struct ipc_post *msg = NULL;
+
+ sst_dbg("...called\n");
+
+ if (0 != sst_create_short_msg(&msg))
+ return;
+
+ sst_fill_header(&msg->header, IPC_IA_SET_PMIC_TYPE, 0, 0);
+ msg->header.part.data = sst_ops->pmic_vendor;
+ list_add_tail(&msg->node, &sst_ops->ipc_dispatch_list);
+ sst_post_message(&sst_ops->ipc_post_msg_wq);
+ return;
+}
+
+void sst_get_fw_version(void)
+{
+ struct ipc_post *msg = NULL;
+
+ sst_dbg("...called\n");
+
+ if (0 != sst_create_short_msg(&msg))
+ return;
+
+ sst_fill_header(&msg->header, IPC_IA_GET_FW_VERSION, 0, 0);
+ list_add_tail(&msg->node, &sst_ops->ipc_dispatch_list);
+ sst_post_message(&sst_ops->ipc_post_msg_wq);
+ if (0 != sst_create_short_msg(&msg))
+ return;
+
+ sst_fill_header(&msg->header, IPC_IA_GET_FW_BUILD_INF, 0, 0);
+ list_add_tail(&msg->node, &sst_ops->ipc_dispatch_list);
+ sst_post_message(&sst_ops->ipc_post_msg_wq);
+ return;
+}
+
+/**
+* sst_post_message - Posts message to SST
+* @work: Pointer to work structure
+*
+* This function is called by any component in driver which
+* wants to send an IPC message. This will post message only if
+* busy bit is free
+*/
+void sst_post_message(struct work_struct *work)
+{
+ struct ipc_post *msg;
+ union ipc_header header;
+ union interrupt_reg imr;
+ imr.full = 0;
+
+ sst_dbg("..called \n");
+ mutex_lock(&sst_ops->list_lock);
+ /*check list*/
+ if (0 != list_empty(&sst_ops->ipc_dispatch_list)) {
+ /*list is empty, mask imr*/
+ sst_dbg(" Empty msg queue... masking \n");
+ imr.full = readl(sst_ops->shim + SST_IMRX);
+ imr.part.done_interrupt = 1;
+ writel(imr.full, sst_ops->shim + SST_IMRX);
+ mutex_unlock(&sst_ops->list_lock);
+ return;
+ }
+
+ /*check busy bit*/
+ header.full = readl(sst_ops->shim + SST_IPCX);
+ if (1 == header.part.busy) {
+ /*busy, unmask*/
+ sst_dbg("Busy not free... unmasking\n");
+ imr.full = readl(sst_ops->shim + SST_IMRX);
+ imr.part.done_interrupt = 0;
+ writel(imr.full, sst_ops->shim + SST_IMRX);
+ mutex_unlock(&sst_ops->list_lock);
+ return;
+ }
+ /*copy msg from list*/
+ msg = list_entry(sst_ops->ipc_dispatch_list.next,
+ struct ipc_post, node);
+ list_del(&msg->node);
+ sst_dbg("Post message: header = %x\n", msg->header.full);
+ sst_dbg("size: = %x\n", msg->header.part.data);
+ if (1 == msg->header.part.large)
+ memcpy_toio(sst_ops->mailbox + SST_MAILBOX_SEND,
+ msg->mailbox_data, msg->header.part.data);
+ writel(msg->header.full, sst_ops->shim + SST_IPCX);
+ mutex_unlock(&sst_ops->list_lock);
+
+ kfree(msg->mailbox_data);
+ kfree(msg);
+ sst_dbg("...done\n");
+ return;
+}
+
+void sst_clear_interrupt(void)
+{
+ union interrupt_reg isr;
+ union interrupt_reg imr;
+ union ipc_header clear_ipc;
+
+ sst_dbg("sst clearing interrupt \n");
+ imr.full = readl(sst_ops->shim + SST_IMRX);
+ isr.full = readl(sst_ops->shim + SST_ISRX);
+ /* write 1 to clear */;
+ isr.part.busy_interrupt = 1;
+ writel(isr.full, sst_ops->shim + SST_ISRX);
+ /*Set IA done bit*/
+ clear_ipc.full = readl(sst_ops->shim + SST_IPCD);
+ clear_ipc.part.busy = 0;
+ clear_ipc.part.done = 1;
+ clear_ipc.part.data = IPC_ACK_SUCCESS;
+ writel(clear_ipc.full, sst_ops->shim + SST_IPCD);
+ /*un mask busy interrupt*/
+ imr.part.busy_interrupt = 0;
+ writel(imr.full, sst_ops->shim + SST_IMRX);
+}
+
+/**
+* sst_process_message - Processes message from SST
+* @work: Pointer to work structure
+*
+* This function is scheduled by ISR
+* It take a msg from process_queue and does action based on msg
+*/
+void sst_process_message(struct work_struct *work)
+{
+ struct sst_ipc_msg_wq *msg =
+ container_of(work, struct sst_ipc_msg_wq, wq);
+ int str_id = msg->header.part.str_id;
+
+ sst_dbg("called \n");
+
+ /*based on msg in list call respective handler*/
+ switch (msg->header.part.msg_id) {
+ case IPC_SST_BUF_UNDER_RUN:
+ case IPC_SST_BUF_OVER_RUN:
+ if (sst_validate_strid(str_id) != 0) {
+ sst_err("stream id %d invalid\n", str_id);
+ break;
+ }
+ sst_err("Buffer under/overrun for %d\n",
+ msg->header.part.str_id);
+ sst_dbg("Got Underrun & not to send data...ignore\n");
+ break;
+
+ case IPC_SST_GET_PLAY_FRAMES:
+ {
+ struct stream_info *stream ;
+
+ if (sst_validate_strid(str_id) != 0) {
+ sst_err("stream id %d invalid\n", str_id);
+ break;
+ }
+ /*call sst_play_frame*/
+ stream = &sst_ops->streams[str_id];
+ sst_dbg("sst_play_frames for %d\n", msg->header.part.str_id);
+ mutex_lock(&sst_ops->streams[str_id].lock);
+ sst_play_frame(msg->header.part.str_id);
+ mutex_unlock(&sst_ops->streams[str_id].lock);
+ break;
+ }
+
+ case IPC_SST_PERIOD_ELAPSED:
+ {
+ struct snd_sst_tstamp fw_tstamp = {0,};
+ struct stream_info *stream ;
+
+ if (sst_validate_strid(str_id) != 0) {
+ sst_err("stream id %d invalid\n", str_id);
+ break;
+ }
+ stream = &sst_ops->streams[str_id];
+
+ sst_dbg("Period elapsed \n");
+ memcpy_fromio(&fw_tstamp,
+ ((void *)(sst_ops->mailbox + SST_TIME_STAMP) +
+ (str_id * sizeof(fw_tstamp))),
+ sizeof(fw_tstamp));
+ sst_dbg("samples played = %lld\n", fw_tstamp.samples_processed);
+ sst_dbg("diff in mesg = %d\n", msg->header.part.data);
+ sst_clear_interrupt();
+ if (stream->period_elapsed)
+ stream->period_elapsed(stream->pcm_substream);
+ return;
+ }
+
+ case IPC_SST_GET_CAPT_FRAMES:
+ /*call sst_capture_frame*/
+ if (sst_validate_strid(str_id) != 0) {
+ sst_err("stream id %d invalid\n", str_id);
+ break;
+ }
+ sst_dbg("sst_capture_frames for %d\n", msg->header.part.str_id);
+ mutex_lock(&sst_ops->streams[str_id].lock);
+ if (sst_ops->streams[str_id].ops == STREAM_OPS_CAPTURE &&
+ sst_ops->streams[str_id].mmapped == false &&
+ sst_ops->streams[str_id].codec !=
+ SST_CODEC_TYPE_PCM) {
+ sst_dbg("waking up block for copy...\n");
+ sst_ops->streams[str_id].data_blk.ret_code = 0;
+ sst_ops->streams[str_id].data_blk.condition = true;
+ sst_ops->streams[str_id].data_blk.on = false;
+ wake_up(&sst_ops->wait_queue);
+ } else
+ sst_capture_frame(msg->header.part.str_id);
+ mutex_unlock(&sst_ops->streams[str_id].lock);
+ break;
+
+ case IPC_IA_PRINT_STRING:
+ sst_dbg("been asked to print something by fw\n");
+ /*TBD*/
+ break;
+
+ case IPC_IA_FW_INIT_CMPLT: {
+ /*send next data to FW*/
+ struct ipc_header_fw_init *init =
+ (struct ipc_header_fw_init *)msg->mailbox;
+
+ sst_dbg("*** FW Init msg came*** \n");
+ if (0 == init->result) {
+ sst_ops->sst_state = SST_FW_RUNNING;
+ sst_info("FW Version %x.%x \n",
+ init->fw_version.major, init->fw_version.minor);
+ sst_info("Build No %x Type %x \n",
+ init->fw_version.build, init->fw_version.type);
+#ifdef SND_LOOP_TEST
+ sst_send_loop_test(0);
+#endif
+ sst_send_pmic_type();
+ sst_get_fw_version();
+ } else {
+ sst_ops->sst_state = SST_ERROR;
+ sst_dbg("FW Init failed, Error %x\n", init->result);
+ sst_dbg("FW Init failed, Module %x, Debug Info %x \n",
+ init->module_id, init->debug_info);
+ }
+ sst_dbg("Waking up... open\n");
+ sst_wake_up_alloc_block(sst_ops, 0xFF, 0, NULL);
+ break;
+ }
+
+ case IPC_SST_STREAM_PROCESS_FATAL_ERR:
+ if (sst_validate_strid(str_id) != 0) {
+ sst_err("stream id %d invalid\n", str_id);
+ break;
+ }
+ sst_err(" codec fatal error %x for stream %d... \n",
+ msg->header.full, msg->header.part.str_id);
+ sst_err("Dropping the stream \n");
+ sst_drop_stream(msg->header.part.str_id);
+ break;
+
+ default:
+ /*Illegal case*/
+ sst_err("Unhandled case msg_id %x message %x\n",
+ msg->header.part.msg_id, msg->header.full);
+ }
+ sst_clear_interrupt();
+ return;
+}
+
+/**
+* sst_process_reply - Processes reply message from SST
+* @work: Pointer to work structure
+*
+* This function is scheduled by ISR
+* It take a reply msg from response_queue and
+* does action based on msg
+*/
+void sst_process_reply(struct work_struct *work)
+{
+ struct sst_ipc_msg_wq *msg =
+ container_of(work, struct sst_ipc_msg_wq, wq);
+ int str_id = msg->header.part.str_id;
+ struct stream_info *str_info = NULL;
+
+ sst_dbg("called for %x \n", msg->header.full);
+
+ switch (msg->header.part.msg_id) {
+ case IPC_IA_DROP_STREAM:
+ case IPC_IA_PAUSE_STREAM:
+ case IPC_IA_RESUME_STREAM:
+ case IPC_IA_SET_STREAM_PARAMS:
+ if (0 == msg->header.part.data) {
+ sst_dbg("Msg succedded %x \n", msg->header.part.msg_id);
+ } else {
+ sst_err("Msg %x reply error %x \n",
+ msg->header.part.msg_id,
+ msg->header.part.data);
+ }
+ if (sst_validate_strid(str_id) != 0) {
+ sst_err("stream id %d invalid\n", str_id);
+ break;
+ }
+
+ str_info = &sst_ops->streams[str_id];
+ str_info->ctrl_blk.ret_code = msg->header.part.data;
+ if (str_info->ctrl_blk.on == true) {
+ str_info->ctrl_blk.condition = true;
+ wake_up(&sst_ops->wait_queue);
+ }
+ break;
+
+ case IPC_IA_FREE_STREAM:
+ if (0 == msg->header.part.data) {
+ sst_dbg("Stream %d freed\n", str_id);
+ } else {
+ sst_err("Free for %d returned error %x\n",
+ str_id, msg->header.part.data);
+ }
+ break;
+ case IPC_IA_GET_STREAM_PARAMS: {
+ if (sst_validate_strid(str_id) != 0) {
+ sst_err("stream id %d invalid\n", str_id);
+ break;
+ }
+ if (0 == msg->header.part.data) {
+ struct snd_sst_stream_params *params = NULL;
+ params = kzalloc(sizeof(*params), GFP_KERNEL);
+ if (NULL == params) {
+ sst_err("mem allocation failed\n");
+ break;
+ }
+ memcpy(params, &msg->mailbox, sizeof(*params));
+ str_info = &sst_ops->streams[str_id];
+ str_info->get_parameters = params;
+ } else {
+ sst_err("Msg %x reply error %x \n",
+ msg->header.part.msg_id, msg->header.part.data);
+ }
+ break;
+ }
+
+ case IPC_IA_ALLOC_STREAM: {
+ /*map to stream, call play*/
+ struct snd_sst_alloc_response *resp =
+ (struct snd_sst_alloc_response *)msg->mailbox;
+ if (0 != resp->str_type.result) {
+ /*error case*/
+ struct snd_sst_alloc_response *lib = NULL;
+ sst_err("error alloc stream = %x \n",
+ resp->str_type.result);
+ if (resp->str_type.result ==
+ SST_LIB_ERR_LIB_DNLD_REQUIRED) {
+ lib = kzalloc(sizeof(*lib), GFP_ATOMIC);
+ if (NULL == lib) {
+ sst_err("mem allocation failed \n");
+ break;
+ }
+ memcpy(lib, msg->mailbox, sizeof(*lib));
+ /*library needs to be downloaded*/
+ sst_dbg("Codec Download required \n");
+ }
+ sst_wake_up_alloc_block(sst_ops, resp->str_type.pvt_id,
+ (-resp->str_type.result), lib);
+ break;
+ }
+ sst_alloc_stream_response(str_id, &resp->str_type);
+ break;
+ }
+
+ case IPC_IA_DBG_LOOP_BACK:
+ /*Debug loop back msg*/
+ sst_dbg("Loop back came \n");
+ if (0 != msg->header.part.data)
+ sst_dbg("Possible error if not large \n");
+ sst_dbg("Loop ID: %d\n", str_id);
+ if (msg->header.part.large) {
+ struct ipc_sst_ia_dbg_loop_back *loop_msg =
+ (struct ipc_sst_ia_dbg_loop_back *)msg->mailbox;
+ int i;
+ sst_dbg("Got large loop back: Words %d\n",
+ loop_msg->num_dwords);
+ for (i = 0; i < loop_msg->num_dwords; i++) {
+ sst_dbg("Loop Word %d = %d \n", i,
+ loop_msg->lpbk_dwords[i]);
+ }
+ }
+ sst_send_loop_test((str_id + 1));
+ break;
+
+ case IPC_IA_PLAY_FRAMES:
+ case IPC_IA_CAPT_FRAMES:
+ if (sst_validate_strid(str_id) != 0) {
+ sst_err("stream id %d invalid\n", str_id);
+ break;
+ }
+ sst_dbg("Ack for play/capt frames recived \n");
+ break;
+
+ case IPC_IA_PREP_LIB_DNLD: {
+ struct snd_sst_str_type *str_type =
+ (struct snd_sst_str_type *)msg->mailbox;
+ sst_dbg("Prep Lib download %x\n", msg->header.part.msg_id);
+ if (0 != str_type->result)
+ sst_err("Error in prep lib download 0x%x\n",
+ str_type->result);
+ else
+ sst_dbg("Need to download codec now...\n");
+ str_type->result = 0;
+ sst_wake_up_alloc_block(sst_ops, str_type->pvt_id,
+ str_type->result, NULL);
+ break;
+ }
+
+ case IPC_IA_LIB_DNLD_CMPLT: {
+ struct snd_sst_lib_download_info *resp =
+ (struct snd_sst_lib_download_info *)msg->mailbox;
+ int retval = resp->result;
+
+ sst_dbg("Lib download cmplt %x\n", msg->header.part.msg_id);
+ if (0 != retval)
+ sst_err("Error in lib dload %x\n", resp->result);
+ else {
+ sst_dbg("Codec download complete...\n");
+ sst_info("Dloaded codec Type %d Ver %d Built %s: %s\n",
+ resp->dload_lib.lib_info.lib_type,
+ resp->dload_lib.lib_info.lib_version,
+ resp->dload_lib.lib_info.b_date,
+ resp->dload_lib.lib_info.b_time);
+ }
+ sst_wake_up_alloc_block(sst_ops, resp->pvt_id, retval, NULL);
+ break;
+ }
+
+ case IPC_IA_GET_FW_VERSION: {
+ struct snd_sst_fw_version *version =
+ (struct snd_sst_fw_version *)msg->mailbox;
+ sst_info("***LOADED SST FW VERSION*** = %2d.%02d\n",
+ version->major, version->minor);
+ sst_info("Build No %x Type %x \n",
+ version->build, version->type);
+ break;
+ }
+ case IPC_IA_GET_FW_BUILD_INF: {
+ struct sst_fw_build_info *build =
+ (struct sst_fw_build_info *)msg->mailbox;
+ sst_info("Build date %s Time %s\n",
+ build->date, build->time);
+ break;
+ }
+
+ default:
+ /*Illegal case*/
+ sst_err("process reply :default case = %x\n",
+ msg->header.full);
+
+ }
+ sst_clear_interrupt();
+ return;
+}
--
1.5.4.5
More information about the Alsa-devel
mailing list