Gitiles
Code Review Sign In
review.evervolv.com / android_kernel_htc_msm8960 / 9dc34f38fdbd841a6d5f1b0ee0a34e2c6b6581a8 / . / drivers / misc / rt5501.c
blob: 5cefcf43615f87db19c49ac5a5e59363aea160de [file] [log] [blame]
/* driver/i2c/chip/tap6185.c
*
* TI rt5501 Speaker Amp
*
* Copyright (C) 2010 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/i2c.h>
#include <linux/slab.h>
#include <linux/irq.h>
#include <linux/miscdevice.h>
#include <asm/uaccess.h>
#include <linux/delay.h>
#include <linux/input.h>
#include <linux/workqueue.h>
#include <linux/freezer.h>
#include <linux/rt5501.h>
#include <linux/mutex.h>
#include <linux/debugfs.h>
#include <linux/gpio.h>
#include <linux/module.h>
#include <linux/mfd/pm8xxx/pm8921.h>
#include <linux/mfd/pm8xxx/pm8921.h>
#include <mach/htc_headset_mgr.h>
#include <linux/wakelock.h>
#include <mach/htc_acoustic_pmic.h>
#include <linux/jiffies.h>
#ifdef CONFIG_AMP_RT5501_ON_GPIO
#define DEBUG (1)
#else
#define DEBUG (1)
#endif
#define AMP_ON_CMD_LEN 7
#define RETRY_CNT 5
#define DRIVER_NAME "RT5501"
struct headset_query {
struct mutex mlock;
struct mutex gpiolock;
struct delayed_work hs_imp_detec_work;
struct wake_lock hs_wake_lock;
struct wake_lock gpio_wake_lock;
enum HEADSET_QUERY_STATUS hs_qstatus;
enum RT5501_STATUS rt5501_status;
enum HEADSET_OM headsetom;
enum RT5501_Mode curmode;
enum AMP_GPIO_STATUS gpiostatus;
enum AMP_S4_STATUS s4status;
int action_on;
int gpio_off_cancel;
struct mutex actionlock;
struct delayed_work volume_ramp_work;
struct delayed_work gpio_off_work;
};
static struct i2c_client *this_client;
static struct rt5501_platform_data *pdata;
static int rt5501Connect = 0;
static int MFG_MODE = 0;
struct rt5501_config_data rt5501_config_data;
static struct mutex hp_amp_lock;
static int rt5501_opened;
static int last_spkamp_state;
struct rt5501_config RT5501_AMP_ON = {6,{{0x1,0x1c},{0x2,0x00},{0x7,0x7f},{0x9,0x1},{0xa,0x0},{0xb,0xc7},}};
struct rt5501_config RT5501_AMP_INIT = {11,{{0,0xc0},{0x81,0x30},{0x87,0xf6},{0x93,0x8d},{0x95,0x7d},{0xa4,0x52},\
{0x96,0xae},{0x97,0x13},{0x99,0x35},{0x9b,0x68},{0x9d,0x68},}};
struct rt5501_config RT5501_AMP_MUTE = {1,{{0x1,0xC7},}};;
struct rt5501_config RT5501_AMP_OFF = {1,{{0x0,0x1},}};
static int rt5501_write_reg(u8 reg, u8 val);
static int rt5501_i2c_write_for_read(char *txData, int length);
static int rt5501_i2c_read(char *rxData, int length);
static void hs_imp_detec_func(struct work_struct *work);
static int rt5501_i2c_read_addr(char *rxData, unsigned char addr);
static int rt5501_i2c_write(struct rt5501_reg_data *txData, int length);
static void set_amp(int on, struct rt5501_config *i2c_command);
struct headset_query rt5501_query;
static struct workqueue_struct *hs_wq;
static struct workqueue_struct *ramp_wq;
static struct workqueue_struct *gpio_wq;
static int high_imp = 0;
static u64 last_hp_remove = 0;
#if 0
static int query_playback(void *pdata)
{
return 0;
}
#endif
static int rt5501_headset_detect(int on)
{
if(on) {
pr_info("%s: headset in ++\n",__func__);
mutex_lock(&rt5501_query.mlock);
if(rt5501_query.headsetom == HEADSET_OM_UNDER_DETECT || \
time_after64(get_jiffies_64(),last_hp_remove + msecs_to_jiffies(500))) {
rt5501_query.hs_qstatus = RT5501_QUERY_HEADSET;
rt5501_query.headsetom = HEADSET_OM_UNDER_DETECT;
} else {
rt5501_query.hs_qstatus = RT5501_QUERY_FINISH;
}
mutex_unlock(&rt5501_query.mlock);
cancel_delayed_work_sync(&rt5501_query.hs_imp_detec_work);
mutex_lock(&rt5501_query.gpiolock);
mutex_lock(&rt5501_query.mlock);
if(rt5501_query.rt5501_status == RT5501_PLAYBACK) {
if(high_imp) {
rt5501_write_reg(1,0x7);
rt5501_write_reg(0xb1,0x81);
} else {
rt5501_write_reg(1,0xc7);
}
last_spkamp_state = 0;
pr_info("%s: OFF\n", __func__);
rt5501_query.rt5501_status = RT5501_SUSPEND;
}
pr_info("%s: headset in --\n",__func__);
mutex_unlock(&rt5501_query.mlock);
mutex_unlock(&rt5501_query.gpiolock);
queue_delayed_work(hs_wq,&rt5501_query.hs_imp_detec_work,msecs_to_jiffies(5));
pr_info("%s: headset in --2\n",__func__);
} else {
pr_info("%s: headset remove ++\n",__func__);
flush_work_sync(&rt5501_query.volume_ramp_work.work);
mutex_lock(&rt5501_query.mlock);
rt5501_query.hs_qstatus = RT5501_QUERY_OFF;
mutex_unlock(&rt5501_query.mlock);
cancel_delayed_work_sync(&rt5501_query.hs_imp_detec_work);
mutex_lock(&rt5501_query.gpiolock);
mutex_lock(&rt5501_query.mlock);
if(rt5501_query.rt5501_status == RT5501_PLAYBACK) {
if(high_imp) {
rt5501_write_reg(1,0x7);
rt5501_write_reg(0xb1,0x81);
} else {
rt5501_write_reg(1,0xc7);
}
last_spkamp_state = 0;
pr_info("%s: OFF\n", __func__);
rt5501_query.rt5501_status = RT5501_SUSPEND;
}
rt5501_query.curmode = RT5501_MODE_OFF;
pr_info("%s: headset remove --1\n",__func__);
if(high_imp) {
int closegpio = 0;
if((rt5501_query.gpiostatus == AMP_GPIO_OFF) && pdata->gpio_rt5501_spk_en) {
if(rt5501_query.s4status == AMP_S4_AUTO) {
pm8921_aud_set_s4_pwm();
rt5501_query.s4status = AMP_S4_PWM;
msleep(1);
}
pr_info("%s: enable gpio %d\n",__func__,pdata->gpio_rt5501_spk_en);
gpio_direction_output(pdata->gpio_rt5501_spk_en, 1);
rt5501_query.gpiostatus = AMP_GPIO_ON;
closegpio = 1;
msleep(1);
}
pr_info("%s: reset rt5501\n",__func__);
rt5501_write_reg(0x0,0x4);
mdelay(1);
rt5501_write_reg(0x1,0xc7);
high_imp = 0;
if(closegpio && (rt5501_query.gpiostatus == AMP_GPIO_ON) && pdata->gpio_rt5501_spk_en) {
pr_info("%s: disable gpio %d\n",__func__,pdata->gpio_rt5501_spk_en);
gpio_direction_output(pdata->gpio_rt5501_spk_en, 0);
rt5501_query.gpiostatus = AMP_GPIO_OFF;
if(rt5501_query.s4status == AMP_S4_PWM) {
pm8921_aud_set_s4_auto();
rt5501_query.s4status = AMP_S4_AUTO;
}
}
}
last_hp_remove = get_jiffies_64();
mutex_unlock(&rt5501_query.mlock);
mutex_unlock(&rt5501_query.gpiolock);
pr_info("%s: headset remove --2\n",__func__);
}
return 0;
}
static int rt5501_write_reg(u8 reg, u8 val)
{
int err;
struct i2c_msg msg[1];
unsigned char data[2];
msg->addr = this_client->addr;
msg->flags = 0;
msg->len = 2;
msg->buf = data;
data[0] = reg;
data[1] = val;
pr_info("%s: write reg 0x%x val 0x%x\n",__func__,data[0],data[1]);
err = i2c_transfer(this_client->adapter, msg, 1);
if (err >= 0)
return 0;
else {
pr_info("%s: write error error %d\n",__func__,err);
return err;
}
}
static int rt5501_i2c_write(struct rt5501_reg_data *txData, int length)
{
int i, retry, pass = 0;
char buf[2];
struct i2c_msg msg[] = {
{
.addr = this_client->addr,
.flags = 0,
.len = 2,
.buf = buf,
},
};
for (i = 0; i < length; i++) {
buf[0] = txData[i].addr;
buf[1] = txData[i].val;
#if DEBUG
pr_info("%s:i2c_write addr 0x%x val 0x%x\n", __func__,buf[0], buf[1]);
#endif
msg->buf = buf;
retry = RETRY_CNT;
pass = 0;
while (retry--) {
if (i2c_transfer(this_client->adapter, msg, 1) < 0) {
pr_err("%s: I2C transfer error %d retry %d\n",
__func__, i, retry);
msleep(20);
} else {
pass = 1;
break;
}
}
if (pass == 0) {
pr_err("I2C transfer error, retry fail\n");
return -EIO;
}
}
return 0;
}
static int rt5501_i2c_write_for_read(char *txData, int length)
{
int i, retry, pass = 0;
char buf[2];
struct i2c_msg msg[] = {
{
.addr = this_client->addr,
.flags = 0,
.len = 2,
.buf = buf,
},
};
for (i = 0; i < length; i++) {
buf[0] = i;
buf[1] = txData[i];
#if DEBUG
pr_info("i2c_write %d=%x\n", i, buf[1]);
#endif
msg->buf = buf;
retry = RETRY_CNT;
pass = 0;
while (retry--) {
if (i2c_transfer(this_client->adapter, msg, 1) < 0) {
pr_err("%s: I2C transfer error %d retry %d\n",
__func__, i, retry);
msleep(20);
} else {
pass = 1;
break;
}
}
if (pass == 0) {
pr_err("I2C transfer error, retry fail\n");
return -EIO;
}
}
return 0;
}
static int rt5501_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;
}
{
int i = 0;
for (i = 0; i < length; i++)
pr_info("i2c_read %s: rx[%d] = 0x%x\n", __func__, i, \
rxData[i]);
}
return 0;
}
static int rt5501_i2c_read_addr(char *rxData, unsigned char addr)
{
int rc;
struct i2c_msg msgs[] = {
{
.addr = this_client->addr,
.flags = 0,
.len = 1,
.buf = rxData,
},
{
.addr = this_client->addr,
.flags = I2C_M_RD,
.len = 1,
.buf = rxData,
},
};
if(!rxData)
return -1;
*rxData = addr;
rc = i2c_transfer(this_client->adapter, &msgs[0], 1);
if (rc < 0) {
pr_err("%s: transfer error %d\n", __func__, rc);
return rc;
}
rc = i2c_transfer(this_client->adapter, &msgs[1], 1);
if (rc < 0) {
pr_err("%s: transfer error %d\n", __func__, rc);
return rc;
}
pr_info("%s:i2c_read addr 0x%x value = 0x%x\n", __func__, addr, *rxData);
return 0;
}
static int rt5501_open(struct inode *inode, struct file *file)
{
int rc = 0;
mutex_lock(&hp_amp_lock);
if (rt5501_opened) {
pr_err("%s: busy\n", __func__);
rc = -EBUSY;
goto done;
}
rt5501_opened = 1;
done:
mutex_unlock(&hp_amp_lock);
return rc;
}
static int rt5501_release(struct inode *inode, struct file *file)
{
mutex_lock(&hp_amp_lock);
rt5501_opened = 0;
mutex_unlock(&hp_amp_lock);
return 0;
}
#if 0
static int init_rt5501(void)
{
int ret;
ret = rt5501_i2c_write(RT5501_AMP_INIT.reg, RT5501_AMP_INIT.reg_len);
if(ret < 0) {
pr_err("init rt5501 error %d\n",ret);
return ret;
}
#if 0
ret = rt5501_i2c_write(RT5501_AMP_ON.reg, RT5501_AMP_ON.reg_len);
if(ret < 0) {
pr_err("init rt5501 to playback error %d\n",ret);
return ret;
}
ret = rt5501_i2c_write(RT5501_AMP_MUTE.reg, RT5501_AMP_MUTE.reg_len);
if(ret < 0) {
pr_err("init rt5501 to mute error %d\n",ret);
return ret;
}
ret = rt5501_i2c_write(RT5501_AMP_OFF.reg, RT5501_AMP_OFF.reg_len);
if(ret < 0) {
pr_err("init rt5501 to off error %d\n",ret);
return ret;
}
#endif
return ret;
}
#endif
static void hs_imp_gpio_off(struct work_struct *work)
{
u64 timeout = get_jiffies_64() + 5*HZ;
wake_lock(&rt5501_query.gpio_wake_lock);
while(1) {
if(time_after64(get_jiffies_64(),timeout))
break;
else if(rt5501_query.gpio_off_cancel) {
wake_unlock(&rt5501_query.gpio_wake_lock);
return;
} else
msleep(10);
}
mutex_lock(&rt5501_query.gpiolock);
pr_info("%s: disable gpio %d\n",__func__,pdata->gpio_rt5501_spk_en);
gpio_direction_output(pdata->gpio_rt5501_spk_en, 0);
rt5501_query.gpiostatus = AMP_GPIO_OFF;
if(rt5501_query.s4status == AMP_S4_PWM) {
pm8921_aud_set_s4_auto();
rt5501_query.s4status = AMP_S4_AUTO;
}
mutex_unlock(&rt5501_query.gpiolock);
wake_unlock(&rt5501_query.gpio_wake_lock);
}
static void hs_imp_detec_func(struct work_struct *work)
{
struct headset_query *hs;
char temp[8]={0x1,};
int ret;
int rt5501_status;
pr_info("%s: read rt5501 hs imp \n",__func__);
hs = container_of(work, struct headset_query, hs_imp_detec_work.work);
wake_lock(&hs->hs_wake_lock);
rt5501_query.gpio_off_cancel = 1;
cancel_delayed_work_sync(&rt5501_query.gpio_off_work);
mutex_lock(&hs->gpiolock);
mutex_lock(&hs->mlock);
if((hs->gpiostatus == AMP_GPIO_OFF) && pdata->gpio_rt5501_spk_en) {
if(rt5501_query.s4status == AMP_S4_AUTO) {
pm8921_aud_set_s4_pwm();
rt5501_query.s4status = AMP_S4_PWM;
msleep(1);
}
pr_info("%s: enable gpio %d\n",__func__,pdata->gpio_rt5501_spk_en);
gpio_direction_output(pdata->gpio_rt5501_spk_en, 1);
rt5501_query.gpiostatus = AMP_GPIO_ON;
}
msleep(1);
if(hs->hs_qstatus == RT5501_QUERY_HEADSET) {
rt5501_write_reg(0,0x04);
rt5501_write_reg(0xa4,0x52);
rt5501_write_reg(1,0x7);
msleep(10);
rt5501_write_reg(0x3,0x81);
msleep(101);
ret = rt5501_i2c_read_addr(temp,0x4);
if(ret < 0) {
pr_err("%s: read rt5501 status error %d\n",__func__,ret);
if((hs->gpiostatus == AMP_GPIO_ON) && pdata->gpio_rt5501_spk_en) {
rt5501_query.gpio_off_cancel = 0;
queue_delayed_work(gpio_wq, &rt5501_query.gpio_off_work, msecs_to_jiffies(0));
}
mutex_unlock(&hs->mlock);
mutex_unlock(&hs->gpiolock);
wake_unlock(&hs->hs_wake_lock);
return;
}
temp[1] = 0x4;
rt5501_i2c_read_addr(&temp[1],0x6);
if(temp[0] & RT5501_SENSE_READY) {
unsigned char om, hsmode;
enum HEADSET_OM hsom;
high_imp = 0;
hsmode = (temp[0] & 0x30) >> 4;
om = (temp[0] & 0xe) >> 1;
if((temp[0] == 0xc0 || temp[0] == 0xc1) && (temp[1] == 0)) {
hsom = HEADSET_MONO;
} else {
switch(om) {
case 0:
hsom = HEADSET_8OM;
break;
case 1:
hsom = HEADSET_16OM;
break;
case 2:
hsom = HEADSET_32OM;
break;
case 3:
hsom = HEADSET_64OM;
break;
case 4:
hsom = HEADSET_128OM;
break;
case 5:
hsom = HEADSET_256OM;
break;
case 6:
hsom = HEADSET_500OM;
break;
case 7:
hsom = HEADSET_1KOM;
break;
default:
hsom = HEADSET_OM_UNDER_DETECT;
break;
}
}
hs->hs_qstatus = RT5501_QUERY_FINISH;
hs->headsetom = hsom;
if(om >= HEADSET_256OM && om <= HEADSET_1KOM)
high_imp = 1;
pr_info("rt5501 hs imp value 0x%x hsmode %d om 0x%x hsom %d high_imp %d\n", \
temp[0] & 0xf,hsmode,om,hsom,high_imp);
} else {
if(hs->hs_qstatus == RT5501_QUERY_HEADSET)
queue_delayed_work(hs_wq,&rt5501_query.hs_imp_detec_work,QUERY_LATTER);
}
}
rt5501_write_reg(0x0,0x4);
mdelay(1);
rt5501_write_reg(0x0,0xc0);
rt5501_write_reg(0x81,0x30);
rt5501_write_reg(0x90,0xd0);
rt5501_write_reg(0x93,0x9d);
rt5501_write_reg(0x95,0x7b);
rt5501_write_reg(0xa4,0x01);
rt5501_write_reg(0x97,0x11);
rt5501_write_reg(0x98,0x22);
rt5501_write_reg(0x99,0x44);
rt5501_write_reg(0x9a,0x55);
rt5501_write_reg(0x9b,0x66);
rt5501_write_reg(0x9c,0x99);
rt5501_write_reg(0x9d,0x66);
rt5501_write_reg(0x9e,0x99);
rt5501_status = hs->rt5501_status;
if(high_imp) {
rt5501_write_reg(0xb1,0x81);
rt5501_write_reg(0x80,0x87);
rt5501_write_reg(0x83,0xc3);
rt5501_write_reg(0x84,0x63);
rt5501_write_reg(0x89,0x7);
mdelay(9);
rt5501_write_reg(0x83,0xcf);
rt5501_write_reg(0x89,0x1d);
mdelay(1);
rt5501_write_reg(1,0x7);
rt5501_write_reg(0xb1,0x81);
} else {
rt5501_write_reg(1,0xc7);
}
if((hs->gpiostatus == AMP_GPIO_ON) && pdata->gpio_rt5501_spk_en) {
rt5501_query.gpio_off_cancel = 0;
queue_delayed_work(gpio_wq, &rt5501_query.gpio_off_work, msecs_to_jiffies(0));
}
mutex_unlock(&hs->mlock);
mutex_unlock(&hs->gpiolock);
if(rt5501_status == RT5501_SUSPEND)
set_rt5501_amp(1);
wake_unlock(&hs->hs_wake_lock);
}
static void volume_ramp_func(struct work_struct *work)
{
mutex_lock(&rt5501_query.actionlock);
if(rt5501_query.rt5501_status != RT5501_PLAYBACK) {
u8 val;
pr_info("%s: ramping-------------------------\n",__func__);
mdelay(1);
if(high_imp)
rt5501_write_reg(0xb1,0x80);
rt5501_write_reg(0x2,0x0);
mdelay(1);
val = 0x7;
if (MFG_MODE) {
pr_info("Skip volume ramp for MFG build");
val += 15;
rt5501_write_reg(1,val);
} else {
#if 1
int i;
for(i=0; i<15; i++) {
if(!rt5501_query.action_on) {
mutex_unlock(&rt5501_query.actionlock);
return;
}
msleep(1);
rt5501_write_reg(1,val);
val++;
}
#else
for(i=0; i<8; i++) {
msleep(10);
rt5501_write_reg(1,val);
val += 2;
}
#endif
}
}
set_amp(1, &RT5501_AMP_ON);
mutex_unlock(&rt5501_query.actionlock);
}
static void set_amp(int on, struct rt5501_config *i2c_command)
{
pr_info("%s: %d\n", __func__, on);
mutex_lock(&rt5501_query.mlock);
mutex_lock(&hp_amp_lock);
if(rt5501_query.hs_qstatus == RT5501_QUERY_HEADSET)
rt5501_query.hs_qstatus = RT5501_QUERY_FINISH;
if (on) {
rt5501_query.rt5501_status = RT5501_PLAYBACK;
if (rt5501_i2c_write(i2c_command->reg, i2c_command->reg_len) == 0) {
last_spkamp_state = 1;
pr_info("%s: ON \n",
__func__);
}
} else {
if(high_imp) {
rt5501_write_reg(1,0x7);
rt5501_write_reg(0xb1,0x81);
} else {
rt5501_write_reg(1,0xc7);
}
if(rt5501_query.rt5501_status == RT5501_PLAYBACK) {
last_spkamp_state = 0;
pr_info("%s: OFF\n", __func__);
}
rt5501_query.rt5501_status = RT5501_OFF;
rt5501_query.curmode = RT5501_MODE_OFF;
}
mutex_unlock(&hp_amp_lock);
mutex_unlock(&rt5501_query.mlock);
}
int query_rt5501(void)
{
return rt5501Connect;
}
void set_rt5501_amp(int on)
{
pr_info("%s: %d\n", __func__, on);
rt5501_query.gpio_off_cancel = 1;
if(!on)
rt5501_query.action_on = 0;
cancel_delayed_work_sync(&rt5501_query.gpio_off_work);
cancel_delayed_work_sync(&rt5501_query.volume_ramp_work);
flush_work_sync(&rt5501_query.volume_ramp_work.work);
mutex_lock(&rt5501_query.gpiolock);
if(on) {
if((rt5501_query.gpiostatus == AMP_GPIO_OFF) && pdata->gpio_rt5501_spk_en) {
if(rt5501_query.s4status == AMP_S4_AUTO) {
pm8921_aud_set_s4_pwm();
rt5501_query.s4status = AMP_S4_PWM;
msleep(1);
}
#ifdef CONFIG_AMP_RT5501_DELAY
msleep(50);
#endif
pr_info("%s: enable gpio %d\n",__func__,pdata->gpio_rt5501_spk_en);
gpio_direction_output(pdata->gpio_rt5501_spk_en, 1);
rt5501_query.gpiostatus = AMP_GPIO_ON;
msleep(1);
}
rt5501_query.action_on = 1;
queue_delayed_work(ramp_wq, &rt5501_query.volume_ramp_work, msecs_to_jiffies(0));
} else {
set_amp(0, &RT5501_AMP_ON);
if((rt5501_query.gpiostatus == AMP_GPIO_ON) && pdata->gpio_rt5501_spk_en) {
rt5501_query.gpio_off_cancel = 0;
queue_delayed_work(gpio_wq, &rt5501_query.gpio_off_work, msecs_to_jiffies(0));
}
}
mutex_unlock(&rt5501_query.gpiolock);
}
static int update_amp_parameter(int mode)
{
if (mode >= rt5501_config_data.mode_num)
return -EINVAL;
pr_info("%s: set mode %d\n", __func__, mode);
if (mode == RT5501_MODE_OFF)
memcpy(&RT5501_AMP_OFF, &rt5501_config_data.cmd_data[mode].config,
sizeof(struct rt5501_config));
else if (mode == RT5501_INIT)
memcpy(&RT5501_AMP_INIT, &rt5501_config_data.cmd_data[mode].config,
sizeof(struct rt5501_config));
else if (mode == RT5501_MUTE)
memcpy(&RT5501_AMP_MUTE, &rt5501_config_data.cmd_data[mode].config,
sizeof(struct rt5501_config));
else {
memcpy(&RT5501_AMP_ON, &rt5501_config_data.cmd_data[mode].config,
sizeof(struct rt5501_config));
}
return 0;
}
static long rt5501_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
void __user *argp = (void __user *)arg;
int rc = 0, modeid = 0;
unsigned char tmp[7];
unsigned char reg_idx[1] = {0x01};
struct rt5501_comm_data spk_cfg;
unsigned char reg_value[2];
int premode = 0;
int rt5501_status = 0;
switch (cmd) {
case RT5501_WRITE_REG:
pr_info("%s: RT5501_WRITE_REG\n", __func__);
mutex_lock(&hp_amp_lock);
if (!last_spkamp_state) {
mdelay(30);
}
if (copy_from_user(reg_value, argp, sizeof(reg_value)))
goto err1;
pr_info("%s: reg_value[0]=%2x, reg_value[1]=%2x\n", __func__, \
reg_value[0], reg_value[1]);
rc = rt5501_write_reg(reg_value[0], reg_value[1]);
err1:
mutex_unlock(&hp_amp_lock);
break;
case RT5501_SET_CONFIG:
if (copy_from_user(&spk_cfg, argp, sizeof(struct rt5501_comm_data)))
return -EFAULT;
memcpy(&RT5501_AMP_ON, &spk_cfg.config,
sizeof(struct rt5501_config));
break;
case RT5501_READ_CONFIG:
mutex_lock(&hp_amp_lock);
if (!last_spkamp_state) {
mdelay(30);
}
rc = rt5501_i2c_write_for_read(reg_idx, sizeof(reg_idx));
if (rc < 0)
goto err2;
rc = rt5501_i2c_read(tmp, sizeof(tmp));
if (rc < 0)
goto err2;
if (copy_to_user(argp, &tmp, sizeof(tmp)))
rc = -EFAULT;
err2:
mutex_unlock(&hp_amp_lock);
break;
case RT5501_SET_MODE:
if (copy_from_user(&modeid, argp, sizeof(modeid)))
return -EFAULT;
if (modeid >= rt5501_config_data.mode_num || modeid <= 0) {
pr_err("unsupported rt5501 mode %d\n", modeid);
return -EINVAL;
}
mutex_lock(&hp_amp_lock);
premode = rt5501_query.curmode;
rt5501_query.curmode = modeid;
rc = update_amp_parameter(modeid);
rt5501_status = rt5501_query.rt5501_status;
mutex_unlock(&hp_amp_lock);
pr_info("%s:set rt5501 mode to %d curstatus %d\n", __func__,modeid,rt5501_status);
if(rt5501_status == RT5501_SUSPEND || (rt5501_status == RT5501_PLAYBACK && premode != rt5501_query.curmode)) {
flush_work_sync(&rt5501_query.volume_ramp_work.work);
mutex_lock(&rt5501_query.actionlock);
rt5501_query.action_on = 1;
mutex_unlock(&rt5501_query.actionlock);
queue_delayed_work(ramp_wq, &rt5501_query.volume_ramp_work, msecs_to_jiffies(280));
}
break;
case RT5501_SET_PARAM:
if (copy_from_user(&rt5501_config_data.mode_num, argp, sizeof(unsigned int))) {
pr_err("%s: copy from user failed.\n", __func__);
return -EFAULT;
}
if (rt5501_config_data.mode_num <= 0) {
pr_err("%s: invalid mode number %d\n",
__func__, rt5501_config_data.mode_num);
return -EINVAL;
}
if (rt5501_config_data.cmd_data == NULL)
rt5501_config_data.cmd_data = kzalloc(sizeof(struct rt5501_comm_data)*rt5501_config_data.mode_num, GFP_KERNEL);
if (!rt5501_config_data.cmd_data) {
pr_err("%s: out of memory\n", __func__);
return -ENOMEM;
}
if (copy_from_user(rt5501_config_data.cmd_data, ((struct rt5501_config_data*)argp)->cmd_data \
,sizeof(struct rt5501_comm_data)*rt5501_config_data.mode_num)) {
pr_err("%s: copy data from user failed.\n", __func__);
kfree(rt5501_config_data.cmd_data);
rt5501_config_data.cmd_data = NULL;
return -EFAULT;
}
pr_info("%s: update rt5501 i2c commands #%d success.\n",
__func__, rt5501_config_data.mode_num);
mutex_lock(&hp_amp_lock);
update_amp_parameter(RT5501_MODE_OFF);
update_amp_parameter(RT5501_MUTE);
update_amp_parameter(RT5501_INIT);
mutex_unlock(&hp_amp_lock);
rc = 0;
break;
case RT5501_QUERY_OM:
mutex_lock(&rt5501_query.mlock);
rc = rt5501_query.headsetom;
mutex_unlock(&rt5501_query.mlock);
pr_info("%s: query headset om %d\n", __func__,rc);
if (copy_to_user(argp, &rc, sizeof(rc)))
rc = -EFAULT;
else
rc = 0;
break;
default:
pr_err("%s: Invalid command\n", __func__);
rc = -EINVAL;
break;
}
return rc;
}
static struct file_operations rt5501_fops = {
.owner = THIS_MODULE,
.open = rt5501_open,
.release = rt5501_release,
.unlocked_ioctl = rt5501_ioctl,
};
static struct miscdevice rt5501_device = {
.minor = MISC_DYNAMIC_MINOR,
.name = "rt5501",
.fops = &rt5501_fops,
};
int rt5501_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret = 0;
int err = 0;
MFG_MODE = board_mfg_mode();
pdata = client->dev.platform_data;
if (pdata == NULL) {
pr_info("%s: platform data null\n", __func__);
pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
if (pdata == NULL) {
ret = -ENOMEM;
pr_err("%s: platform data is NULL\n", __func__);
goto err_alloc_data_failed;
}
}
this_client = client;
if (ret < 0) {
pr_err("%s: pmic request aud_spk_en pin 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__);
ret = -ENODEV;
goto err_free_gpio_all;
}
if(pdata->gpio_rt5501_spk_en) {
char temp[2];
err = gpio_request(pdata->gpio_rt5501_spk_en, "hp_en");
ret = gpio_direction_output(pdata->gpio_rt5501_spk_en, 1);
if(ret < 0) {
pr_err("%s: gpio %d on error %d\n", __func__,pdata->gpio_rt5501_spk_en,ret);
}
mdelay(1);
ret = rt5501_i2c_read(temp, 2);
if(ret < 0) {
pr_info("rt5501 is not connected\n");
rt5501Connect = 0;
} else {
pr_info("rt5501 is connected\n");
rt5501Connect = 1;
}
rt5501_write_reg(0x0,0x4);
mdelay(1);
rt5501_write_reg(0x0,0xc0);
rt5501_write_reg(0x81,0x30);
rt5501_write_reg(0x90,0xd0);
rt5501_write_reg(0x93,0x9d);
rt5501_write_reg(0x95,0x7b);
rt5501_write_reg(0xa4,0x01);
rt5501_write_reg(0x97,0x11);
rt5501_write_reg(0x98,0x22);
rt5501_write_reg(0x99,0x44);
rt5501_write_reg(0x9a,0x55);
rt5501_write_reg(0x9b,0x66);
rt5501_write_reg(0x9c,0x99);
rt5501_write_reg(0x9d,0x66);
rt5501_write_reg(0x9e,0x99);
rt5501_write_reg(0x1,0xc7);
gpio_direction_output(pdata->gpio_rt5501_spk_en, 0);
if(!err)
gpio_free(pdata->gpio_rt5501_spk_en);
if(ret < 0) {
pr_err("%s: gpio %d off error %d\n", __func__,pdata->gpio_rt5501_spk_en,ret);
}
}
if(rt5501Connect) {
struct headset_notifier notifier;
ret = misc_register(&rt5501_device);
if (ret) {
pr_err("%s: rt5501_device register failed\n", __func__);
goto err_free_gpio_all;
}
hs_wq = create_workqueue("rt5501_hsdetect");
INIT_DELAYED_WORK(&rt5501_query.hs_imp_detec_work,hs_imp_detec_func);
wake_lock_init(&rt5501_query.hs_wake_lock, WAKE_LOCK_SUSPEND, DRIVER_NAME);
wake_lock_init(&rt5501_query.gpio_wake_lock, WAKE_LOCK_SUSPEND, DRIVER_NAME);
ramp_wq = create_workqueue("rt5501_volume_ramp");
INIT_DELAYED_WORK(&rt5501_query.volume_ramp_work, volume_ramp_func);
gpio_wq = create_workqueue("rt5501_gpio_off");
INIT_DELAYED_WORK(&rt5501_query.gpio_off_work, hs_imp_gpio_off);
notifier.id = HEADSET_REG_HS_INSERT;
notifier.func = rt5501_headset_detect;
headset_notifier_register(&notifier);
}
return 0;
err_free_gpio_all:
rt5501Connect = 0;
return ret;
err_alloc_data_failed:
rt5501Connect = 0;
return ret;
}
static int rt5501_remove(struct i2c_client *client)
{
struct rt5501_platform_data *p6185data = i2c_get_clientdata(client);
kfree(p6185data);
if(rt5501Connect) {
misc_deregister(&rt5501_device);
cancel_delayed_work_sync(&rt5501_query.hs_imp_detec_work);
destroy_workqueue(hs_wq);
}
return 0;
}
static void rt5501_shutdown(struct i2c_client *client)
{
rt5501_query.gpio_off_cancel = 1;
cancel_delayed_work_sync(&rt5501_query.gpio_off_work);
cancel_delayed_work_sync(&rt5501_query.volume_ramp_work);
mutex_lock(&rt5501_query.gpiolock);
mutex_lock(&hp_amp_lock);
mutex_lock(&rt5501_query.mlock);
if((rt5501_query.gpiostatus == AMP_GPIO_OFF) && pdata->gpio_rt5501_spk_en) {
if(rt5501_query.s4status == AMP_S4_AUTO) {
pm8921_aud_set_s4_pwm();
rt5501_query.s4status = AMP_S4_PWM;
msleep(1);
}
pr_info("%s: enable gpio %d\n",__func__,pdata->gpio_rt5501_spk_en);
gpio_direction_output(pdata->gpio_rt5501_spk_en, 1);
rt5501_query.gpiostatus = AMP_GPIO_ON;
msleep(1);
}
pr_info("%s: reset rt5501\n",__func__);
rt5501_write_reg(0x0,0x4);
mdelay(1);
high_imp = 0;
if((rt5501_query.gpiostatus == AMP_GPIO_ON) && pdata->gpio_rt5501_spk_en) {
pr_info("%s: disable gpio %d\n",__func__,pdata->gpio_rt5501_spk_en);
gpio_direction_output(pdata->gpio_rt5501_spk_en, 0);
rt5501_query.gpiostatus = AMP_GPIO_OFF;
if(rt5501_query.s4status == AMP_S4_PWM) {
pm8921_aud_set_s4_auto();
rt5501_query.s4status = AMP_S4_AUTO;
}
}
mutex_unlock(&rt5501_query.mlock);
mutex_unlock(&hp_amp_lock);
mutex_unlock(&rt5501_query.gpiolock);
}
static int rt5501_suspend(struct i2c_client *client, pm_message_t mesg)
{
return 0;
}
static int rt5501_resume(struct i2c_client *client)
{
return 0;
}
static const struct i2c_device_id rt5501_id[] = {
{ RT5501_I2C_NAME, 0 },
{ }
};
static struct i2c_driver rt5501_driver = {
.probe = rt5501_probe,
.remove = rt5501_remove,
.shutdown = rt5501_shutdown,
.suspend = rt5501_suspend,
.resume = rt5501_resume,
.id_table = rt5501_id,
.driver = {
.name = RT5501_I2C_NAME,
},
};
static int __init rt5501_init(void)
{
pr_info("%s\n", __func__);
mutex_init(&hp_amp_lock);
mutex_init(&rt5501_query.mlock);
mutex_init(&rt5501_query.gpiolock);
mutex_init(&rt5501_query.actionlock);
rt5501_query.rt5501_status = RT5501_OFF;
rt5501_query.hs_qstatus = RT5501_QUERY_OFF;
rt5501_query.headsetom = HEADSET_8OM;
rt5501_query.curmode = RT5501_MODE_OFF;
rt5501_query.gpiostatus = AMP_GPIO_OFF;
rt5501_query.s4status = AMP_S4_AUTO;
return i2c_add_driver(&rt5501_driver);
}
static void __exit rt5501_exit(void)
{
i2c_del_driver(&rt5501_driver);
}
module_init(rt5501_init);
module_exit(rt5501_exit);
MODULE_DESCRIPTION("rt5501 Speaker Amp driver");
MODULE_LICENSE("GPL");