Initial file dump from open source releaseHEADmaster

1 files changed, 1435 insertions, 0 deletions

diff --git a/sound/drivers/saudio.c b/sound/drivers/saudio.c
new file mode 100644
index 00000000..0a1d0350
--- /dev/null
+++ b/sound/drivers/saudio.c
@@ -0,0 +1,1435 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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.
+ */
+#define pr_fmt(fmt) "[saudio] " fmt
+
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/jiffies.h>
+#include <linux/slab.h>
+#include <linux/time.h>
+#include <linux/wait.h>
+#include <linux/moduleparam.h>
+#include <sound/core.h>
+#include <sound/control.h>
+#include <sound/tlv.h>
+#include <sound/pcm.h>
+#include <sound/initval.h>
+
+#ifdef CONFIG_OF
+#include <linux/of.h>
+#include <linux/of_device.h>
+#endif
+
+#include <linux/sipc.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/mutex.h>
+#include <linux/memory.h>
+#include <linux/io.h>
+#include <linux/workqueue.h>
+#include <linux/kthread.h>
+#include <sound/saudio.h>
+
+#define ETRACE(x...)           printk(KERN_ERR "Error: " x)
+#define WTRACE(x...)		pr_debug(KERN_ERR x)
+
+#define ADEBUG()			pr_debug(KERN_ERR "saudio.c: function: %s,line %d\n",__FUNCTION__,__LINE__)
+
+#define CMD_BLOCK_SIZE			80
+#define TX_DATA_BLOCK_SIZE		80
+#define RX_DATA_BLOCK_SIZE		0
+#define MAX_BUFFER_SIZE			(10*1024)
+
+#define MAX_PERIOD_SIZE			MAX_BUFFER_SIZE
+
+#define USE_FORMATS			(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE)
+
+#define USE_RATE			SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000
+#define USE_RATE_MIN			5500
+#define USE_RATE_MAX			48000
+
+#define USE_CHANNELS_MIN		1
+
+#define USE_CHANNELS_MAX		2
+
+#define USE_PERIODS_MIN			1
+
+#define USE_PERIODS_MAX			1024
+
+#define CMD_TIMEOUT			msecs_to_jiffies(5000)
+#define CMD_MODEM_RESET_TIMEOUT		msecs_to_jiffies(10000)
+
+#define SAUDIO_CMD_NONE			0x00000000
+#define SAUDIO_CMD_OPEN			0x00000001
+#define SAUDIO_CMD_CLOSE		0x00000002
+#define SAUDIO_CMD_START		0x00000004
+#define SAUDIO_CMD_STOP			0x00000008
+#define SAUDIO_CMD_PREPARE		0x00000010
+#define SAUDIO_CMD_TRIGGER              0x00000020
+#define SAUDIO_CMD_HANDSHAKE            0x00000040
+#define SAUDIO_CMD_RESET		0x00000080
+
+#define SAUDIO_CMD_OPEN_RET		0x00010000
+#define SAUDIO_CMD_CLOSE_RET		0x00020000
+#define SAUDIO_CMD_START_RET		0x00040000
+#define SAUDIO_CMD_STOP_RET             0x00080000
+#define SAUDIO_CMD_PREPARE_RET		0x00100000
+#define SAUDIO_CMD_TRIGGER_RET		0x00200000
+#define SAUDIO_CMD_HANDSHAKE_RET	0x00400000
+#define SAUDIO_CMD_RESET_RET		0x00800000
+
+#define SAUDIO_DATA_PCM			0x00000040
+#define SAUDIO_DATA_SILENCE		0x00000080
+
+#define PLAYBACK_DATA_ABORT		0x00000001
+#define PLAYBACK_DATA_BREAK		0x00000002
+
+#define  SAUDIO_DEV_CTRL_ABORT		0x00000001
+#define SAUDIO_DEV_CTRL_BREAK		0x00000002
+
+#define SAUDIO_SUBCMD_CAPTURE		0x0
+#define SAUDIO_SUBCMD_PLAYBACK		0x1
+
+#define SAUDIO_DEV_MAX			1
+#define SAUDIO_STREAM_MAX		2
+#define SAUDIO_CARD_NAME_LEN_MAX	16
+
+#define  SAUDIO_STREAM_BLOCK_COUNT	4
+#define  SAUDIO_CMD_BLOCK_COUNT		4
+
+#define  SAUDIO_MONITOR_BLOCK_COUNT	2
+#define  SAUDIO_MONITOR_BLOCK_COUNT	2
+
+struct cmd_common {
+	unsigned int command;
+	unsigned int sub_cmd;
+	unsigned int reserved1;
+	unsigned int reserved2;
+};
+
+struct cmd_prepare {
+	struct cmd_common common;
+	unsigned int rate;	/* rate in Hz */
+	unsigned char channels;	/* channels */
+	unsigned char format;
+	unsigned char reserved1;
+	unsigned char reserved2;
+	unsigned int period;	/* period size */
+	unsigned int periods;	/* periods */
+};
+
+struct cmd_open {
+	struct cmd_common common;
+	uint32_t stream_type;
+};
+
+struct saudio_msg {
+	uint32_t command;
+	uint32_t stream_id;
+	uint32_t reserved1;
+	uint32_t reserved2;
+	void *param;
+};
+
+enum snd_status {
+	SAUDIO_IDLE,
+	SAUDIO_OPENNED,
+	SAUDIO_CLOSED,
+	SAUDIO_STOPPED,
+	SAUDIO_PREPARED,
+	SAUDIO_TRIGGERED,
+	SAUDIO_PARAMIZED,
+	SAUDIO_ABORT,
+};
+
+struct saudio_dev_ctrl;
+struct snd_saudio;
+
+struct saudio_stream {
+
+	struct snd_saudio *saudio;
+	struct snd_pcm_substream *substream;
+	struct saudio_dev_ctrl *dev_ctrl;
+	int stream_id;		/* numeric identification */
+
+	uint32_t stream_state;
+
+	uint32_t dst;
+	uint32_t channel;
+
+	int32_t period;
+	int32_t periods_avail;
+	int32_t periods_tosend;
+
+	uint32_t hwptr_done;
+
+	uint32_t last_elapsed_count;
+	uint32_t last_getblk_count;
+	uint32_t blk_count;
+
+	struct mutex mutex;
+};
+
+struct saudio_dev_ctrl {
+	uint32_t dev_state;
+	struct mutex mutex;
+	uint32_t dst;
+	uint32_t monitor_channel;
+	uint32_t channel;
+	uint8_t name[SAUDIO_CARD_NAME_LEN_MAX];
+	struct saudio_stream stream[SAUDIO_STREAM_MAX];
+};
+
+struct snd_saudio {
+	struct snd_card *card;
+	struct snd_pcm *pcm[SAUDIO_DEV_MAX];
+	struct saudio_dev_ctrl dev_ctrl[SAUDIO_DEV_MAX];
+	wait_queue_head_t wait;
+	struct platform_device *pdev;
+	struct workqueue_struct *queue;
+	struct work_struct card_free_work;
+	uint32_t dst;
+	uint32_t channel;
+	uint32_t in_init;
+	struct task_struct * thread_id;
+	int32_t state;
+	struct mutex mutex;
+};
+
+static DEFINE_MUTEX(snd_sound);
+
+static int saudio_snd_card_free(const struct snd_saudio *saudio);
+
+
+static int saudio_clear_cmd(uint32_t dst, uint32_t channel)
+{
+	int result = 0;
+	int i = 0;
+	struct sblock blk = { 0 };
+	do {
+		result = sblock_receive(dst, channel,  (struct sblock *)&blk, 0);
+		if (!result) {
+			sblock_release(dst, channel, &blk);
+		}
+	} while (!result);
+	return result;
+}
+
+
+static int saudio_send_common_cmd(uint32_t dst, uint32_t channel,
+				  uint32_t cmd, uint32_t subcmd,
+				  int32_t timeout)
+{
+	int result = 0;
+	struct sblock blk = { 0 };
+	ADEBUG();
+	pr_debug(" dst is %d, channel %d, cmd %x, subcmd %x\n", dst, channel,
+		 cmd, subcmd);
+	saudio_clear_cmd( dst,  channel);
+	result = sblock_get(dst, channel, (struct sblock *)&blk, timeout);
+	if (result >= 0) {
+		struct cmd_common *common = (struct cmd_common *)blk.addr;
+		common->command = cmd;
+		common->sub_cmd = subcmd;
+		blk.length = sizeof(struct cmd_common);
+		pr_debug(" dst is %d, channel %d, cmd %x, subcmd %x send ok\n",
+			 dst, channel, cmd, subcmd);
+		result = sblock_send(dst, channel, (struct sblock *)&blk);
+	}
+	return result;
+}
+
+static int saudio_wait_common_cmd(uint32_t dst, uint32_t channel,
+				  uint32_t cmd, uint32_t subcmd,
+				  int32_t timeout)
+{
+	int result = 0;
+	struct sblock blk = { 0 };
+	struct cmd_common *common = NULL;
+	ADEBUG();
+	result = sblock_receive(dst, channel, (struct sblock *)&blk, timeout);
+	if (result < 0) {
+		ETRACE("sblock_receive dst %d, channel %d result is %d \n", dst,
+		       channel, result);
+		return result;
+	}
+
+	common = (struct cmd_common *)blk.addr;
+	pr_debug("dst is %d, channel %d, common->command is %x ,sub cmd %x,\n",
+		 dst, channel, common->command, common->sub_cmd);
+	if (subcmd) {
+		if ((common->command == cmd) && (common->sub_cmd == subcmd)) {
+			result = 0;
+		} else {
+			result = -1;
+		}
+	} else {
+		if (common->command == cmd) {
+			result = 0;
+		} else {
+			result = -1;
+		}
+	}
+	sblock_release(dst, channel, &blk);
+	return result;
+}
+
+static int saudio_clear_ctrl_cmd(struct snd_saudio *saudio)
+{
+	int result = 0;
+	int i = 0;
+	struct sblock blk = { 0 };
+	struct saudio_dev_ctrl *dev_ctrl = NULL;
+
+	for (i = 0; i < SAUDIO_DEV_MAX; i++) {	/* now only support  one device */
+		dev_ctrl = &saudio->dev_ctrl[i];
+		do {
+			result =
+			    sblock_receive(dev_ctrl->dst, dev_ctrl->channel,
+					   (struct sblock *)&blk, 0);
+			if (!result) {
+				sblock_release(dev_ctrl->dst, dev_ctrl->channel,
+					       &blk);
+			}
+		} while (!result);
+	}
+
+	return result;
+}
+
+
+static int saudio_pcm_lib_malloc_pages(struct snd_pcm_substream *substream,
+				       size_t size)
+{
+	struct snd_pcm_runtime *runtime = substream->runtime;
+	struct snd_dma_buffer *dmab = &substream->dma_buffer;
+
+	/* Use the pre-allocated buffer */
+	snd_pcm_set_runtime_buffer(substream, dmab);
+	runtime->dma_bytes = size;
+	return 1;
+}
+
+static int saudio_pcm_lib_free_pages(struct snd_pcm_substream *substream)
+{
+	snd_pcm_set_runtime_buffer(substream, NULL);
+	return 0;
+}
+
+static int saudio_snd_mmap(struct snd_pcm_substream *substream,
+			   struct vm_area_struct *vma)
+{
+	ADEBUG();
+	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+	return remap_pfn_range(vma, vma->vm_start,
+			       substream->dma_buffer.addr >> PAGE_SHIFT,
+			       vma->vm_end - vma->vm_start, vma->vm_page_prot);
+}
+
+static struct snd_pcm_hardware snd_card_saudio_playback = {
+	.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
+		 SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
+	.formats = USE_FORMATS,
+	.rates = USE_RATE,
+	.rate_min = USE_RATE_MIN,
+	.rate_max = USE_RATE_MAX,
+	.channels_min = USE_CHANNELS_MIN,
+	.channels_max = USE_CHANNELS_MAX,
+	.buffer_bytes_max = MAX_BUFFER_SIZE,
+	.period_bytes_min = 64,
+	.period_bytes_max = MAX_PERIOD_SIZE,
+	.periods_min = USE_PERIODS_MIN,
+	.periods_max = USE_PERIODS_MAX,
+	.fifo_size = 0,
+};
+
+static struct snd_pcm_hardware snd_card_saudio_capture = {
+	.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
+		 SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
+	.formats = USE_FORMATS,
+	.rates = USE_RATE,
+	.rate_min = USE_RATE_MIN,
+	.rate_max = USE_RATE_MAX,
+	.channels_min = USE_CHANNELS_MIN,
+	.channels_max = USE_CHANNELS_MAX,
+	.buffer_bytes_max = MAX_BUFFER_SIZE,
+	.period_bytes_min = 64,
+	.period_bytes_max = MAX_PERIOD_SIZE,
+	.periods_min = USE_PERIODS_MIN,
+	.periods_max = USE_PERIODS_MAX,
+	.fifo_size = 0,
+};
+
+static int snd_card_saudio_pcm_open(struct snd_pcm_substream *substream)
+{
+	const struct snd_saudio *saudio = snd_pcm_substream_chip(substream);
+	const int stream_id = substream->pstr->stream;
+	const int dev = substream->pcm->device;
+	struct snd_pcm_runtime *runtime = substream->runtime;
+	struct saudio_stream *stream = NULL;
+	int result = 0;
+	struct saudio_dev_ctrl *dev_ctrl = NULL;
+	ADEBUG();
+
+	mutex_lock(&saudio->mutex);
+	if(!saudio->state) {
+		mutex_unlock(&saudio->mutex);
+		printk("saudio.c: snd_pcm_open error saudio state %d\n",saudio->state);
+		return -EIO;
+	}
+	mutex_unlock(&saudio->mutex);
+
+	pr_info("%s IN, stream_id=%d\n", __func__, stream_id);
+	dev_ctrl = (struct saudio_dev_ctrl *)&(saudio->dev_ctrl[dev]);
+	stream = (struct saudio_stream *)&(dev_ctrl->stream[stream_id]);
+	stream->substream = substream;
+	stream->stream_id = stream_id;
+
+	stream->period = 0;
+	stream->periods_tosend = 0;
+	stream->periods_avail = 0;
+	stream->hwptr_done = 0;
+	stream->last_getblk_count = 0;
+	stream->last_elapsed_count = 0;
+	stream->blk_count = SAUDIO_STREAM_BLOCK_COUNT;
+
+	if (stream_id == SNDRV_PCM_STREAM_PLAYBACK) {
+		runtime->hw = snd_card_saudio_playback;
+	} else {
+		runtime->hw = snd_card_saudio_capture;
+	}
+	mutex_lock(&dev_ctrl->mutex);
+	result = saudio_send_common_cmd(dev_ctrl->dst, dev_ctrl->channel,
+					SAUDIO_CMD_OPEN, stream_id,
+					CMD_TIMEOUT);
+	if (result) {
+		ETRACE
+		    ("saudio.c: snd_card_saudio_pcm_open: saudio_send_common_cmd result is %d",
+		     result);
+		if(result != (-ERESTARTSYS))
+			saudio_snd_card_free(saudio);
+		mutex_unlock(&dev_ctrl->mutex);
+		return result;
+	}
+	pr_info("%s send cmd done\n", __func__);
+	result = saudio_wait_common_cmd(dev_ctrl->dst,
+					dev_ctrl->channel,
+					SAUDIO_CMD_OPEN_RET, 0, CMD_TIMEOUT);
+	if (result && (result != (-ERESTARTSYS)))
+		saudio_snd_card_free(saudio);
+	mutex_unlock(&dev_ctrl->mutex);
+	pr_info("%s OUT, result=%d\n", __func__, result);
+
+	return result;
+}
+
+static int snd_card_saudio_pcm_close(struct snd_pcm_substream *substream)
+{
+	const struct snd_saudio *saudio = snd_pcm_substream_chip(substream);
+	const int stream_id = substream->pstr->stream;
+	const int dev = substream->pcm->device;
+	struct saudio_dev_ctrl *dev_ctrl = NULL;
+	int result = 0;
+	ADEBUG();
+	mutex_lock(&saudio->mutex);
+	if(!saudio->state) {
+		mutex_unlock(&saudio->mutex);
+		printk("saudio.c: snd_pcm_close error saudio state %d\n",saudio->state);
+		return -EIO;
+	}
+	mutex_unlock(&saudio->mutex);
+	dev_ctrl = (struct saudio_dev_ctrl *)&(saudio->dev_ctrl[dev]);
+	pr_info("%s IN, stream_id=%d,dst %d, channel %d\n", __func__, stream_id,
+		dev_ctrl->dst, dev_ctrl->channel);
+	mutex_lock(&dev_ctrl->mutex);
+	result = saudio_send_common_cmd(dev_ctrl->dst, dev_ctrl->channel,
+					SAUDIO_CMD_CLOSE, stream_id,
+					CMD_TIMEOUT);
+	if (result) {
+		ETRACE
+		    ("saudio.c: snd_card_saudio_pcm_close: saudio_send_common_cmd result is %d",
+		     result);
+		if(result != (-ERESTARTSYS))
+			saudio_snd_card_free(saudio);
+		mutex_unlock(&dev_ctrl->mutex);
+		return result;
+	}
+	pr_info("%s send cmd done\n", __func__);
+	result =
+	    saudio_wait_common_cmd(dev_ctrl->dst,
+				   dev_ctrl->channel,
+				   SAUDIO_CMD_CLOSE_RET, 0, CMD_TIMEOUT);
+	if (result && (result != (-ERESTARTSYS)))
+		saudio_snd_card_free(saudio);
+	mutex_unlock(&dev_ctrl->mutex);
+	pr_info("%s OUT, result=%d,dst %d, channel %d\n", __func__, result,
+		dev_ctrl->dst, dev_ctrl->channel);
+
+	return result;
+
+}
+
+static int saudio_data_trigger_process(struct saudio_stream *stream,
+				       struct saudio_msg *msg);
+
+static int snd_card_saudio_pcm_trigger(struct snd_pcm_substream *substream,
+				       int cmd)
+{
+	const struct snd_saudio *saudio = snd_pcm_substream_chip(substream);
+	const int stream_id = substream->pstr->stream;
+	const int dev = substream->pcm->device;
+	struct saudio_dev_ctrl *dev_ctrl = NULL;
+	struct saudio_stream *stream = NULL;
+	struct saudio_msg msg = { 0 };
+	int err = 0;
+	int result = 0;
+	ADEBUG();
+	dev_ctrl = (struct saudio_dev_ctrl *)&(saudio->dev_ctrl[dev]);
+	stream = (struct saudio_stream *)&(dev_ctrl->stream[stream_id]);
+
+	switch (cmd) {
+	case SNDRV_PCM_TRIGGER_START:
+	case SNDRV_PCM_TRIGGER_RESUME:
+		pr_info("%s IN, TRIGGER_START, stream_id=%d\n", __func__,
+			stream_id);
+		msg.stream_id = stream_id;
+		stream->stream_state = SAUDIO_TRIGGERED;
+		result = saudio_data_trigger_process(stream, &msg);
+		result =
+		    saudio_send_common_cmd(dev_ctrl->dst, dev_ctrl->channel,
+					   SAUDIO_CMD_START, stream->stream_id,
+					   0);
+		if (result) {
+			ETRACE
+			    ("saudio.c: snd_card_saudio_pcm_trigger: RESUME, send_common_cmd result is %d",
+			     result);
+			if(result != (-ERESTARTSYS))
+				saudio_snd_card_free(saudio);
+			return result;
+		}
+		pr_info("%s OUT, TRIGGER_START, result=%d\n", __func__, result);
+
+		break;
+	case SNDRV_PCM_TRIGGER_STOP:
+	case SNDRV_PCM_TRIGGER_SUSPEND:
+		pr_info("%s IN, TRIGGER_STOP, stream_id=%d\n", __func__,
+			stream_id);
+		stream->stream_state = SAUDIO_STOPPED;
+		result =
+		    saudio_send_common_cmd(dev_ctrl->dst, dev_ctrl->channel,
+					   SAUDIO_CMD_STOP, stream->stream_id,
+					   0);
+		if (result) {
+			ETRACE
+			    ("saudio.c: snd_card_saudio_pcm_trigger: SUSPEND, send_common_cmd result is %d",
+			     result);
+			if(result != (-ERESTARTSYS))
+				saudio_snd_card_free(saudio);
+			return result;
+		}
+		pr_info("%s OUT, TRIGGER_STOP, result=%d\n", __func__, result);
+
+		break;
+	default:
+		err = -EINVAL;
+		break;
+	}
+
+	return 0;
+}
+
+static int saudio_cmd_prepare_process(struct saudio_dev_ctrl *dev_ctrl,
+				      struct saudio_msg *msg);
+static int snd_card_saudio_pcm_prepare(struct snd_pcm_substream *substream)
+{
+	const struct snd_saudio *saudio = snd_pcm_substream_chip(substream);
+	const int stream_id = substream->pstr->stream;
+	const int dev = substream->pcm->device;
+	struct saudio_dev_ctrl *dev_ctrl = NULL;
+	struct saudio_msg msg = { 0 };
+	int result = 0;
+
+	ADEBUG();
+	mutex_lock(&saudio->mutex);
+	if(!saudio->state) {
+		mutex_unlock(&saudio->mutex);
+		printk("saudio.c: snd_pcm_prepare error saudio state %d\n",saudio->state);
+		return -EIO;
+	}
+	mutex_unlock(&saudio->mutex);
+	pr_info("%s IN, stream_id=%d\n", __func__, stream_id);
+	dev_ctrl = (struct saudio_dev_ctrl *)&(saudio->dev_ctrl[dev]);
+	msg.command = SAUDIO_CMD_PREPARE;
+	msg.stream_id = stream_id;
+
+	result = saudio_cmd_prepare_process(dev_ctrl, &msg);
+	pr_info("%s OUT, result=%d\n", __func__, result);
+
+	return 0;
+}
+
+static int snd_card_saudio_hw_params(struct snd_pcm_substream *substream,
+				     struct snd_pcm_hw_params *hw_params)
+{
+	int32_t result = 0;
+	ADEBUG();
+	result =
+	    saudio_pcm_lib_malloc_pages(substream,
+					params_buffer_bytes(hw_params));
+	pr_debug("saudio.c: saudio.c: hw_params result is %d", result);
+	return result;
+}
+
+static int snd_card_saudio_hw_free(struct snd_pcm_substream *substream)
+{
+	int ret = 0;
+	const struct snd_saudio *saudio = snd_pcm_substream_chip(substream);
+	const int stream_id = substream->pstr->stream;
+	const int dev = substream->pcm->device;
+	struct saudio_stream *stream =
+	    (struct saudio_stream *)&(saudio->dev_ctrl[dev].stream[stream_id]);
+	ADEBUG();
+	mutex_lock(&stream->mutex);
+	ret = saudio_pcm_lib_free_pages(substream);
+	mutex_unlock(&stream->mutex);
+	return ret;
+}
+
+static snd_pcm_uframes_t snd_card_saudio_pcm_pointer(struct snd_pcm_substream
+						     *substream)
+{
+	const struct snd_saudio *saudio = snd_pcm_substream_chip(substream);
+	const int stream_id = substream->pstr->stream;
+	const int dev = substream->pcm->device;
+	struct snd_pcm_runtime *runtime = substream->runtime;
+	struct saudio_stream *stream =
+	    (struct saudio_stream *)&(saudio->dev_ctrl[dev].stream[stream_id]);
+	unsigned int offset;
+	offset =
+	    stream->hwptr_done * frames_to_bytes(runtime, runtime->period_size);
+	return bytes_to_frames(runtime, offset);
+}
+
+static struct snd_pcm_ops snd_card_saudio_playback_ops = {
+	.open = snd_card_saudio_pcm_open,
+	.close = snd_card_saudio_pcm_close,
+	.ioctl = snd_pcm_lib_ioctl,
+	.hw_params = snd_card_saudio_hw_params,
+	.hw_free = snd_card_saudio_hw_free,
+	.prepare = snd_card_saudio_pcm_prepare,
+	.trigger = snd_card_saudio_pcm_trigger,
+	.pointer = snd_card_saudio_pcm_pointer,
+	.mmap = saudio_snd_mmap,
+};
+
+static struct snd_pcm_ops snd_card_saudio_capture_ops = {
+	.open = snd_card_saudio_pcm_open,
+	.close = snd_card_saudio_pcm_close,
+	.ioctl = snd_pcm_lib_ioctl,
+	.hw_params = snd_card_saudio_hw_params,
+	.hw_free = snd_card_saudio_hw_free,
+	.prepare = snd_card_saudio_pcm_prepare,
+	.trigger = snd_card_saudio_pcm_trigger,
+	.pointer = snd_card_saudio_pcm_pointer,
+	.mmap = saudio_snd_mmap,
+};
+
+void saudio_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm)
+{
+	struct snd_pcm_substream *substream;
+	int stream;
+	pr_debug("saudio.c:saudio_pcm_lib_preallocate_free_for_all");
+	for (stream = 0; stream < 2; stream++)
+		for (substream = pcm->streams[stream].substream; substream;
+		     substream = substream->next) {
+			if(substream->dma_buffer.addr) {
+			    iounmap(substream->dma_buffer.area);
+			    smem_free(substream->dma_buffer.addr,
+				      substream->dma_buffer.bytes);
+			    substream->dma_buffer.addr = (dma_addr_t) NULL;
+			    substream->dma_buffer.area = (int8_t *) NULL;
+			    substream->dma_buffer.bytes = 0;
+			}
+		}
+}
+
+int saudio_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
+					     int type, void *data,
+					     size_t size, size_t max)
+{
+
+	struct snd_pcm_substream *substream;
+	int stream;
+	pr_debug("saudio.c:saudio_pcm_lib_preallocate_pages_for_all in");
+	(void)size;
+	for (stream = 0; stream < SAUDIO_STREAM_MAX; stream++) {
+		for (substream = pcm->streams[stream].substream; substream;
+		     substream = substream->next) {
+			struct snd_dma_buffer *dmab = &substream->dma_buffer;
+
+			uint32_t addr = smem_alloc(size);
+
+			if(addr) {
+			    dmab->dev.type = type;
+			    dmab->dev.dev = data;
+			    dmab->area = ioremap_nocache(addr, size);
+			    dmab->addr = addr;
+			    dmab->bytes = size;
+			    memset(dmab->area, 0x5a, size);
+			    pr_debug
+				("saudio_pcm_lib_preallocate_pages_for_all:saudio.c: dmab addr is %x, area is %lx,size is %d",
+				 (uint32_t) dmab->addr, (unsigned long)dmab->area,
+				 size);
+			    if (substream->dma_buffer.bytes > 0)
+				    substream->buffer_bytes_max =
+					substream->dma_buffer.bytes;
+			    substream->dma_max = max;
+			}
+			else {
+			    printk("saudio: prealloc smem error \n");
+			    memset(dmab,0,sizeof(struct snd_dma_buffer));
+			    substream->dma_max = 0;
+			    substream->buffer_bytes_max = 0;
+			    goto ERR;
+
+			}
+		}
+	}
+	return 0;
+ERR:
+	saudio_pcm_lib_preallocate_free_for_all(pcm);
+	return -1;
+}
+
+static int  snd_card_saudio_pcm(struct snd_saudio *saudio, int device,
+					 int substreams)
+{
+	struct snd_pcm *pcm;
+	int err;
+	ADEBUG();
+	err = snd_pcm_new(saudio->card, "SAUDIO PCM", device,
+			  substreams, substreams, &pcm);
+	if (err < 0)
+		return err;
+	pcm->private_data = saudio;
+	saudio->pcm[device] = pcm;
+	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+			&snd_card_saudio_playback_ops);
+	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
+			&snd_card_saudio_capture_ops);
+	pcm->private_data = saudio;
+	pcm->info_flags = 0;
+	strcpy(pcm->name, "SAUDIO PCM");
+	pcm->private_free = saudio_pcm_lib_preallocate_free_for_all;
+	err = saudio_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
+						 snd_dma_continuous_data
+						 (GFP_KERNEL), MAX_BUFFER_SIZE,
+						 MAX_BUFFER_SIZE);
+	if(err) {
+	    printk("saudio:snd_card_saudio_pcm: prealloc pages error\n");
+	    saudio->pcm[device] = NULL;
+	}
+	return err;
+}
+
+static struct snd_saudio *saudio_card_probe(struct saudio_init_data *init_data)
+{
+	struct snd_saudio *saudio = NULL;
+
+	saudio = kzalloc(sizeof(struct snd_saudio), GFP_KERNEL);
+	if (!saudio)
+		return NULL;
+
+	saudio->dev_ctrl[0].channel = init_data->ctrl_channel;
+	saudio->dev_ctrl[0].monitor_channel = init_data->monitor_channel;
+	saudio->dev_ctrl[0].dst = init_data->dst;
+	saudio->dst = init_data->dst;
+	saudio->channel = init_data->ctrl_channel;
+	mutex_init(&saudio->mutex);
+	memcpy(saudio->dev_ctrl[0].name, init_data->name,
+	       SAUDIO_CARD_NAME_LEN_MAX);
+	saudio->dev_ctrl[0].stream[SNDRV_PCM_STREAM_PLAYBACK].channel =
+	    init_data->playback_channel;
+	saudio->dev_ctrl[0].stream[SNDRV_PCM_STREAM_PLAYBACK].dst =
+	    init_data->dst;
+	saudio->dev_ctrl[0].stream[SNDRV_PCM_STREAM_CAPTURE].channel =
+	    init_data->capture_channel;
+	saudio->dev_ctrl[0].stream[SNDRV_PCM_STREAM_CAPTURE].dst =
+	    init_data->dst;
+
+	return saudio;
+}
+
+static int saudio_data_trigger_process(struct saudio_stream *stream,
+				       struct saudio_msg *msg)
+{
+	int32_t result = 0;
+	struct sblock blk = { 0 };
+	struct cmd_common *common = NULL;
+	struct snd_pcm_runtime *runtime = stream->substream->runtime;
+	ADEBUG();
+
+	if (stream->stream_id == SNDRV_PCM_STREAM_PLAYBACK) {
+		stream->periods_avail = snd_pcm_playback_avail(runtime) /
+		    runtime->period_size;
+	} else {
+		stream->periods_avail = snd_pcm_capture_avail(runtime) /
+		    runtime->period_size;
+	}
+
+	pr_debug("saudio.c:stream->periods_avail is %d,block count is %d",
+		 stream->periods_avail, sblock_get_free_count(stream->dst,
+							      stream->channel));
+
+	stream->periods_tosend = runtime->periods - stream->periods_avail;
+
+	ADEBUG();
+
+	while (stream->periods_tosend) {
+
+		result = sblock_get(stream->dst, stream->channel, &blk, 0);
+		if (result) {
+			break;
+		}
+		stream->last_getblk_count++;
+		common = (struct cmd_common *)blk.addr;
+		blk.length = frames_to_bytes(runtime, runtime->period_size);
+		common->command = SAUDIO_DATA_PCM;
+		common->sub_cmd = stream->stream_id;
+		common->reserved1 =
+		    stream->substream->dma_buffer.addr +
+		    stream->period * blk.length;
+
+		sblock_send(stream->dst, stream->channel, &blk);
+
+		stream->period++;
+		stream->period = stream->period % runtime->periods;
+		stream->periods_tosend--;
+	}
+
+	pr_debug(":sblock_getblock_count trigger is %d \n",
+		 stream->last_getblk_count);
+
+	return result;
+}
+
+static int saudio_data_transfer_process(struct saudio_stream *stream,
+					struct saudio_msg *msg)
+{
+	struct snd_pcm_runtime *runtime = stream->substream->runtime;
+	struct sblock blk = { 0 };
+	int32_t result = 0;
+	struct cmd_common *common = NULL;
+
+	int32_t elapsed_blks = 0;
+	int32_t periods_avail;
+	int32_t periods_tosend;
+	int32_t cur_blk_count = 0;
+
+	cur_blk_count = sblock_get_free_count(stream->dst, stream->channel);
+
+	elapsed_blks =
+	    (cur_blk_count + stream->last_getblk_count - stream->blk_count) -
+	    stream->last_elapsed_count;
+
+	if (stream->stream_id == SNDRV_PCM_STREAM_PLAYBACK) {
+		periods_avail = snd_pcm_playback_avail(runtime) /
+		    runtime->period_size;
+	} else {
+		periods_avail = snd_pcm_capture_avail(runtime) /
+		    runtime->period_size;
+	}
+
+	periods_tosend = stream->periods_avail - periods_avail;
+	if (periods_tosend > 0) {
+		stream->periods_tosend += periods_tosend;
+	}
+
+	if (stream->periods_tosend) {
+		while (stream->periods_tosend) {
+			result =
+			    sblock_get(stream->dst, stream->channel, &blk, 0);
+			if (result) {
+				break;
+			}
+			stream->last_getblk_count++;
+			common = (struct cmd_common *)blk.addr;
+			blk.length =
+			    frames_to_bytes(runtime, runtime->period_size);
+			common->command = SAUDIO_DATA_PCM;
+			common->sub_cmd = stream->stream_id;
+			common->reserved1 =
+			    stream->substream->dma_buffer.addr +
+			    stream->period * blk.length;
+
+			sblock_send(stream->dst, stream->channel, &blk);
+
+			stream->periods_tosend--;
+			stream->period++;
+			stream->period = stream->period % runtime->periods;
+		}
+
+	} else {
+		pr_debug("saudio.c: saudio no data to send ");
+		if (sblock_get_free_count(stream->dst, stream->channel) ==
+		    SAUDIO_STREAM_BLOCK_COUNT) {
+			pr_debug
+			    ("saudio.c: saudio no data to send and  is empty ");
+			result =
+			    sblock_get(stream->dst, stream->channel, &blk, 0);
+			if (result) {
+				ETRACE("saudio.c: no data and no blk\n");
+			} else {
+				stream->last_getblk_count++;
+				common = (struct cmd_common *)blk.addr;
+				common->command = SAUDIO_DATA_SILENCE;
+				common->sub_cmd = stream->stream_id;
+
+				sblock_send(stream->dst, stream->channel, &blk);
+				stream->last_elapsed_count++;
+				schedule_timeout_interruptible(msecs_to_jiffies(5));
+			}
+		}
+	}
+
+	while (elapsed_blks > 0) {
+		elapsed_blks--;
+		stream->hwptr_done++;
+		stream->hwptr_done %= runtime->periods;
+		snd_pcm_period_elapsed(stream->substream);
+		stream->periods_avail++;
+		stream->last_elapsed_count++;
+	}
+
+	return 0;
+}
+
+static int saudio_cmd_prepare_process(struct saudio_dev_ctrl *dev_ctrl,
+				      struct saudio_msg *msg)
+{
+	struct sblock blk;
+	struct snd_saudio *saudio = NULL;
+	int32_t result = 0;
+	struct snd_pcm_runtime *runtime =
+	    dev_ctrl->stream[msg->stream_id].substream->runtime;
+	ADEBUG();
+	saudio = dev_ctrl->stream[msg->stream_id].saudio;
+	result =
+	    sblock_get(dev_ctrl->dst, dev_ctrl->channel, (struct sblock *)&blk,
+		       CMD_TIMEOUT);
+	if (!result) {
+		struct cmd_prepare *prepare = (struct cmd_prepare *)blk.addr;
+		prepare->common.command = SAUDIO_CMD_PREPARE;
+		prepare->common.sub_cmd = msg->stream_id;
+		prepare->rate = runtime->rate;
+		prepare->channels = runtime->channels;
+		prepare->format = runtime->format;
+		prepare->period =
+		    frames_to_bytes(runtime, runtime->period_size);
+		prepare->periods = runtime->periods;
+		blk.length = sizeof(struct cmd_prepare);
+
+		mutex_lock(&dev_ctrl->mutex);
+
+		sblock_send(dev_ctrl->dst, dev_ctrl->channel,
+			    (struct sblock *)&blk);
+		result =
+		    saudio_wait_common_cmd(dev_ctrl->dst, dev_ctrl->channel,
+					   SAUDIO_CMD_PREPARE_RET,
+					   0, CMD_TIMEOUT);
+		if (result && (result != (-ERESTARTSYS)))
+			saudio_snd_card_free(saudio);
+
+		mutex_unlock(&dev_ctrl->mutex);
+	}
+	pr_debug("saudio_cmd_prepare_process result is %d", result);
+	return result;
+
+}
+
+static void sblock_notifier(int event, void *data)
+{
+	struct saudio_stream *stream = data;
+	struct saudio_msg msg = { 0 };
+	int result = 0;
+
+	if (event == SBLOCK_NOTIFY_GET) {
+		if (stream->stream_state == SAUDIO_TRIGGERED) {
+			mutex_lock(&stream->mutex);
+			result = saudio_data_transfer_process(stream, &msg);
+			mutex_unlock(&stream->mutex);
+		} else {
+			pr_debug("\n: saudio is stopped\n");
+		}
+	}
+}
+
+static int saudio_snd_card_free(const struct snd_saudio *saudio)
+{
+	int result = 0;
+	printk(KERN_INFO "saudio:saudio_snd_card free in dst %d,channel %d\n",
+	       saudio->dst, saudio->channel);
+	queue_work(saudio->queue, (struct work_struct *)&saudio->card_free_work);
+	printk(KERN_INFO
+	       "saudio:saudio_snd_card free out %d ,dst %d, channel %d\n",
+	       result, saudio->dst, saudio->channel);
+	return 0;
+}
+
+static void saudio_snd_wait_modem_restart(struct snd_saudio *saudio)
+{
+	struct saudio_dev_ctrl *dev_ctrl = NULL;
+	int result = 0;
+	dev_ctrl = &saudio->dev_ctrl[0];
+	while (1) {
+		result =
+		    saudio_wait_common_cmd(dev_ctrl->dst,
+					   dev_ctrl->monitor_channel,
+					   SAUDIO_CMD_HANDSHAKE, 0, -1);
+		if (result) {
+			schedule_timeout_interruptible(msecs_to_jiffies(1000));
+			printk(KERN_ERR "saudio_wait_monitor_cmd error %d\n",
+			       result);
+			continue;
+		} else {
+			while (1) {
+				result =
+				    saudio_send_common_cmd(dev_ctrl->dst,
+							   dev_ctrl->
+							   monitor_channel,
+							   SAUDIO_CMD_HANDSHAKE_RET,
+							   0, -1);
+				if (!result) {
+					break;
+				}
+				printk(KERN_ERR
+				       "saudio_send_monitor_cmd error %d\n",
+				       result);
+				schedule_timeout_interruptible(msecs_to_jiffies
+							       (1000));
+			}
+		}
+		break;
+	}
+}
+
+static int saudio_snd_notify_modem_clear(struct snd_saudio *saudio)
+{
+	struct saudio_dev_ctrl *dev_ctrl = NULL;
+	int result = 0;
+	dev_ctrl = &saudio->dev_ctrl[0];
+	printk(KERN_INFO "saudio.c:saudio_snd_notify_mdem_clear in");
+	result =
+	    saudio_send_common_cmd(dev_ctrl->dst, dev_ctrl->monitor_channel,
+				   SAUDIO_CMD_RESET, 0, -1);
+	if (result) {
+		printk(KERN_ERR "saudio_send_modem_reset_cmd error %d\n",
+		       result);
+	}
+	else {
+	    result =
+		saudio_wait_common_cmd(dev_ctrl->dst, dev_ctrl->monitor_channel,
+				       SAUDIO_CMD_RESET_RET, 0, CMD_MODEM_RESET_TIMEOUT);
+	    if (result) {
+		    printk(KERN_ERR "saudio_wait_monitor_cmd error %d\n", result);
+	    }
+	}
+	printk(KERN_INFO "saudio.c:saudio_snd_notify_mdem_clear out");
+	return result;
+}
+
+static int saudio_snd_init_ipc(struct snd_saudio *saudio)
+{
+	int result = 0;
+	int32_t i = 0, j = 0;
+	struct saudio_stream *stream = NULL;
+	struct saudio_dev_ctrl *dev_ctrl = NULL;
+
+	ADEBUG();
+
+	for (i = 0; i < SAUDIO_DEV_MAX; i++) {	/* now only support  one device */
+		dev_ctrl = &saudio->dev_ctrl[i];
+		result =
+		    sblock_create(dev_ctrl->dst, dev_ctrl->monitor_channel,
+				  SAUDIO_MONITOR_BLOCK_COUNT, CMD_BLOCK_SIZE,
+				  SAUDIO_MONITOR_BLOCK_COUNT, CMD_BLOCK_SIZE);
+		if (result) {
+			ETRACE
+			    ("saudio:monitor channel create  failed result is %d\n",
+			     result);
+			goto __nodev;
+		}
+		result =
+		    sblock_create(dev_ctrl->dst, dev_ctrl->channel,
+				  SAUDIO_CMD_BLOCK_COUNT, CMD_BLOCK_SIZE,
+				  SAUDIO_CMD_BLOCK_COUNT, CMD_BLOCK_SIZE);
+		if (result) {
+			ETRACE
+			    ("saudio_thread sblock create  failed result is %d\n",
+			     result);
+			goto __nodev;
+		}
+		pr_debug("saudio_thread sblock create  result is %d\n", result);
+
+		for (j = 0; j < SAUDIO_STREAM_MAX; j++) {
+			stream = &dev_ctrl->stream[j];
+			result =
+			    sblock_create(stream->dst, stream->channel,
+					  SAUDIO_STREAM_BLOCK_COUNT,
+					  TX_DATA_BLOCK_SIZE,
+					  SAUDIO_STREAM_BLOCK_COUNT,
+					  RX_DATA_BLOCK_SIZE);
+			if (result) {
+				ETRACE
+				    ("saudio_thread sblock create  failed result is %d\n",
+				     result);
+				goto __nodev;
+			}
+			sblock_register_notifier(stream->dst, stream->channel,
+						 sblock_notifier, stream);
+			pr_debug("saudio_thread sblock create  result is %d\n",
+				 result);
+		}
+	}
+	ADEBUG();
+	return result;
+__nodev:
+	ETRACE("initialization failed\n");
+	return result;
+}
+
+static int saudio_snd_init_card(struct snd_saudio *saudio)
+{
+	int result = 0;
+	int32_t i = 0, j = 0, err = 0;
+	struct saudio_stream *stream = NULL;
+	struct saudio_dev_ctrl *dev_ctrl = NULL;
+	struct snd_card *saudio_card = NULL;
+
+	ADEBUG();
+
+	if (!saudio) {
+		return -1;
+	}
+
+	mutex_lock(&snd_sound);
+
+	result =
+	    snd_card_create(SNDRV_DEFAULT_IDX1, saudio->dev_ctrl[0].name,
+			    THIS_MODULE, sizeof(struct snd_saudio *),
+			    &saudio_card);
+	if (!saudio_card) {
+		printk(KERN_ERR "saudio:snd_card_create faild result is %d\n",
+		       result);
+		mutex_unlock(&snd_sound);
+		return -1;
+	}
+	saudio->card = saudio_card;
+	saudio_card->private_data = saudio;
+
+	for (i = 0; i < SAUDIO_DEV_MAX; i++) {	/* now only support  one device */
+		dev_ctrl = &saudio->dev_ctrl[i];
+		mutex_init(&dev_ctrl->mutex);
+		err = snd_card_saudio_pcm(saudio, i, 1);
+		if (err < 0) {
+			mutex_unlock(&snd_sound);
+			goto __nodev;
+		}
+		for (j = 0; j < SAUDIO_STREAM_MAX; j++) {
+			stream = &dev_ctrl->stream[j];
+			stream->dev_ctrl = dev_ctrl;
+
+			stream->stream_state = SAUDIO_IDLE;
+			stream->stream_id = j;
+			stream->saudio = saudio;
+			mutex_init(&stream->mutex);
+		}
+	}
+	ADEBUG();
+
+	memcpy(saudio->card->driver, dev_ctrl->name, SAUDIO_CARD_NAME_LEN_MAX);
+	memcpy(saudio->card->shortname, dev_ctrl->name,
+	       SAUDIO_CARD_NAME_LEN_MAX);
+	memcpy(saudio->card->longname, dev_ctrl->name,
+	       SAUDIO_CARD_NAME_LEN_MAX);
+
+	err = snd_card_register(saudio->card);
+
+	mutex_unlock(&snd_sound);
+
+	if (err == 0) {
+		printk(KERN_INFO "saudio.c:snd_card create ok\n");
+		return 0;
+	}
+__nodev:
+	if (saudio) {
+		if (saudio->card) {
+			mutex_lock(&snd_sound);
+			snd_card_free(saudio->card);
+			saudio->card = NULL;
+			mutex_unlock(&snd_sound);
+		}
+	}
+	printk("saudio.c:initialization failed\n");
+	return err;
+}
+
+static int saudio_ctrl_thread(void *data)
+{
+	int result = 0;
+	struct snd_saudio *saudio = (struct snd_saudio *)data;
+	ADEBUG();
+
+	result = saudio_snd_init_ipc(saudio);
+	if (result) {
+		printk(KERN_ERR "saudio:saudio_snd_init_ipc error %d\n",
+		       result);
+		return -1;
+	}
+	while (!kthread_should_stop()) {
+		printk(KERN_INFO
+		       "%s,saudio: waiting for modem boot handshake,dst %d,channel %d\n",
+		       __func__, saudio->dst, saudio->channel);
+		saudio_snd_wait_modem_restart(saudio);
+
+		saudio->in_init = 1;
+
+		printk(KERN_INFO
+		       "%s,saudio: modem boot and handshake ok,dst %d, channel %d\n",
+		       __func__, saudio->dst, saudio->channel);
+		saudio_snd_card_free(saudio);
+		printk(KERN_INFO
+		       "saudio_ctrl_thread flush work queue in dst %d, channel %d\n",
+		       saudio->dst, saudio->channel);
+
+		flush_workqueue(saudio->queue);
+
+		saudio->in_init = 0;
+
+		printk(KERN_INFO
+		       "saudio_ctrl_thread flush work queue out,dst %d, channel %d\n",
+		       saudio->dst, saudio->channel);
+
+		if(saudio_snd_notify_modem_clear(saudio)) {
+			printk(KERN_ERR " saudio_ctrl_thread modem error again when notify modem clear \n");
+		    continue;
+		}
+
+		saudio_clear_ctrl_cmd(saudio);
+
+		if(!saudio->card) {
+			result = saudio_snd_init_card(saudio);
+			printk(KERN_INFO
+			       "saudio: snd card init reulst %d, dst %d, channel %d\n",
+			       result, saudio->dst, saudio->channel);
+		}
+		mutex_lock(&saudio->mutex);
+		saudio->state = 1;
+		mutex_unlock(&saudio->mutex);
+	}
+	ETRACE("saudio_ctrl_thread  create  ok\n");
+
+	return 0;
+}
+
+static void saudio_work_card_free_handler(struct work_struct *data)
+{
+	struct snd_saudio *saudio =
+	    container_of(data, struct snd_saudio, card_free_work);
+	printk(KERN_INFO "saudio: card free handler in\n");
+
+	if (saudio->card) {
+		int result;
+		printk(KERN_INFO
+		       "saudio: work_handler:snd card free in,dst %d, channel %d\n",
+		       saudio->dst, saudio->channel);
+		mutex_lock(&saudio->mutex);
+		saudio->state = 0;
+		mutex_unlock(&saudio->mutex);
+		if (!saudio->in_init)
+			saudio_send_common_cmd(saudio->dst, saudio->channel, 0,
+					       SAUDIO_CMD_HANDSHAKE, -1);
+		printk(KERN_INFO
+		       "saudio: work_handler:snd card free reulst %d,dst %d, channel %d\n",
+		       result, saudio->dst, saudio->channel);
+	}
+	printk(KERN_INFO "saudio: card free handler out\n");
+}
+
+static int snd_saudio_probe(struct platform_device *devptr)
+{
+	struct snd_saudio *saudio = NULL;
+	static pid_t thread_id = (pid_t) - 1;
+#ifdef CONFIG_OF
+	int ret, id, ctrl_ch, playback_ch, capture_ch, monitor_ch;
+	const char *name = NULL;
+	struct saudio_init_data snd_init_data = {0};
+	const char *saudio_names = "sprd,saudio-names";
+	const char *saudio_dst_id = "sprd,saudio-dst-id";
+	const char *ctrl_channel = "sprd,ctrl_channel";
+	const char *playback_channel = "sprd,playback_channel";
+	const char *capture_channel = "sprd,capture_channel";
+	const char *monitor_channel = "sprd,monitor_channel";
+	struct saudio_init_data *init_data = &snd_init_data;
+#else
+	struct saudio_init_data *init_data = devptr->dev.platform_data;
+#endif
+
+	ADEBUG();
+
+#ifdef CONFIG_OF
+	ret = of_property_read_u32(devptr->dev.of_node, saudio_dst_id, &id);
+	if (ret) {
+		printk("saudio: %s: missing %s in dt node\n", __func__, saudio_dst_id);
+		return ret;
+	} else {
+		printk("saudio: %s: %s is %d\n", __func__, saudio_dst_id, id);
+	}
+	ret = of_property_read_u32(devptr->dev.of_node, ctrl_channel, &ctrl_ch);
+	if (ret) {
+		printk("saudio: %s: missing %s in dt node\n", __func__, ctrl_channel);
+		return ret;
+	} else {
+		printk("saudio: %s: %s is %d\n", __func__, ctrl_channel, ctrl_ch);
+	}
+	ret = of_property_read_u32(devptr->dev.of_node, playback_channel, &playback_ch);
+	if (ret) {
+		printk("saudio: %s: missing %s in dt node\n", __func__, playback_channel);
+		return ret;
+	} else {
+		printk("saudio: %s: %s is %d\n", __func__, playback_channel, playback_ch);
+	}
+	ret = of_property_read_u32(devptr->dev.of_node, capture_channel, &capture_ch);
+	if (ret) {
+		printk("saudio: %s: missing %s in dt node\n", __func__, capture_channel);
+		return ret;
+	} else {
+		printk("saudio: %s: %s is %d\n", __func__, capture_channel, capture_ch);
+	}
+	ret = of_property_read_u32(devptr->dev.of_node, monitor_channel, &monitor_ch);
+	if (ret) {
+		printk("saudio: %s: missing %s in dt node\n", __func__, monitor_channel);
+		return ret;
+	} else {
+		printk("saudio: %s: %s is %d\n", __func__, monitor_channel, monitor_ch);
+	}
+	ret = of_property_read_string(devptr->dev.of_node, saudio_names, &name);
+	if (ret) {
+		printk("saudio: %s: missing %s in dt node\n", __func__, saudio_names);
+		return ret;
+	} else {
+		printk("saudio: %s: %s is %s\n", __func__, saudio_names, name);
+	}
+	init_data->name = (char *)name;
+	init_data->dst = id;
+	init_data->ctrl_channel = ctrl_ch;
+	init_data->playback_channel = playback_ch;
+	init_data->capture_channel = capture_ch;
+	init_data->monitor_channel = monitor_ch;
+#endif
+
+	if (!(saudio = saudio_card_probe(init_data))) {
+		return -1;
+	}
+	saudio->pdev = devptr;
+
+	saudio->queue = create_singlethread_workqueue("saudio");
+	if (!saudio->queue) {
+		printk("saudio:workqueue create error %d\n", (int)saudio->queue);
+		if (saudio) {
+			kfree(saudio);
+			saudio = NULL;
+		}
+		return -1;
+	}
+	printk("saudio:workqueue create ok");
+	INIT_WORK(&saudio->card_free_work, saudio_work_card_free_handler);
+
+	platform_set_drvdata(devptr, saudio);
+
+	saudio->thread_id = kthread_create(saudio_ctrl_thread, saudio, "saudio-%d-%d",saudio->dst,saudio->channel);
+	if (IS_ERR(saudio->thread_id)) {
+		ETRACE("virtual audio cmd kernel thread creation failure \n");
+		destroy_workqueue(saudio->queue);
+		saudio->queue = NULL;
+		saudio->thread_id = NULL;
+		kfree(saudio);
+		platform_set_drvdata(devptr, NULL);
+		return -1;
+	}
+	wake_up_process(saudio->thread_id);
+	return 0;
+}
+
+static int snd_saudio_remove(struct platform_device *devptr)
+{
+	struct snd_saudio *saudio = platform_get_drvdata(devptr);
+
+	if (saudio) {
+		if (!IS_ERR_OR_NULL(saudio->thread_id)) {
+		    kthread_stop(saudio->thread_id);
+		    saudio->thread_id = NULL;
+		}
+		if (saudio->queue)
+			destroy_workqueue(saudio->queue);
+		if (saudio->pdev) {
+			platform_device_unregister(saudio->pdev);
+		}
+		if (saudio->card) {
+			mutex_lock(&snd_sound);
+			snd_card_free(saudio->card);
+			saudio->card = NULL;
+			mutex_unlock(&snd_sound);
+		}
+		kfree(saudio);
+	}
+	return 0;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id saudio_dt_match[] = {
+	{.compatible = "sprd,saudio"},
+	{},
+};
+#endif
+
+static struct platform_driver snd_saudio_driver = {
+	.probe = snd_saudio_probe,
+	.remove = snd_saudio_remove,
+	.driver = {
+		.name = "saudio",
+		.owner = THIS_MODULE,
+#ifdef CONFIG_OF
+		.of_match_table = saudio_dt_match,
+#endif
+	},
+};
+
+static int __init alsa_card_saudio_init(void)
+{
+	int err;
+	err = platform_driver_register(&snd_saudio_driver);
+	if (err < 0)
+		printk("saudio: platform_driver_register err %d\n", err);
+	return 0;
+}
+
+static void __exit alsa_card_saudio_exit(void)
+{
+	platform_driver_unregister(&snd_saudio_driver);
+	return;
+}
+
+module_init(alsa_card_saudio_init)
+module_exit(alsa_card_saudio_exit)