/* drivers/i2c/chips/a1028.c - a1028 voice processor driver
 *
 * Copyright (C) 2009 HTC Corporation.
 *
 * 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.
 *
 */

#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/irq.h>
#include <linux/miscdevice.h>
#include <linux/gpio.h>
#include <linux/uaccess.h>
#include <linux/delay.h>
#include <linux/input.h>
#include <linux/workqueue.h>
#include <linux/freezer.h>
#include <linux/a1028.h>
#include <mach/msm_xo.h>
#define DEBUG			(0)
#define ENABLE_DIAG_IOCTLS	(1)

#define PARAM_MAX	(sizeof(char) * 6 * 1024)

static struct i2c_client *this_client;
static struct a1028_platform_data *pdata;

static int execute_cmdmsg(unsigned int);

static struct mutex a1028_lock;
static int a1028_opened;
static int a1028_suspended;
static int control_a1028_clk;
static int control_a1028_xo_clk;
static int control_a1028_micsel;
static int a1028_NS_state = A1028_NS_STATE_AUTO;
static int a1028_current_config = A1028_PATH_SUSPEND;
static int a1028_param_ID;
static char *config_data;
static int a1028_cmds_len;

struct vp_ctxt {
	unsigned char *data;
	unsigned int img_size;
};

struct vp_ctxt the_vp;

static struct msm_xo_voter *a1028_clock;
static const char *cid = "A1028";
static int a1028_xo_clk_enable(int en)
{
	int rc = 0;
	if (a1028_clock != NULL) {
		if (en)
			rc = msm_xo_mode_vote(a1028_clock, MSM_XO_MODE_ON);
		else
			rc = msm_xo_mode_vote(a1028_clock, MSM_XO_MODE_OFF);
		if (rc < 0) {
			pr_err("Configuring MSM_XO_MODE_ON failed"
						" (%d)\n", rc);
			goto fail;
		}
	} else
		pr_err("a1028_clock is null\n");
	return rc;
fail:
	msm_xo_put(a1028_clock);
	return rc;
}

static void a1028_gpio_set_value(int gpio, int value)
{
	if (gpio >  0)
		gpio_set_value(gpio, value);
}

static void a1028_pmic_set_value(int gpio, int value)
{
}

static int a1028_i2c_read(char *rxData, int length)
{
	int rc;
	struct i2c_msg msgs[] = {
		{
			.addr = this_client->addr,
			.flags = I2C_M_RD,
			.len = length,
			.buf = rxData,
		},
	};

	rc = i2c_transfer(this_client->adapter, msgs, 1);
	if (rc < 0) {
		pr_err("%s: transfer error %d\n", __func__, rc);
		return rc;
	}

#if DEBUG
	{
		int i = 0;
		for (i = 0; i < length; i++)
			pr_info("%s: rx[%d] = %2x\n", \
				__func__, i, rxData[i]);
	}
#endif

	return 0;
}

static int a1028_i2c_write(char *txData, int length)
{
	int rc;
	struct i2c_msg msg[] = {
		{
			.addr = this_client->addr,
			.flags = 0,
			.len = length,
			.buf = txData,
		},
	};

	rc = i2c_transfer(this_client->adapter, msg, 1);
	if (rc < 0) {
		pr_err("%s: transfer error %d\n", __func__, rc);
		return rc;
	}

#if DEBUG
	{
		int i = 0;
		for (i = 0; i < length; i++)
			pr_info("%s: tx[%d] = %2x\n", \
				__func__, i, txData[i]);
	}
#endif

	return 0;
}

static int a1028_open(struct inode *inode, struct file *file)
{
	int rc = 0;
	struct vp_ctxt *vp = &the_vp;

	mutex_lock(&a1028_lock);

	if (a1028_opened) {
		pr_err("%s: busy\n", __func__);
		rc = -EBUSY;
		goto done;
	}

	file->private_data = vp;
	vp->img_size = 0;
	a1028_opened = 1;
done:
	mutex_unlock(&a1028_lock);
	return rc;
}

static int a1028_release(struct inode *inode, struct file *file)
{
	mutex_lock(&a1028_lock);
	a1028_opened = 0;
	mutex_unlock(&a1028_lock);

	return 0;
}

static void a1028_i2c_sw_reset(unsigned int reset_cmd)
{
	int rc = 0;
	unsigned char msgbuf[4];

	msgbuf[0] = (reset_cmd >> 24) & 0xFF;
	msgbuf[1] = (reset_cmd >> 16) & 0xFF;
	msgbuf[2] = (reset_cmd >> 8) & 0xFF;
	msgbuf[3] = reset_cmd & 0xFF;

	pr_info("%s: %08x\n", __func__, reset_cmd);

	rc = a1028_i2c_write(msgbuf, 4);
	if (!rc)
		msleep(20);
}

static ssize_t a1028_bootup_init(struct file *file, struct a1028img *img)
{
	struct vp_ctxt *vp = file->private_data;
	int rc, pass = 0;
	int remaining;
	int retry = RETRY_CNT;
	unsigned char *index;
	char buf[2];

	if (img->img_size > A1028_MAX_FW_SIZE) {
		pr_err("%s: invalid a1028 image size %d\n", __func__,
			img->img_size);
		return -EINVAL;
	}

	vp->data = kmalloc(img->img_size, GFP_KERNEL);
	if (!vp->data) {
		pr_err("%s: out of memory\n", __func__);
		return -ENOMEM;
	}
	vp->img_size = img->img_size;
	if (copy_from_user(vp->data, img->buf, img->img_size)) {
		pr_err("%s: copy from user failed\n", __func__);
		kfree(vp->data);
		return -EFAULT;
	}

	while (retry--) {
		
		a1028_gpio_set_value(pdata->gpio_a1028_reset, 0);

		
		if (control_a1028_clk) {
			a1028_gpio_set_value(pdata->gpio_a1028_clk, 1);
			mdelay(1);
		}
		if (control_a1028_xo_clk) {
			a1028_xo_clk_enable(1);
			mdelay(1);
		}
		
		a1028_gpio_set_value(pdata->gpio_a1028_reset, 1);

		msleep(50); 

		
		buf[0] = A1028_msg_BOOT >> 8;
		buf[1] = A1028_msg_BOOT & 0xff;

		rc = a1028_i2c_write(buf, 2);
		if (rc < 0) {
			pr_err("%s: set boot mode error \
				(%d retries left)\n", __func__, retry);
			continue;
		}

		mdelay(1); 
		rc = a1028_i2c_read(buf, 1);
		if (rc < 0) {
			pr_err("%s: boot mode ack error \
				(%d retries left)\n", __func__, retry);
			continue;
		}

		if (buf[0] != A1028_msg_BOOT_ACK) {
			pr_err("%s: not a boot-mode ack \
				(%d retries left)\n", __func__, retry);
			continue;
		}

		remaining = vp->img_size / 32;
		index = vp->data;

		pr_info("%s: starting to load image (%d passes)...\n",
			__func__,
			remaining + !!(vp->img_size % 32));

		for (; remaining; remaining--, index += 32) {
			rc = a1028_i2c_write(index, 32);
			if (rc < 0)
				break;
		}

		if (rc >= 0 && vp->img_size % 32)
			rc = a1028_i2c_write(index, vp->img_size % 32);

		if (rc < 0) {
			pr_err("%s: fw load error %d (%d retries left)\n",
				__func__, rc, retry);
			continue;
		}

		msleep(20); 

		pr_info("%s: firmware loaded successfully\n", __func__);

		rc = execute_cmdmsg(A100_msg_Sync);
		if (rc < 0) {
			pr_err("%s: sync command error %d \
				(%d retries left)\n", __func__, rc, retry);
			continue;
		}

		pass = 1;
		break;
	}

	
	rc = execute_cmdmsg(A100_msg_Sleep);
	if (rc < 0) {
		pr_err("%s: suspend error\n", __func__);
		goto set_suspend_err;
	}

	a1028_suspended = 1;
	a1028_current_config = A1028_PATH_SUSPEND;

	msleep(120);
	
	if (control_a1028_clk)
		a1028_gpio_set_value(pdata->gpio_a1028_clk, 0);
	if (control_a1028_xo_clk)
		a1028_xo_clk_enable(0);

set_suspend_err:
	if (pass && !rc)
		pr_info("%s: initialized!\n", __func__);
	else
		pr_err("%s: initialization failed\n", __func__);

	kfree(vp->data);
	return rc;
}

unsigned char phonecall_receiver[] = {
	0x80, 0x1C, 0x00, 0x01,
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x17, 0x00, 0x00,
	0x80, 0x18, 0x00, 0x04,
	0x80, 0x1B, 0x00, 0x0C,
	0x80, 0x1B, 0x01, 0x0C,
	0x80, 0x17, 0x00, 0x04,
	0x80, 0x18, 0x00, 0x00,
};

unsigned char phonecall_headset[] = {
	0x80, 0x1C, 0x00, 0x01,
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x03,
	0x80, 0x26, 0x00, 0x15,
	0x80, 0x17, 0x00, 0x00,
	0x80, 0x18, 0x00, 0x04,
	0x80, 0x1B, 0x00, 0x0D,
	0x80, 0x17, 0x00, 0x04,
	0x80, 0x18, 0x00, 0x00,
};

unsigned char phonecall_TTY_headset[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x03,
	0x80, 0x26, 0x00, 0x15,
	0x80, 0x1C, 0x00, 0x00,
	0x80, 0x1B, 0x00, 0x00,
	0x80, 0x1B, 0x01, 0x00,
	0x80, 0x15, 0x00, 0x00,
};

unsigned char phonecall_speaker[] = {
	0x80, 0x1C, 0x00, 0x01,
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x02,
	0x80, 0x17, 0x00, 0x00,
	0x80, 0x18, 0x00, 0x04,
	0x80, 0x1B, 0x00, 0x14,
	0x80, 0x17, 0x00, 0x04,
	0x80, 0x18, 0x00, 0x00,
};

unsigned char phonecall_bt[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x03,
	0x80, 0x26, 0x00, 0x06,
	0x80, 0x1C, 0x00, 0x00,
	0x80, 0x1B, 0x00, 0x00,
	0x80, 0x15, 0x00, 0x00,
};

unsigned char INT_MIC_recording_receiver[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x26, 0x00, 0x01,
	0x80, 0x1B, 0x00, 0x0D,
	0x80, 0x1B, 0x01, 0x0D,
	0x80, 0x15, 0x00, 0x00,
	0x80, 0x1C, 0x00, 0x03,
};

unsigned char INT_MIC_stereo_recording_receiver[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x03,
	0x80, 0x26, 0x00, 0x07,
	0x80, 0x1B, 0x00, 0xFA,
	0x80, 0x15, 0x00, 0x00,
	0x80, 0x1C, 0x00, 0x03,
};

unsigned char EXT_MIC_recording[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x03,
	0x80, 0x26, 0x00, 0x15,
	0x80, 0x1B, 0x00, 0x0D,
	0x80, 0x1B, 0x01, 0x00,
	0x80, 0x15, 0x00, 0x00,
	0x80, 0x1C, 0x00, 0x03,
};

unsigned char INT_MIC_recording_speaker[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x26, 0x00, 0x01,
	0x80, 0x1B, 0x00, 0x0D,
	0x80, 0x1B, 0x01, 0x0D,
	0x80, 0x15, 0x00, 0x00,
	0x80, 0x1C, 0x00, 0x03,
};

unsigned char INT_MIC_stereo_recording_speaker[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x03,
	0x80, 0x26, 0x00, 0x07,
	0x80, 0x1B, 0x00, 0xFA,
	0x80, 0x15, 0x00, 0x00,
	0x80, 0x1C, 0x00, 0x03,
};

unsigned char BACK_MIC_recording[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x26, 0x00, 0x15,
	0x80, 0x1B, 0x00, 0x0D,
	0x80, 0x15, 0x00, 0x00,
	0x80, 0x1C, 0x00, 0x03,
};

unsigned char vr_no_ns_receiver[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x1C, 0x00, 0x00,
	0x80, 0x1B, 0x00, 0x0C,
	0x80, 0x1B, 0x01, 0x0C,
	0x80, 0x15, 0x00, 0x00,
};

unsigned char vr_no_ns_headset[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x03,
	0x80, 0x26, 0x00, 0x15,
	0x80, 0x1C, 0x00, 0x00,
	0x80, 0x1B, 0x00, 0x12,
	0x80, 0x15, 0x00, 0x00,
};

unsigned char vr_no_ns_speaker[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x02,
	0x80, 0x1C, 0x00, 0x00,
	0x80, 0x1B, 0x00, 0x0C,
	0x80, 0x15, 0x00, 0x00,
};

unsigned char vr_no_ns_bt[] = {
	0x80, 0x26, 0x00, 0x06,
	0x80, 0x1C, 0x00, 0x00,
	0x80, 0x1B, 0x00, 0x00,
	0x80, 0x15, 0x00, 0x00,
};

unsigned char vr_ns_receiver[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x1C, 0x00, 0x01,
	0x80, 0x17, 0x00, 0x1A,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x17, 0x00, 0x04,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x17, 0x00, 0x00,
	0x80, 0x18, 0x00, 0x04,
	0x80, 0x1B, 0x00, 0x0C,
	0x80, 0x1B, 0x01, 0x0C,
	0x80, 0x15, 0x00, 0x00,
};

unsigned char vr_ns_headset[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x03,
	0x80, 0x26, 0x00, 0x15,
	0x80, 0x1C, 0x00, 0x01,
	0x80, 0x17, 0x00, 0x00,
	0x80, 0x18, 0x00, 0x02,
	0x80, 0x17, 0x00, 0x1A,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x17, 0x00, 0x04,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x1B, 0x00, 0x12,
	0x80, 0x15, 0x00, 0x00,
};

unsigned char vr_ns_speaker[] = {
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x02,
	0x80, 0x1C, 0x00, 0x01,
	0x80, 0x17, 0x00, 0x00,
	0x80, 0x18, 0x00, 0x04,
	0x80, 0x17, 0x00, 0x04,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x17, 0x00, 0x1A,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x1B, 0x00, 0x0C,
	0x80, 0x15, 0x00, 0x00,
};

unsigned char vr_ns_bt[] = {
	0x80, 0x26, 0x00, 0x06,
	0x80, 0x1C, 0x00, 0x01,
	0x80, 0x17, 0x00, 0x00,
	0x80, 0x18, 0x00, 0x02,
	0x80, 0x17, 0x00, 0x04,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x17, 0x00, 0x1A,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x1B, 0x00, 0x00,
	0x80, 0x15, 0x00, 0x00,
};

unsigned char suspend_mode[] = {
	0x80, 0x10, 0x00, 0x01
};

unsigned char mfg_loopback[] = {
	0x80, 0x1C, 0x00, 0x00,
	0x80, 0x17, 0x00, 0x02,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x17, 0x00, 0x00,
	0x80, 0x18, 0x00, 0x04,
	0x80, 0x1B, 0x00, 0x00,
	0x80, 0x1B, 0x01, 0x00,
	0x80, 0x17, 0x00, 0x04,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x17, 0x00, 0x0E,
	0x80, 0x18, 0x00, 0x00,
	0x80, 0x17, 0x00, 0x15,
	0x80, 0x18, 0x00, 0x01,
};

static ssize_t chk_wakeup_a1028(void)
{
	int rc = 0, retry = 3;

	if (a1028_suspended == 1) {
		
		if (control_a1028_clk) {
			a1028_gpio_set_value(pdata->gpio_a1028_clk, 1);
			mdelay(1);
		}
		if (control_a1028_xo_clk) {
			a1028_xo_clk_enable(1);
			mdelay(1);
		}

		a1028_gpio_set_value(pdata->gpio_a1028_wakeup, 0);
		msleep(120);

		do {
			rc = execute_cmdmsg(A100_msg_Sync);
		} while ((rc < 0) && --retry);

		a1028_gpio_set_value(pdata->gpio_a1028_wakeup, 1);
		if (rc < 0) {
			pr_err("%s: failed (%d)\n", __func__, rc);
			goto wakeup_sync_err;
		}

		a1028_suspended = 0;
	}
wakeup_sync_err:
	return rc;
}

int a1028_filter_vp_cmd(int cmd, int mode)
{
	int msg = (cmd >> 16) & 0xFFFF;
	int filtered_cmd = cmd;

	if (a1028_NS_state == A1028_NS_STATE_AUTO)
		return cmd;

	switch (msg) {
	case A100_msg_Bypass:
		if (a1028_NS_state == A1028_NS_STATE_OFF)
			filtered_cmd = A1028_msg_VP_OFF;
		else
			filtered_cmd = A1028_msg_VP_ON;
		break;
	case A100_msg_SetAlgorithmParmID:
		a1028_param_ID = cmd & 0xFFFF;
		break;
	case A100_msg_SetAlgorithmParm:
		if (a1028_param_ID == Mic_Config) {
			if (a1028_NS_state == A1028_NS_STATE_CT)
				filtered_cmd = (msg << 16);
			else if (a1028_NS_state == A1028_NS_STATE_FT)
				filtered_cmd = (msg << 16) | 0x0002;
		}
		break;
	default:
		if (mode == A1028_CONFIG_VP)
			filtered_cmd = -1;
		break;
	}

	pr_info("%s: %x filtered = %x, a1028_NS_state %d, mode %d\n",\
		__func__, cmd, filtered_cmd, a1028_NS_state, mode);

	return filtered_cmd;
}
int build_cmds(char *cmds, int newid)
{
	int i = 0;
	int offset = 0;
	for (i = 0; i < a1028_cmds_len; i += 6)
		if (config_data[i] == newid) {
			cmds[offset++] = config_data[i + 2];
			cmds[offset++] = config_data[i + 3];
			cmds[offset++] = config_data[i + 4];
			cmds[offset++] = config_data[i + 5];
		}
	if (offset > 128) {
		pr_err("Wrong i2c commands\n");
		return 0;
	}
	return offset;
}
int a1028_set_config(int newid, int mode)
{
	int rc = 0, size = 0;
	int number_of_cmd_sets, rd_retry_cnt;
	unsigned int sw_reset = 0;
	unsigned char *i2c_cmds;
	unsigned char *index = 0;
	unsigned char ack_buf[A1028_CMD_FIFO_DEPTH * 4];
	unsigned char rdbuf[4];
	unsigned char custom_cmds[128] = {0};

	if ((a1028_suspended) && (newid == A1028_PATH_SUSPEND))
		return rc;

	rc = chk_wakeup_a1028();
	if (rc < 0)
		return rc;

	sw_reset = ((A100_msg_Reset << 16) | RESET_IMMEDIATE);

	switch (newid) {
	case A1028_PATH_INCALL_RECEIVER:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = phonecall_receiver;
		size = sizeof(phonecall_receiver);
		break;
	case A1028_PATH_INCALL_HEADSET:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 1);
		i2c_cmds = phonecall_headset;
		size = sizeof(phonecall_headset);
		break;
	case A1028_PATH_INCALL_SPEAKER:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = phonecall_speaker;
		size = sizeof(phonecall_speaker);
		break;
	case A1028_PATH_INCALL_BT:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = phonecall_bt;
		size = sizeof(phonecall_bt);
		break;
	case A1028_PATH_VR_NO_NS_RECEIVER:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = vr_no_ns_receiver;
		size = sizeof(vr_no_ns_receiver);
		break;
	case A1028_PATH_VR_NO_NS_HEADSET:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 1);
		i2c_cmds = vr_no_ns_headset;
		size = sizeof(vr_no_ns_headset);
		break;
	case A1028_PATH_VR_NO_NS_SPEAKER:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = vr_no_ns_speaker;
		size = sizeof(vr_no_ns_speaker);
		break;
	case A1028_PATH_VR_NO_NS_BT:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = vr_no_ns_bt;
		size = sizeof(vr_no_ns_bt);
		break;
	case A1028_PATH_VR_NS_RECEIVER:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = vr_ns_receiver;
		size = sizeof(vr_ns_receiver);
		break;
	case A1028_PATH_VR_NS_HEADSET:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 1);
		i2c_cmds = vr_ns_headset;
		size = sizeof(vr_ns_headset);
		break;
	case A1028_PATH_VR_NS_SPEAKER:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = vr_ns_speaker;
		size = sizeof(vr_ns_speaker);
		break;
	case A1028_PATH_VR_NS_BT:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = vr_ns_bt;
		size = sizeof(vr_ns_bt);
		break;
	case A1028_PATH_RECORD_RECEIVER:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = INT_MIC_recording_receiver;
		size = sizeof(INT_MIC_recording_receiver);
		break;
	case A1028_PATH_RECORD_HEADSET:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 1);
		i2c_cmds = EXT_MIC_recording;
		size = sizeof(EXT_MIC_recording);
		break;
	case A1028_PATH_RECORD_SPEAKER:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = INT_MIC_recording_speaker;
		size = sizeof(INT_MIC_recording_speaker);
		break;
	case A1028_PATH_RECORD_BT:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = phonecall_bt;
		size = sizeof(phonecall_bt);
		break;
	case A1028_PATH_SUSPEND:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = (unsigned char *)suspend_mode;
		size = sizeof(suspend_mode);
		break;
	case A1028_PATH_CAMCORDER:
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
		i2c_cmds = BACK_MIC_recording;
		size = sizeof(BACK_MIC_recording);
		break;
	case A1028_PATH_MFG_LOOPBACK:
		a1028_pmic_set_value(pdata->gpio_a1028_micswitch, 0);
		i2c_cmds = mfg_loopback;
		size = sizeof(mfg_loopback);
		break;
	default:
		pr_err("%s: invalid cmd %d\n", __func__, newid);
		rc = -1;
		goto input_err;
		break;
	}

	a1028_current_config = newid;

	if (a1028_cmds_len > 0) {
		int cmd_size = 0;
		cmd_size = build_cmds(custom_cmds, newid);
		if (cmd_size > 0)
			i2c_cmds = custom_cmds;
		size = cmd_size;
		pr_info("use customize command\n");
	}

	pr_info("%s: change to mode %d\n", __func__, newid);

	pr_info("%s: block write start (size = %d)\n", __func__, size);

#if DEBUG
	{
		int i = 0;
		for (i = 1; i <= size; i++) {
			pr_info("%x ", *(i2c_cmds + i - 1));
			if (!(i % 4))
				pr_info("\n");
		}
	}
#endif

	rc = a1028_i2c_write(i2c_cmds, size);
	if (rc < 0) {
		pr_err("A1028 CMD block write error!\n");
		a1028_i2c_sw_reset(sw_reset);
		return rc;
	}
	pr_info("%s: block write end\n", __func__);

	
	if (*i2c_cmds == 0x80 && *(i2c_cmds + 1) == 0x10
		&& *(i2c_cmds + 2) == 0x00 && *(i2c_cmds + 3) == 0x01) {
		a1028_suspended = 1;
		
		msleep(120);
		if (control_a1028_clk)
			a1028_gpio_set_value(pdata->gpio_a1028_clk, 0);
		if (control_a1028_xo_clk)
			a1028_xo_clk_enable(0);
		return rc;
	}

	memset(ack_buf, 0, sizeof(ack_buf));
	msleep(20);
	pr_info("%s: CMD ACK block read start\n", __func__);
	rc = a1028_i2c_read(ack_buf, size);
	if (rc < 0) {
		pr_err("%s: CMD ACK block read error\n", __func__);
		a1028_i2c_sw_reset(sw_reset);
		return rc;
	} else {
		pr_info("%s: CMD ACK block read end\n", __func__);
#if DEBUG
	{
		int i = 0;
		for (i = 1; i <= size; i++) {
			pr_info("%x ", ack_buf[i-1]);
			if (!(i % 4))
				pr_info("\n");
		}
	}
#endif
		index = ack_buf;
		number_of_cmd_sets = size / 4;
		do {
			if (*index == 0x00) {
				rd_retry_cnt = POLLING_RETRY_CNT;
rd_retry:
				if (rd_retry_cnt--) {
					memset(rdbuf, 0, sizeof(rdbuf));
					rc = a1028_i2c_read(rdbuf, 4);
					if (rc < 0)
						return rc;
#if DEBUG
				{
					int i = 0;
					for (i = 0; i < sizeof(rdbuf); i++)
						pr_info("0x%x\n", rdbuf[i]);
					pr_info("-----------------\n");
				}
#endif
					if (rdbuf[0] == 0x00) {
						msleep(20);
						goto rd_retry;
					}
				} else {
					pr_err("%s: CMD ACK Not Ready\n",
						__func__);
					return -EBUSY;
				}
			} else if (*index == 0xff) { 
				return -ENOEXEC;
			} else if (*index == 0x80) {
				index += 4;
			}
		} while (--number_of_cmd_sets);
	}
input_err:
	return rc;
}

int execute_cmdmsg(unsigned int msg)
{
	int rc = 0;
	int retries, pass = 0;
	unsigned char msgbuf[4];
	unsigned char chkbuf[4];
	unsigned int sw_reset = 0;

	sw_reset = ((A100_msg_Reset << 16) | RESET_IMMEDIATE);

	msgbuf[0] = (msg >> 24) & 0xFF;
	msgbuf[1] = (msg >> 16) & 0xFF;
	msgbuf[2] = (msg >> 8) & 0xFF;
	msgbuf[3] = msg & 0xFF;

	memcpy(chkbuf, msgbuf, 4);

	rc = a1028_i2c_write(msgbuf, 4);
	if (rc < 0) {
		pr_err("%s: error %d\n", __func__, rc);
		a1028_i2c_sw_reset(sw_reset);
		return rc;
	}

	
	if (msg == A100_msg_Sleep)
		return rc;

	retries = POLLING_RETRY_CNT;
	while (retries--) {
		rc = 0;

		msleep(20); 
		memset(msgbuf, 0, sizeof(msgbuf));
		rc = a1028_i2c_read(msgbuf, 4);
		if (rc < 0) {
			pr_err("%s: ack-read error %d (%d retries)\n",\
				__func__, rc, retries);
			continue;
		}

		if (msgbuf[0] == 0x80  && msgbuf[1] == chkbuf[1]) {
			pass = 1;
			break;
		} else if (msgbuf[0] == 0xff && msgbuf[1] == 0xff) {
			pr_err("%s: illegal cmd %08x\n", __func__, msg);
			rc = -EINVAL;
			break;
		} else if (msgbuf[0] == 0x00 && msgbuf[1] == 0x00) {
			pr_info("%s: not ready (%d retries)\n", __func__,
				retries);
			rc = -EBUSY;
		} else {
			pr_info("%s: cmd/ack mismatch: (%d retries left)\n",
				__func__,
				retries);
#if DEBUG
		pr_info("%s: msgbuf[0] = %x\n", __func__, msgbuf[0]);
		pr_info("%s: msgbuf[1] = %x\n", __func__, msgbuf[1]);
		pr_info("%s: msgbuf[2] = %x\n", __func__, msgbuf[2]);
		pr_info("%s: msgbuf[3] = %x\n", __func__, msgbuf[3]);
#endif
			rc = -EBUSY;
		}
	}

	if (!pass) {
		pr_err("%s: failed execute cmd %08x (%d)\n", __func__,
			msg, rc);
		a1028_i2c_sw_reset(sw_reset);
	}
	return rc;
}

#if ENABLE_DIAG_IOCTLS
static int a1028_set_mic_state(char miccase)
{
	int rc = 0;
	unsigned int cmd_msg = 0;

	switch (miccase) {
	case 1: 
		cmd_msg = 0x80260007;
		break;
	case 2: 
		cmd_msg = 0x80260015;
		break;
	case 3: 
		cmd_msg = 0x80260001;
		break;
	case 4: 
		cmd_msg = 0x80260006;
		break;
	default:
		pr_info("%s: invalid input %d\n", __func__, miccase);
		rc = -EINVAL;
		break;
	}
	rc = execute_cmdmsg(cmd_msg);
	return rc;
}

static int exe_cmd_in_file(unsigned char *incmd)
{
	int rc = 0;
	int i = 0;
	unsigned int cmd_msg = 0;
	unsigned char tmp = 0;

	for (i = 0; i < 4; i++) {
		tmp = *(incmd + i);
		cmd_msg |= (unsigned int)tmp;
		if (i != 3)
			cmd_msg = cmd_msg << 8;
	}
	rc = execute_cmdmsg(cmd_msg);
	if (rc < 0)
		pr_err("%s: cmd %08x error %d\n", __func__, cmd_msg, rc);
	return rc;
}
#endif 

static long
a1028_ioctl(struct file *file, unsigned int cmd,
			unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	struct a1028img img;
	struct A1028_config_data cfg;
	int rc = 0;
#if ENABLE_DIAG_IOCTLS
	char msg[4];
	int mic_cases = 0;
	int mic_sel = 0;
#endif
	int pathid = 0;
	int ns_state;

	switch (cmd) {
	case A1028_BOOTUP_INIT:
		img.buf = 0;
		img.img_size = 0;
		if (copy_from_user(&img, argp, sizeof(img)))
			return -EFAULT;
		rc = a1028_bootup_init(file, &img);
		break;
	case A1028_SET_CONFIG:
		if (copy_from_user(&pathid, argp, sizeof(pathid)))
			return -EFAULT;
		if (pathid < 0 || pathid >= A1028_PATH_MAX)
			return -EINVAL;
		rc = a1028_set_config(pathid, A1028_CONFIG_FULL);
		if (rc < 0)
			pr_err("%s: A1028_SET_CONFIG (%d) error %d!\n",
				__func__, pathid, rc);
		break;
	case A1028_SET_NS_STATE:
		if (copy_from_user(&ns_state, argp, sizeof(ns_state)))
			return -EFAULT;
		pr_info("%s: set noise suppression %d\n",\
			__func__, ns_state);
		if (ns_state < 0 || ns_state >= A1028_NS_NUM_STATES)
			return -EINVAL;
		a1028_NS_state = ns_state;
		if (!a1028_suspended)
			a1028_set_config(a1028_current_config,
					A1028_CONFIG_VP);
		break;
	case A1028_SET_PARAM:
		a1028_cmds_len = 0;
		cfg.cmd_data = 0;
		if (copy_from_user(&cfg, argp, sizeof(cfg))) {
			pr_err("%s: copy from user failed.\n", __func__);
			return -EFAULT;
		}

		if (cfg.data_len <= 0 || cfg.data_len > PARAM_MAX) {
				pr_err("%s: invalid data length %d\n", \
				__func__, cfg.data_len);
				return -EINVAL;
		}

		if (cfg.cmd_data == NULL) {
			pr_err("%s: invalid data\n", __func__);
			return -EINVAL;
		}

		if (config_data == NULL)
			config_data = kmalloc(cfg.data_len, GFP_KERNEL);
		if (!config_data) {
			pr_err("%s: out of memory\n", __func__);
			return -ENOMEM;
		}
		if (copy_from_user(config_data, cfg.cmd_data, cfg.data_len)) {
			pr_err("%s: copy data from user failed.\n",\
				__func__);
			kfree(config_data);
			config_data = NULL;
			return -EFAULT;
		}
		a1028_cmds_len = cfg.data_len;
		pr_info("%s: update a1028 i2c commands success.\n",\
			__func__);
		rc = 0;
		break;
#if ENABLE_DIAG_IOCTLS
	case A1028_SET_MIC_ONOFF:
		rc = chk_wakeup_a1028();
		if (rc < 0)
			return rc;
		if (copy_from_user(&mic_cases, argp, sizeof(mic_cases)))
			return -EFAULT;
		rc = a1028_set_mic_state(mic_cases);
		if (rc < 0)
			pr_err("%s: A1028_SET_MIC_ONOFF %d error %d!\n",
				__func__, mic_cases, rc);
		break;
	case A1028_SET_MICSEL_ONOFF:
		rc = chk_wakeup_a1028();
		if (rc < 0)
			return rc;
		if (copy_from_user(&mic_sel, argp, sizeof(mic_sel)))
			return -EFAULT;
		if (control_a1028_micsel)
			a1028_gpio_set_value(pdata->gpio_a1028_micsel, \
				!!mic_sel);
		rc = 0;
		break;
	case A1028_READ_DATA:
		rc = chk_wakeup_a1028();
		if (rc < 0)
			return rc;
		rc = a1028_i2c_read(msg, 4);
		if (copy_to_user(argp, &msg, 4))
			return -EFAULT;
		break;
	case A1028_WRITE_MSG:
		rc = chk_wakeup_a1028();
		if (rc < 0)
			return rc;
		if (copy_from_user(msg, argp, sizeof(msg)))
			return -EFAULT;
		rc = a1028_i2c_write(msg, 4);
		break;
	case A1028_SYNC_CMD:
		rc = chk_wakeup_a1028();
		if (rc < 0)
			return rc;
		msg[0] = 0x80;
		msg[1] = 0x00;
		msg[2] = 0x00;
		msg[3] = 0x00;
		rc = a1028_i2c_write(msg, 4);
		break;
	case A1028_SET_CMD_FILE:
		rc = chk_wakeup_a1028();
		if (rc < 0)
			return rc;
		if (copy_from_user(msg, argp, sizeof(msg)))
			return -EFAULT;
		rc = exe_cmd_in_file(msg);
		break;
#endif 
	default:
		pr_err("%s: invalid command %d\n", __func__, _IOC_NR(cmd));
		rc = -EINVAL;
		break;
	}

	return rc;
}

static const struct file_operations a1028_fops = {
	.owner = THIS_MODULE,
	.open = a1028_open,
	.release = a1028_release,
	.unlocked_ioctl = a1028_ioctl,
};

static struct miscdevice a1028_device = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "audience_a1028",
	.fops = &a1028_fops,
};

static int a1028_probe(
	struct i2c_client *client, const struct i2c_device_id *id)
{
	int rc = 0;
	control_a1028_xo_clk = 0;
	pdata = client->dev.platform_data;

	if (pdata == NULL) {
		pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
		if (pdata == NULL) {
			rc = -ENOMEM;
			pr_err("%s: platform data is NULL\n", __func__);
			goto err_alloc_data_failed;
		}
	}

	this_client = client;
#ifdef CONFIG_ARCH_MSM8960
	a1028_clock = msm_xo_get(MSM_XO_TCXO_D1, cid);
	if (IS_ERR(a1028_clock)) {
		control_a1028_xo_clk = 0;
		msm_xo_put(a1028_clock);
	} else {
		control_a1028_xo_clk = 1;
		pr_info("use tcxo_d1 clk");
	}
	control_a1028_clk = 0;
	control_a1028_micsel = 0;
#else
	rc = gpio_request(pdata->gpio_a1028_clk, "a1028");
	if (rc < 0) {
		control_a1028_clk = 0;
		goto chk_gpio_micsel;
	}
	control_a1028_clk = 1;

	rc = gpio_direction_output(pdata->gpio_a1028_clk, 1);
	if (rc < 0) {
		pr_err("%s: request clk gpio direction failed\n", __func__);
		goto err_free_gpio_clk;
	}

chk_gpio_micsel:
	rc = gpio_request(pdata->gpio_a1028_micsel, "a1028");
	if (rc < 0) {
		pr_info("%s: gpio request mic_sel pin failed\n", __func__);
		control_a1028_micsel = 0;
	} else {
		rc = gpio_direction_output(pdata->gpio_a1028_micsel, 1);
		if (rc < 0) {
			pr_err("%s: request mic_sel gpio direction \
				failed\n", __func__);
			goto err_free_gpio_micsel;
		}
	}
#endif

	rc = gpio_request(pdata->gpio_a1028_wakeup, "a1028");
	if (rc < 0) {
		pr_err("%s: gpio request wakeup pin failed\n", __func__);
		goto err_free_gpio;
	}

	rc = gpio_direction_output(pdata->gpio_a1028_wakeup, 1);
	if (rc < 0) {
		pr_err("%s: request wakeup gpio direction failed\n",\
			__func__);
		goto err_free_gpio;
	}

	rc = gpio_request(pdata->gpio_a1028_reset, "a1028");
	if (rc < 0) {
		pr_err("%s: gpio request reset pin failed\n", __func__);
		goto err_free_gpio;
	}

	rc = gpio_direction_output(pdata->gpio_a1028_reset, 1);
	if (rc < 0) {
		pr_err("%s: request reset gpio direction failed\n",\
			__func__);
		goto err_free_gpio_all;
	}

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		pr_err("%s: i2c check functionality error\n", __func__);
		rc = -ENODEV;
		goto err_free_gpio_all;
	}

	if (control_a1028_clk)
		a1028_gpio_set_value(pdata->gpio_a1028_clk, 1);
	if (control_a1028_micsel)
		a1028_gpio_set_value(pdata->gpio_a1028_micsel, 0);
	a1028_gpio_set_value(pdata->gpio_a1028_wakeup, 1);
	a1028_gpio_set_value(pdata->gpio_a1028_reset, 1);

	rc = misc_register(&a1028_device);
	if (rc) {
		pr_err("%s: a1028_device register failed\n", __func__);
		goto err_free_gpio_all;
	}
	pr_info("%s ok", __func__);
	return 0;

err_free_gpio_all:
	gpio_free(pdata->gpio_a1028_reset);
err_free_gpio:
	gpio_free(pdata->gpio_a1028_wakeup);
#ifndef CONFIG_ARCH_MSM8960
err_free_gpio_micsel:
	gpio_free(pdata->gpio_a1028_micsel);
err_free_gpio_clk:
	gpio_free(pdata->gpio_a1028_clk);
#endif
err_alloc_data_failed:
	return rc;
}

static int a1028_remove(struct i2c_client *client)
{
	struct a1028_platform_data *p1028data = i2c_get_clientdata(client);
	kfree(p1028data);

	return 0;
}

static int a1028_suspend(struct i2c_client *client, pm_message_t mesg)
{
	return 0;
}

static int a1028_resume(struct i2c_client *client)
{
	return 0;
}

static const struct i2c_device_id a1028_id[] = {
	{ "audience_a1028", 0 },
	{ }
};

static struct i2c_driver a1028_driver = {
	.probe = a1028_probe,
	.remove = a1028_remove,
	.suspend = a1028_suspend,
	.resume	= a1028_resume,
	.id_table = a1028_id,
	.driver = {
		.name = "audience_a1028",
	},
};

static int __init a1028_init(void)
{
	pr_info("%s\n", __func__);
	mutex_init(&a1028_lock);

	return i2c_add_driver(&a1028_driver);
}

static void __exit a1028_exit(void)
{
	i2c_del_driver(&a1028_driver);
}

module_init(a1028_init);
module_exit(a1028_exit);

MODULE_DESCRIPTION("A1028 voice processor driver");
MODULE_LICENSE("GPL");