antifallobst
/
lineage_kernel_xcoverpro
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
lineage_kernel_xcoverpro/drivers/sensorhub/tc3xxk.c

2317 lines
53 KiB
C
Raw Normal View History

initial commit
2023-06-18 22:53:49 +00:00
/* tc3xxk.c -- Linux driver for coreriver chip as grip
*
* Copyright (C) 2013 Samsung Electronics Co.Ltd
* Author: Junkyeong Kim <jk0430.kim@samsung.com>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2, or (at your option) any
* later version.
*
* 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/delay.h>
#include <linux/firmware.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <asm/unaligned.h>
#include <linux/wakelock.h>
#include <linux/workqueue.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/regulator/consumer.h>
#include <linux/sec_class.h>
#include <linux/pinctrl/consumer.h>
#ifdef CONFIG_BATTERY_SAMSUNG
#include <linux/sec_batt.h>
#endif
#include "tc3xxk.h"
#if defined (CONFIG_VBUS_NOTIFIER)
#include <linux/muic/muic.h>
#include <linux/muic/muic_notifier.h>
#include <linux/vbus_notifier.h>
#endif
#define IDLE 0
#define ACTIVE 1
/* registers */
#define TC300K_FWVER 0x01
#define TC300K_MDVER 0x02
#define TC300K_MODE 0x03
#define TC300K_CHECKS_H 0x04
#define TC300K_CHECKS_L 0x05
/* registers for grip sensor */
#define TC305K_GRIPCODE 0x0F
#define TC305K_GRIP_THD_PRESS 0x00
#define TC305K_GRIP_THD_RELEASE 0x02
#define TC305K_GRIP_THD_NOISE 0x04
#define TC305K_GRIP_CH_PERCENT 0x06
#define TC305K_GRIP_DIFF_DATA 0x08
#define TC305K_GRIP_RAW_DATA 0x0A
#define TC305K_GRIP_BASELINE 0x0C
#define TC305K_GRIP_TOTAL_CAP 0x0E
#define TC305K_GRIP_REF_CAP 0x70
#define TC305K_1GRIP 0x30
#define TC305K_2GRIP 0x40
#define TC305K_3GRIP 0x50
#define TC305K_4GRIP 0x60
#define TC350K_DATA_SIZE 0x02
#define TC350K_DATA_H_OFFSET 0x00
#define TC350K_DATA_L_OFFSET 0x01
/* command */
#define TC300K_CMD_ADDR 0x00
#define TC300K_CMD_TA_ON 0x50
#define TC300K_CMD_TA_OFF 0x60
#define TC300K_CMD_CAL_CHECKSUM 0x70
#define TC300K_CMD_STOP_MODE 0x90
#define TC300K_CMD_NORMAL_MODE 0x91
#define TC300K_CMD_SAR_DISABLE 0xA0
#define TC300K_CMD_SAR_ENABLE 0xA1
#define TC300K_CMD_GRIP_BASELINE_CAL 0xC0
#define TC300K_CMD_WAKE_UP 0xF0
#define TC300K_CMD_DELAY 50
/* mode status bit */
#define TC300K_MODE_RUN (1 << 1)
#define TC300K_MODE_SAR (1 << 2)
/* firmware */
#define TC300K_FW_PATH_SDCARD "/sdcard/tc3xxk.bin"
#define HALL_PATH "/sys/class/sec/sec_key/hall_detect"
#define HALL_CLOSE_STATE 1
#define TK_UPDATE_PASS 0
#define TK_UPDATE_DOWN 1
#define TK_UPDATE_FAIL 2
/* ISP command */
#define TC300K_CSYNC1 0xA3
#define TC300K_CSYNC2 0xAC
#define TC300K_CSYNC3 0xA5
#define TC300K_CCFG 0x92
#define TC300K_PRDATA 0x81
#define TC300K_PEDATA 0x82
#define TC300K_PWDATA 0x83
#define TC300K_PECHIP 0x8A
#define TC300K_PEDISC 0xB0
#define TC300K_LDDATA 0xB2
#define TC300K_LDMODE 0xB8
#define TC300K_RDDATA 0xB9
#define TC300K_PCRST 0xB4
#define TC300K_PCRED 0xB5
#define TC300K_PCINC 0xB6
#define TC300K_RDPCH 0xBD
/* ISP delay */
#define TC300K_TSYNC1 300 /* us */
#define TC300K_TSYNC2 50 /* 1ms~50ms */
#define TC300K_TSYNC3 100 /* us */
#define TC300K_TDLY1 1 /* us */
#define TC300K_TDLY2 2 /* us */
#define TC300K_TFERASE 10 /* ms */
#define TC300K_TPROG 20 /* us */
#define TC300K_CHECKSUM_DELAY 500
enum {
FW_INKERNEL,
FW_SDCARD,
};
struct fw_image {
u8 hdr_ver;
u8 hdr_len;
u16 first_fw_ver;
u16 second_fw_ver;
u16 third_ver;
u32 fw_len;
u16 checksum;
u16 alignment_dummy;
u8 data[0];
} __attribute__ ((packed));
#define GRIP_RELEASE 0x00
#define GRIP_PRESS 0x01
struct grip_event_val {
u16 grip_bitmap;
u8 grip_status;
char* grip_name;
};
struct grip_event_val grip_ev[4] =
{
{0x01 << 0, GRIP_PRESS, "grip1"},
{0x01 << 1, GRIP_PRESS, "grip2"},
{0x01 << 4, GRIP_RELEASE, "grip1"},
{0x01 << 5, GRIP_RELEASE, "grip2"},
};
struct tc3xxk_data {
struct device *dev;
struct i2c_client *client;
struct input_dev *input_dev;
struct tc3xxk_platform_data *pdata;
struct mutex lock_fac;
struct fw_image *fw_img;
const struct firmware *fw;
char phys[32];
int irq;
bool irq_check;
u16 checksum;
u16 threhold;
int mode;
int (*power) (bool on);
u8 fw_ver;
u8 fw_ver_bin;
u8 md_ver;
u8 md_ver_bin;
u8 fw_update_status;
bool enabled;
bool fw_downloading;
struct pinctrl *pinctrl_i2c;
struct pinctrl *pinctrl_irq;
struct pinctrl_state *pin_state[4];
struct wake_lock grip_wake_lock;
u16 grip_p_thd;
u16 grip_r_thd;
u16 grip_n_thd;
u16 grip_s1;
u16 grip_s2;
u16 grip_baseline;
u16 grip_raw1;
u16 grip_raw2;
u16 grip_event;
bool sar_enable;
bool sar_enable_off;
int grip_num;
struct grip_event_val *grip_ev_val;
struct delayed_work debug_work;
#ifdef CONFIG_SEC_FACTORY
int irq_count;
int abnormal_mode;
s32 diff;
s32 max_diff;
#endif
#if defined (CONFIG_VBUS_NOTIFIER)
struct notifier_block vbus_nb;
#endif
};
extern struct class *sec_class;
char *str_states[] = {"on_irq", "off_irq", "on_i2c", "off_i2c"};
enum {
I_STATE_ON_IRQ = 0,
I_STATE_OFF_IRQ,
I_STATE_ON_I2C,
I_STATE_OFF_I2C,
};
static bool tc3xxk_power_enabled;
const char *regulator_ic;
static int tc3xxk_pinctrl_init(struct tc3xxk_data *data);
static void tc3xxk_config_gpio_i2c(struct tc3xxk_data *data, int onoff);
static int tc3xxk_pinctrl(struct tc3xxk_data *data, int status);
static int read_tc3xxk_register_data(struct tc3xxk_data *data, int read_key_num, int read_offset);
static int tc3xxk_mode_enable(struct i2c_client *client, u8 cmd);
static void tc3xxk_grip_cal_reset(struct tc3xxk_data *data);
static int tc3xxk_get_hallic_state(struct tc3xxk_data *data)
{
char hall_buf[6];
int ret = -ENODEV;
int hall_state = -1;
mm_segment_t old_fs;
struct file *filep;
memset(hall_buf, 0, sizeof(hall_buf));
old_fs = get_fs();
set_fs(KERNEL_DS);
filep = filp_open(HALL_PATH, O_RDONLY, 0666);
if (IS_ERR(filep)) {
set_fs(old_fs);
return hall_state;
}
ret = filep->f_op->read(filep, hall_buf,
sizeof(hall_buf) - 1, &filep->f_pos);
if (ret != sizeof(hall_buf) - 1)
goto exit;
if (strcmp(hall_buf, "CLOSE") == 0)
hall_state = HALL_CLOSE_STATE;
exit:
filp_close(filep, current->files);
set_fs(old_fs);
return hall_state;
}
static void tc3xxk_debug_work_func(struct work_struct *work)
{
struct tc3xxk_data *data = container_of((struct delayed_work *)work,
struct tc3xxk_data, debug_work);
static int hall_prev_state;
int hall_state;
hall_state = tc3xxk_get_hallic_state(data);
if (hall_state == HALL_CLOSE_STATE && hall_prev_state != hall_state) {
SENSOR_INFO("%s - hall is closed\n", __func__);
tc3xxk_grip_cal_reset(data);
}
hall_prev_state = hall_state;
#ifdef CONFIG_SEC_FACTORY
if (data->abnormal_mode) {
data->diff = read_tc3xxk_register_data(data, TC305K_1GRIP, TC305K_GRIP_DIFF_DATA);
if (data->max_diff < data->diff)
data->max_diff = data->diff;
}
#endif
schedule_delayed_work(&data->debug_work, msecs_to_jiffies(2000));
}
static int tc3xxk_mode_check(struct i2c_client *client)
{
int mode = i2c_smbus_read_byte_data(client, TC300K_MODE);
if (mode < 0)
SENSOR_ERR("failed to read mode (%d)\n", mode);
return mode;
}
static int tc3xxk_wake_up(struct i2c_client *client, u8 cmd)
{
//If stop mode enabled, touch key IC need wake_up CMD
//After wake_up CMD, IC need 10ms delay
int ret;
SENSOR_INFO("Send WAKE UP cmd: 0x%02x \n", cmd);
ret = i2c_smbus_write_byte_data(client, TC300K_CMD_ADDR, TC300K_CMD_WAKE_UP);
msleep(10);
return ret;
}
static void grip_sar_sensing(struct tc3xxk_data *data, bool on)
{
/* enable/disable sar sensing
* need to disable when earjack is connected (FM radio can't work normally)
*/
}
static void tc3xxk_grip_cal_reset(struct tc3xxk_data *data)
{
/* calibrate grip sensor chn */
struct i2c_client *client = data->client;
SENSOR_INFO("\n");
i2c_smbus_write_byte_data(client, TC300K_CMD_ADDR, TC300K_CMD_GRIP_BASELINE_CAL);
msleep(TC300K_CMD_DELAY);
}
static void tc3xxk_reset(struct tc3xxk_data *data)
{
SENSOR_INFO("\n");
if (data->irq_check) {
data->irq_check = false;
disable_irq_wake(data->client->irq);
disable_irq_nosync(data->client->irq);
}
data->pdata->power(data, false);
msleep(50);
data->pdata->power(data, true);
msleep(200);
if (data->sar_enable)
tc3xxk_mode_enable(data->client, TC300K_CMD_SAR_ENABLE);
if (!data->irq_check) {
data->irq_check = true;
enable_irq(data->client->irq);
enable_irq_wake(data->client->irq);
}
}
static void tc3xxk_reset_probe(struct tc3xxk_data *data)
{
data->pdata->power(data, false);
msleep(50);
data->pdata->power(data, true);
msleep(200);
}
int tc3xxk_get_fw_version(struct tc3xxk_data *data, bool probe)
{
struct i2c_client *client = data->client;
int retry = 3;
int buf;
if ((!data->enabled) || data->fw_downloading) {
SENSOR_ERR("can't excute\n");
return -1;
}
buf = i2c_smbus_read_byte_data(client, TC300K_FWVER);
if (buf < 0) {
while (retry--) {
SENSOR_ERR("read fail(%d)\n", retry);
if (probe)
tc3xxk_reset_probe(data);
else
tc3xxk_reset(data);
buf = i2c_smbus_read_byte_data(client, TC300K_FWVER);
if (buf > 0)
break;
}
if (retry <= 0) {
SENSOR_ERR("read fail\n");
data->fw_ver = 0;
return -1;
}
}
data->fw_ver = (u8)buf;
SENSOR_INFO( "fw_ver : 0x%x\n", data->fw_ver);
return 0;
}
int tc3xxk_get_md_version(struct tc3xxk_data *data, bool probe)
{
struct i2c_client *client = data->client;
int retry = 3;
int buf;
if ((!data->enabled) || data->fw_downloading) {
SENSOR_ERR("can't excute\n");
return -1;
}
buf = i2c_smbus_read_byte_data(client, TC300K_MDVER);
if (buf < 0) {
while (retry--) {
SENSOR_ERR("read fail(%d)\n", retry);
if (probe)
tc3xxk_reset_probe(data);
else
tc3xxk_reset(data);
buf = i2c_smbus_read_byte_data(client, TC300K_MDVER);
if (buf > 0)
break;
}
if (retry <= 0) {
SENSOR_ERR("read fail\n");
data->md_ver = 0;
return -1;
}
}
data->md_ver = (u8)buf;
SENSOR_INFO( "md_ver : 0x%x\n", data->md_ver);
return 0;
}
static void tc3xxk_gpio_request(struct tc3xxk_data *data)
{
int ret = 0;
SENSOR_INFO("\n");
if (!data->pdata->i2c_gpio) {
ret = gpio_request(data->pdata->gpio_scl, "grip_scl");
if (ret) {
SENSOR_ERR("unable to request grip_scl [%d]\n",
data->pdata->gpio_scl);
}
ret = gpio_request(data->pdata->gpio_sda, "grip_sda");
if (ret) {
SENSOR_ERR("unable to request grip_sda [%d]\n",
data->pdata->gpio_sda);
}
}
ret = gpio_request(data->pdata->gpio_int, "grip_irq");
if (ret) {
SENSOR_ERR("unable to request grip_irq [%d]\n",
data->pdata->gpio_int);
}
}
static int tc3xxk_parse_dt(struct device *dev,
struct tc3xxk_platform_data *pdata)
{
struct device_node *np = dev->of_node;
int ret;
enum of_gpio_flags flags;
of_property_read_u32(np, "coreriver,use_bitmap", &pdata->use_bitmap);
SENSOR_INFO("%s protocol.\n",
pdata->use_bitmap ? "Use Bit-map" : "Use OLD");
pdata->gpio_scl = of_get_named_gpio_flags(np, "coreriver,scl-gpio", 0, &pdata->scl_gpio_flags);
pdata->gpio_sda = of_get_named_gpio_flags(np, "coreriver,sda-gpio", 0, &pdata->sda_gpio_flags);
pdata->gpio_int = of_get_named_gpio_flags(np, "coreriver,irq-gpio", 0, &pdata->irq_gpio_flags);
pdata->ldo_en = of_get_named_gpio_flags(np, "coreriver,ldo_en", 0, &flags);
if (pdata->ldo_en < 0) {
SENSOR_ERR("fail to get ldo_en\n");
pdata->ldo_en = 0;
if (of_property_read_string(np, "coreriver,regulator_ic", &pdata->regulator_ic)) {
SENSOR_ERR("Failed to get regulator_ic name property\n");
return -EINVAL;
}
regulator_ic = pdata->regulator_ic;
} else {
ret = gpio_request(pdata->ldo_en, "grip_ldo_en");
if (ret < 0) {
SENSOR_ERR("gpio %d request failed %d\n", pdata->ldo_en, ret);
return ret;
}
gpio_direction_output(pdata->ldo_en, 0);
}
pdata->boot_on_ldo = of_property_read_bool(np, "coreriver,boot-on-ldo");
pdata->i2c_gpio = of_property_read_bool(np, "coreriver,i2c-gpio");
if (of_property_read_string(np, "coreriver,fw_name", &pdata->fw_name)) {
SENSOR_ERR("Failed to get fw_name property\n");
return -EINVAL;
} else {
SENSOR_INFO("fw_name %s\n", pdata->fw_name);
}
pdata->bringup = of_property_read_bool(np, "coreriver,bringup");
if (pdata->bringup < 0)
pdata->bringup = 0;
SENSOR_INFO("grip_int:%d, ldo_en:%d\n", pdata->gpio_int, pdata->ldo_en);
return 0;
}
int tc3xxk_grip_power(void *info, bool on)
{
struct tc3xxk_data *data = (struct tc3xxk_data *)info;
struct regulator *regulator;
int ret = 0;
if (tc3xxk_power_enabled == on)
return 0;
SENSOR_INFO("%s\n", on ? "on" : "off");
/* ldo control*/
if (data->pdata->ldo_en) {
gpio_set_value(data->pdata->ldo_en, on);
SENSOR_INFO("ldo_en power %d\n", on);
tc3xxk_power_enabled = on;
return 0;
}
/*regulator control*/
regulator = regulator_get(NULL, regulator_ic);
if (IS_ERR(regulator)){
SENSOR_ERR("regulator_ic get failed\n");
return -EIO;
}
if (on) {
ret = regulator_enable(regulator);
if (ret) {
SENSOR_ERR("regulator_ic enable failed\n");
return ret;
}
} else {
if (regulator_is_enabled(regulator)){
regulator_disable(regulator);
if (ret) {
SENSOR_ERR("regulator_ic disable failed\n");
return ret;
}
}
else
regulator_force_disable(regulator);
}
regulator_put(regulator);
tc3xxk_power_enabled = on;
return 0;
}
static irqreturn_t tc3xxk_interrupt(int irq, void *dev_id)
{
struct tc3xxk_data *data = dev_id;
struct i2c_client *client = data->client;
int ret, retry;
int i = 0;
u8 grip_val;
bool grip_handle_flag;
wake_lock(&data->grip_wake_lock);
SENSOR_INFO("\n");
if ((!data->enabled) || data->fw_downloading) {
SENSOR_ERR("can't excute\n");
wake_unlock(&data->grip_wake_lock);
return IRQ_HANDLED;
}
ret = tc3xxk_wake_up(client, TC300K_CMD_WAKE_UP);
ret = i2c_smbus_read_byte_data(client, TC305K_GRIPCODE);
if (ret < 0) {
retry = 3;
while (retry--) {
SENSOR_ERR("read fail ret=%d(retry:%d)\n", ret, retry);
msleep(10);
ret = i2c_smbus_read_byte_data(client, TC305K_GRIPCODE);
if (ret > 0)
break;
}
if (retry <= 0) {
tc3xxk_reset(data);
wake_unlock(&data->grip_wake_lock);
return IRQ_HANDLED;
}
}
grip_val = (u8)ret;
for (i = 0 ; i < data->grip_num * 2 ; i++){ //use 2 grip chanel
if (data->pdata->use_bitmap)
grip_handle_flag = (grip_val & data->grip_ev_val[i].grip_bitmap);
else
grip_handle_flag = (grip_val == data->grip_ev_val[i].grip_bitmap);
if (grip_handle_flag){
if(data->grip_ev_val[i].grip_status == ACTIVE){
data->grip_event = ACTIVE;
input_report_rel(data->input_dev, REL_MISC, 1);
}
else{
data->grip_event = IDLE;
input_report_rel(data->input_dev, REL_MISC, 2);
}
SENSOR_INFO(
"grip %s : %s(0x%02X) ver0x%02x\n",
data->grip_ev_val[i].grip_status? "P" : "R",
data->grip_ev_val[i].grip_name, grip_val,
data->fw_ver);
#ifdef CONFIG_SEC_FACTORY
data->diff = read_tc3xxk_register_data(data, TC305K_1GRIP, TC305K_GRIP_DIFF_DATA);
if (data->abnormal_mode) {
if (data->grip_event) {
if (data->max_diff < data->diff)
data->max_diff = data->diff;
data->irq_count++;
}
}
#endif
}
}
input_sync(data->input_dev);
wake_unlock(&data->grip_wake_lock);
return IRQ_HANDLED;
}
static int load_fw_in_kernel(struct tc3xxk_data *data)
{
struct i2c_client *client = data->client;
int ret;
ret = request_firmware(&data->fw, data->pdata->fw_name, &client->dev);
if (ret) {
SENSOR_ERR("fail(%d)\n", ret);
return -1;
}
data->fw_img = (struct fw_image *)data->fw->data;
SENSOR_INFO( "0x%x 0x%x firm (size=%d)\n",
data->fw_img->first_fw_ver, data->fw_img->second_fw_ver, data->fw_img->fw_len);
SENSOR_INFO("done\n");
return 0;
}
static int load_fw_sdcard(struct tc3xxk_data *data)
{
struct file *fp;
mm_segment_t old_fs;
long fsize, nread;
int ret = 0;
old_fs = get_fs();
set_fs(get_ds());
fp = filp_open(TC300K_FW_PATH_SDCARD, O_RDONLY, S_IRUSR);
if (IS_ERR(fp)) {
SENSOR_ERR("%s open error\n", TC300K_FW_PATH_SDCARD);
ret = -ENOENT;
goto fail_sdcard_open;
}
fsize = fp->f_path.dentry->d_inode->i_size;
data->fw_img = kzalloc((size_t)fsize, GFP_KERNEL);
if (!data->fw_img) {
SENSOR_ERR("fail to kzalloc for fw\n");
filp_close(fp, current->files);
ret = -ENOMEM;
goto fail_sdcard_kzalloc;
}
nread = vfs_read(fp, (char __user *)data->fw_img, fsize, &fp->f_pos);
if (nread != fsize) {
SENSOR_ERR("fail to vfs_read file\n");
ret = -EINVAL;
goto fail_sdcard_size;
}
filp_close(fp, current->files);
set_fs(old_fs);
SENSOR_INFO("fw_size : %lu\n", nread);
SENSOR_INFO("done\n");
return ret;
fail_sdcard_size:
kfree(&data->fw_img);
fail_sdcard_kzalloc:
filp_close(fp, current->files);
fail_sdcard_open:
set_fs(old_fs);
return ret;
}
static inline void setsda(struct tc3xxk_data *data, int state)
{
if (state)
gpio_direction_output(data->pdata->gpio_sda, 1);
else
gpio_direction_output(data->pdata->gpio_sda, 0);
}
static inline void setscl(struct tc3xxk_data *data, int state)
{
if (state)
gpio_direction_output(data->pdata->gpio_scl, 1);
else
gpio_direction_output(data->pdata->gpio_scl, 0);
}
static inline int getsda(struct tc3xxk_data *data)
{
return gpio_get_value(data->pdata->gpio_sda);
}
static inline int getscl(struct tc3xxk_data *data)
{
return gpio_get_value(data->pdata->gpio_scl);
}
static void send_9bit(struct tc3xxk_data *data, u8 buff)
{
int i;
setscl(data, 1);
ndelay(20);
setsda(data, 0);
ndelay(20);
setscl(data, 0);
ndelay(20);
for (i = 0; i < 8; i++) {
setscl(data, 1);
ndelay(20);
setsda(data, (buff >> i) & 0x01);
ndelay(20);
setscl(data, 0);
ndelay(20);
}
setsda(data, 0);
}
static u8 wait_9bit(struct tc3xxk_data *data)
{
int i;
int buf;
u8 send_buf = 0;
gpio_direction_input(data->pdata->gpio_sda);
getsda(data);
ndelay(10);
setscl(data, 1);
ndelay(40);
setscl(data, 0);
ndelay(20);
for (i = 0; i < 8; i++) {
setscl(data, 1);
ndelay(20);
buf = getsda(data);
ndelay(20);
setscl(data, 0);
ndelay(20);
send_buf |= (buf & 0x01) << i;
}
setsda(data, 0);
return send_buf;
}
static void tc3xxk_reset_for_isp(struct tc3xxk_data *data, bool start)
{
if (start) {
setscl(data, 0);
setsda(data, 0);
data->pdata->power(data, false);
msleep(100);
data->pdata->power(data, true);
usleep_range(5000, 6000);
} else {
data->pdata->power(data, false);
msleep(100);
data->pdata->power(data, true);
msleep(120);
gpio_direction_input(data->pdata->gpio_sda);
gpio_direction_input(data->pdata->gpio_scl);
}
}
static void load(struct tc3xxk_data *data, u8 buff)
{
send_9bit(data, TC300K_LDDATA);
udelay(1);
send_9bit(data, buff);
udelay(1);
}
static void step(struct tc3xxk_data *data, u8 buff)
{
send_9bit(data, TC300K_CCFG);
udelay(1);
send_9bit(data, buff);
udelay(2);
}
static void setpc(struct tc3xxk_data *data, u16 addr)
{
u8 buf[4];
int i;
buf[0] = 0x02;
buf[1] = addr >> 8;
buf[2] = addr & 0xff;
buf[3] = 0x00;
for (i = 0; i < 4; i++)
step(data, buf[i]);
}
static void configure_isp(struct tc3xxk_data *data)
{
u8 buf[7];
int i;
buf[0] = 0x75; buf[1] = 0xFC; buf[2] = 0xAC;
buf[3] = 0x75; buf[4] = 0xFC; buf[5] = 0x35;
buf[6] = 0x00;
/* Step(cmd) */
for (i = 0; i < 7; i++)
step(data, buf[i]);
}
static int tc3xxk_erase_fw(struct tc3xxk_data *data)
{
int i;
u8 state = 0;
tc3xxk_reset_for_isp(data, true);
/* isp_enable_condition */
send_9bit(data, TC300K_CSYNC1);
udelay(9);
send_9bit(data, TC300K_CSYNC2);
udelay(9);
send_9bit(data, TC300K_CSYNC3);
usleep_range(150, 160);
state = wait_9bit(data);
if (state != 0x01) {
SENSOR_ERR("isp enable error %d\n", state);
return -1;
}
configure_isp(data);
/* Full Chip Erase */
send_9bit(data, TC300K_PCRST);
udelay(1);
send_9bit(data, TC300K_PECHIP);
usleep_range(15000, 15500);
state = 0;
for (i = 0; i < 100; i++) {
udelay(2);
send_9bit(data, TC300K_CSYNC3);
udelay(1);
state = wait_9bit(data);
if ((state & 0x04) == 0x00)
break;
}
if (i == 100) {
SENSOR_ERR("fail\n");
return -1;
}
SENSOR_INFO("success\n");
return 0;
}
static int tc3xxk_write_fw(struct tc3xxk_data *data)
{
u16 addr = 0;
u8 code_data;
setpc(data, addr);
load(data, TC300K_PWDATA);
send_9bit(data, TC300K_LDMODE);
udelay(1);
while (addr < data->fw_img->fw_len) {
code_data = data->fw_img->data[addr++];
load(data, code_data);
usleep_range(20, 21);
}
send_9bit(data, TC300K_PEDISC);
udelay(1);
return 0;
}
static int tc3xxk_verify_fw(struct tc3xxk_data *data)
{
u16 addr = 0;
u8 code_data;
setpc(data, addr);
SENSOR_INFO( "fw code size = %#x (%u)",
data->fw_img->fw_len, data->fw_img->fw_len);
while (addr < data->fw_img->fw_len) {
if ((addr % 0x40) == 0)
SENSOR_INFO("fw verify addr = %#x\n", addr);
send_9bit(data, TC300K_PRDATA);
udelay(2);
code_data = wait_9bit(data);
udelay(1);
if (code_data != data->fw_img->data[addr++]) {
SENSOR_ERR("addr : %#x data error (0x%2x)\n",
addr - 1, code_data );
return -1;
}
}
SENSOR_INFO("success\n");
return 0;
}
static void t300k_release_fw(struct tc3xxk_data *data, u8 fw_path)
{
if (fw_path == FW_INKERNEL)
release_firmware(data->fw);
else if (fw_path == FW_SDCARD)
kfree(data->fw_img);
}
static int tc3xxk_flash_fw(struct tc3xxk_data *data, u8 fw_path)
{
int retry = 5;
int ret;
tc3xxk_config_gpio_i2c(data, 0);
do {
ret = tc3xxk_erase_fw(data);
if (ret)
SENSOR_ERR("erase fail(retry=%d)\n", retry);
else
break;
} while (retry-- > 0);
if (retry < 0)
goto err_tc3xxk_flash_fw;
retry = 5;
do {
tc3xxk_write_fw(data);
ret = tc3xxk_verify_fw(data);
if (ret)
SENSOR_ERR("verify fail(retry=%d)\n", retry);
else
break;
} while (retry-- > 0);
tc3xxk_reset_for_isp(data, false);
tc3xxk_config_gpio_i2c(data, 1);
if (retry < 0)
goto err_tc3xxk_flash_fw;
return 0;
err_tc3xxk_flash_fw:
return -1;
}
static int tc3xxk_crc_check(struct tc3xxk_data *data)
{
struct i2c_client *client = data->client;
int ret;
u8 cmd;
u8 checksum_h, checksum_l;
if ((!data->enabled) || data->fw_downloading) {
SENSOR_ERR("can't excute\n");
return -1;
}
cmd = TC300K_CMD_CAL_CHECKSUM;
ret = i2c_smbus_write_byte_data(client, TC300K_CMD_ADDR, cmd);
if (ret) {
SENSOR_ERR("command fail (%d)\n", ret);
return ret;
}
msleep(TC300K_CHECKSUM_DELAY);
ret = i2c_smbus_read_byte_data(client, TC300K_CHECKS_H);
if (ret < 0) {
SENSOR_ERR("failed to read checksum_h (%d)\n", ret);
return ret;
}
checksum_h = ret;
ret = i2c_smbus_read_byte_data(client, TC300K_CHECKS_L);
if (ret < 0) {
SENSOR_ERR("failed to read checksum_l (%d)\n", ret);
return ret;
}
checksum_l = ret;
data->checksum = (checksum_h << 8) | checksum_l;
if (data->fw_img->checksum != data->checksum) {
SENSOR_ERR("checksum fail - firm checksum(%d), compute checksum(%d)\n",
data->fw_img->checksum, data->checksum);
return -1;
}
SENSOR_INFO("success (%d)\n", data->checksum);
return 0;
}
static int tc3xxk_fw_update(struct tc3xxk_data *data, u8 fw_path, bool force)
{
int retry = 4;
int ret;
if (fw_path == FW_INKERNEL) {
ret = load_fw_in_kernel(data);
if (ret)
return -1;
data->fw_ver_bin = data->fw_img->first_fw_ver;
data->md_ver_bin = data->fw_img->second_fw_ver;
/* read model ver */
ret = tc3xxk_get_md_version(data, false);
if (ret) {
SENSOR_ERR("get md version fail\n");
force = 1;
}
if (data->md_ver != data->md_ver_bin) {
SENSOR_INFO( "fw model number = %x ic model number = %x \n", data->md_ver_bin, data->md_ver);
force = 1;
}
if (!force && (data->fw_ver >= data->fw_ver_bin)) {
SENSOR_INFO( "do not need firm update (IC:0x%x, BIN:0x%x)(MD IC:0x%x, BIN:0x%x)\n",
data->fw_ver, data->fw_ver_bin, data->md_ver, data->md_ver_bin);
t300k_release_fw(data, fw_path);
return 0;
}
} else if (fw_path == FW_SDCARD) {
ret = load_fw_sdcard(data);
if (ret)
return -1;
}
while (retry--) {
data->fw_downloading = true;
ret = tc3xxk_flash_fw(data, fw_path);
data->fw_downloading = false;
if (ret) {
SENSOR_ERR("tc3xxk_flash_fw fail (%d)\n", retry);
continue;
}
ret = tc3xxk_get_fw_version(data, false);
if (ret) {
SENSOR_ERR("tc3xxk_get_fw_version fail (%d)\n", retry);
continue;
}
if (data->fw_ver != data->fw_img->first_fw_ver) {
SENSOR_ERR("fw version fail (0x%x, 0x%x)(%d)\n",
data->fw_ver, data->fw_img->first_fw_ver, retry);
continue;
}
ret = tc3xxk_get_md_version(data, false);
if (ret) {
SENSOR_ERR("tc3xxk_get_md_version fail (%d)\n", retry);
continue;
}
if (data->md_ver != data->fw_img->second_fw_ver) {
SENSOR_ERR("md version fail (0x%x, 0x%x)(%d)\n",
data->md_ver, data->fw_img->second_fw_ver, retry);
continue;
}
ret = tc3xxk_crc_check(data);
if (ret) {
SENSOR_ERR("crc check fail (%d)\n", retry);
continue;
}
break;
}
if (retry > 0)
SENSOR_INFO("success\n");
t300k_release_fw(data, fw_path);
return ret;
}
/*
* Fw update by parameters:
* s | S = TSK FW from kernel binary and compare fw version.
* i | I = TSK FW from SD Card and Not compare fw version.
* f | F = TSK FW from kernel binary and Not compare fw version.
*/
static ssize_t tc3xxk_update_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
int ret;
u8 fw_path;
bool fw_update_force = false;
switch(*buf) {
case 's':
case 'S':
fw_path = FW_INKERNEL;
fw_update_force = true;
break;
case 'i':
case 'I':
fw_path = FW_SDCARD;
break;
case 'f':
case 'F':
fw_path = FW_INKERNEL;
fw_update_force = true;
break;
default:
SENSOR_ERR("wrong command fail\n");
data->fw_update_status = TK_UPDATE_FAIL;
return count;
}
data->fw_update_status = TK_UPDATE_DOWN;
if (data->irq_check) {
data->irq_check = false;
disable_irq_wake(client->irq);
disable_irq(client->irq);
}
ret = tc3xxk_fw_update(data, fw_path, fw_update_force);
if (!data->irq_check) {
data->irq_check = true;
enable_irq(client->irq);
enable_irq_wake(client->irq);
}
if (ret < 0) {
SENSOR_ERR("fail\n");
data->fw_update_status = TK_UPDATE_FAIL;
} else
data->fw_update_status = TK_UPDATE_PASS;
return count;
}
static ssize_t tc3xxk_firm_status_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
if (data->fw_update_status == TK_UPDATE_PASS)
ret = sprintf(buf, "PASS\n");
else if (data->fw_update_status == TK_UPDATE_DOWN)
ret = sprintf(buf, "DOWNLOADING\n");
else if (data->fw_update_status == TK_UPDATE_FAIL)
ret = sprintf(buf, "FAIL\n");
else
ret = sprintf(buf, "NG\n");
return ret;
}
static ssize_t tc3xxk_firm_version_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
return sprintf(buf, "0x%02x%02x\n", data->md_ver_bin, data->fw_ver_bin);
}
static ssize_t tc3xxk_md_version_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
return sprintf(buf, "0x%02x\n", data->md_ver_bin);
}
static ssize_t tc3xxk_firm_version_read_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
ret = tc3xxk_get_fw_version(data, false);
if (ret < 0)
SENSOR_ERR("failed to read firmware version (%d)\n", ret);
ret = tc3xxk_get_md_version(data, false);
if (ret < 0)
SENSOR_ERR("failed to read md version (%d)\n", ret);
return sprintf(buf, "0x%02x%02x\n", data->md_ver, data->fw_ver);
}
static ssize_t tc3xxk_md_version_read_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
ret = tc3xxk_get_md_version(data, false);
if (ret < 0)
SENSOR_ERR("failed to read md version (%d)\n", ret);
return sprintf(buf, "0x%02x\n", data->md_ver);
}
static int read_tc3xxk_register_data(struct tc3xxk_data *data, int read_key_num, int read_offset)
{
struct i2c_client *client = data->client;
int ret;
u8 buff[2];
int value;
mutex_lock(&data->lock_fac);
ret = i2c_smbus_read_i2c_block_data(client, read_key_num + read_offset, TC350K_DATA_SIZE, buff);
if (ret != TC350K_DATA_SIZE) {
SENSOR_ERR("read fail(%d)\n", ret);
value = 0;
goto exit;
}
value = (buff[TC350K_DATA_H_OFFSET] << 8) | buff[TC350K_DATA_L_OFFSET];
mutex_unlock(&data->lock_fac);
SENSOR_INFO("read key num/offset = [0x%X/0x%X], value : [%d]\n",
read_key_num, read_offset, value);
exit:
return value;
}
static int tc3xxk_mode_enable(struct i2c_client *client, u8 cmd)
{
int ret;
ret = i2c_smbus_write_byte_data(client, TC300K_CMD_ADDR, cmd);
msleep(15);
return ret;
}
static ssize_t tc3xxk_sar_enable_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%u\n", !data->sar_enable_off);
}
static ssize_t tc3xxk_sar_enable_store(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t count)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
int buff;
int ret;
bool on;
int cmd;
ret = sscanf(buf, "%d", &buff);
if (ret != 1) {
SENSOR_ERR("cmd read err\n");
return count;
}
SENSOR_INFO(" (%d) \n", buff);
if (!(buff >= 0 && buff <= 3)) {
SENSOR_ERR("wrong command(%d)\n", buff);
return count;
}
/* sar enable param
* 0 off
* 1 on
* 2 force off
* 3 force off -> on
*/
if (data->sar_enable && buff == 1) {
SENSOR_INFO("Grip sensor already ON\n");
return count;
} else if (!data->sar_enable && buff == 0) {
SENSOR_INFO("Grip sensor already OFF\n");
return count;
}
if (buff == 3) {
data->sar_enable_off = 0;
SENSOR_INFO("Power back off _ force off -> on (%d)\n",
data->sar_enable);
if (!data->sar_enable)
buff = 1;
else
return count;
}
if (data->sar_enable_off) {
if (buff == 1)
data->sar_enable = true;
else
data->sar_enable = false;
SENSOR_INFO("skip, Power back off _ force off mode (%d)\n",
data->sar_enable);
return count;
}
if (buff == 1) {
on = true;
if (!data->irq_check) {
data->irq_check = true;
enable_irq(client->irq);
enable_irq_wake(client->irq);
}
cmd = TC300K_CMD_SAR_ENABLE;
} else if (buff == 2) {
on = false;
data->sar_enable_off = 1;
if (data->irq_check) {
data->irq_check = false;
disable_irq_wake(client->irq);
disable_irq(client->irq);
}
cmd = TC300K_CMD_SAR_DISABLE;
} else {
on = false;
if (data->irq_check) {
data->irq_check = false;
disable_irq_wake(client->irq);
disable_irq(client->irq);
}
cmd = TC300K_CMD_SAR_DISABLE;
}
ret = tc3xxk_wake_up(data->client, TC300K_CMD_WAKE_UP);
ret = tc3xxk_mode_enable(data->client, cmd);
if (ret < 0) {
SENSOR_ERR("fail(%d)\n", ret);
return count;
}
if (buff == 1) {
data->sar_enable = true;
} else {
input_report_rel(data->input_dev, REL_MISC, 2);
input_sync(data->input_dev);
data->grip_event = 0;
data->sar_enable = false;
}
SENSOR_INFO("data:%d on:%d\n", buff, on);
return count;
}
static ssize_t tc3xxk_grip1_threshold_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
ret = read_tc3xxk_register_data(data, TC305K_1GRIP, TC305K_GRIP_THD_PRESS);
if (ret < 0) {
SENSOR_ERR("fail to read press thd(%d)\n", ret);
data->grip_p_thd = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_p_thd = ret;
ret = read_tc3xxk_register_data(data, TC305K_1GRIP, TC305K_GRIP_THD_RELEASE);
if (ret < 0) {
SENSOR_ERR("fail to read release thd(%d)\n", ret);
data->grip_r_thd = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_r_thd = ret;
ret = read_tc3xxk_register_data(data, TC305K_1GRIP, TC305K_GRIP_THD_NOISE);
if (ret < 0) {
SENSOR_ERR("fail to read noise thd(%d)\n", ret);
data->grip_n_thd = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_n_thd = ret;
return sprintf(buf, "%d,%d,%d\n",
data->grip_p_thd, data->grip_r_thd, data->grip_n_thd );
}
static ssize_t tc3xxk_grip2_threshold_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
ret = read_tc3xxk_register_data(data, TC305K_2GRIP, TC305K_GRIP_THD_PRESS);
if (ret < 0) {
SENSOR_ERR("fail to read press thd(%d)\n", ret);
data->grip_p_thd = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_p_thd = ret;
ret = read_tc3xxk_register_data(data, TC305K_2GRIP, TC305K_GRIP_THD_RELEASE);
if (ret < 0) {
SENSOR_ERR("fail to read release thd(%d)\n", ret);
data->grip_r_thd = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_r_thd = ret;
ret = read_tc3xxk_register_data(data, TC305K_2GRIP, TC305K_GRIP_THD_NOISE);
if (ret < 0) {
SENSOR_ERR("fail to read noise thd(%d)\n", ret);
data->grip_n_thd = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_n_thd = ret;
return sprintf(buf, "%d,%d,%d\n",
data->grip_p_thd, data->grip_r_thd, data->grip_n_thd );
}
static ssize_t tc3xxk_total_cap1_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
int ret;
ret = i2c_smbus_read_byte_data(client, TC305K_1GRIP + TC305K_GRIP_TOTAL_CAP);
if (ret < 0) {
SENSOR_ERR("fail(%d)\n", ret);
return sprintf(buf, "%d\n", 0);
}
return sprintf(buf, "%d\n", ret);
}
static ssize_t tc3xxk_total_cap2_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
int ret;
ret = i2c_smbus_read_byte_data(client, TC305K_2GRIP + TC305K_GRIP_TOTAL_CAP);
if (ret < 0) {
SENSOR_ERR("fail(%d)\n", ret);
return sprintf(buf, "%d\n", 0);
}
return sprintf(buf, "%d\n", ret);
}
static ssize_t grip_ref_cap_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
int ret;
ret = i2c_smbus_read_byte_data(client, TC305K_GRIP_REF_CAP);
if (ret < 0) {
SENSOR_ERR("fail(%d)\n", ret);
return sprintf(buf, "%d\n", 0);
}
return sprintf(buf, "%d\n", ret);
}
static ssize_t tc3xxk_grip1_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
ret = read_tc3xxk_register_data(data, TC305K_1GRIP, TC305K_GRIP_DIFF_DATA);
if (ret < 0) {
SENSOR_ERR("fail(%d)\n", ret);
data->grip_s1 = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_s1 = ret;
return sprintf(buf, "%d\n", data->grip_s1);
}
static ssize_t tc3xxk_grip2_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
ret = read_tc3xxk_register_data(data, TC305K_2GRIP, TC305K_GRIP_DIFF_DATA);
if (ret < 0) {
SENSOR_ERR("fail(%d)\n", ret);
data->grip_s1 = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_s1 = ret;
return sprintf(buf, "%d\n", data->grip_s1);
}
static ssize_t tc3xxk_grip1_baseline_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
ret = read_tc3xxk_register_data(data, TC305K_1GRIP, TC305K_GRIP_BASELINE);
if (ret < 0) {
SENSOR_ERR("fail(%d)\n", ret);
data->grip_baseline = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_baseline = ret;
return sprintf(buf, "%d\n", data->grip_baseline);
}
static ssize_t tc3xxk_grip2_baseline_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
ret = read_tc3xxk_register_data(data, TC305K_2GRIP, TC305K_GRIP_BASELINE);
if (ret < 0) {
SENSOR_ERR("fail(%d)\n", ret);
data->grip_baseline = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_baseline = ret;
return sprintf(buf, "%d\n", data->grip_baseline);
}
static ssize_t tc3xxk_grip1_raw_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
ret = read_tc3xxk_register_data(data, TC305K_1GRIP, TC305K_GRIP_RAW_DATA);
if (ret < 0) {
SENSOR_ERR("fail(%d)\n", ret);
data->grip_raw1 = 0;
data->grip_raw2 = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_raw1 = ret;
data->grip_raw2 = 0;
return sprintf(buf, "%d,%d\n", data->grip_raw1, data->grip_raw2);
}
static ssize_t tc3xxk_grip2_raw_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
ret = read_tc3xxk_register_data(data, TC305K_2GRIP, TC305K_GRIP_RAW_DATA);
if (ret < 0) {
SENSOR_ERR("fail(%d)\n", ret);
data->grip_raw1 = 0;
data->grip_raw2 = 0;
return sprintf(buf, "%d\n", 0);
}
data->grip_raw1 = ret;
data->grip_raw2 = 0;
return sprintf(buf, "%d,%d\n", data->grip_raw1, data->grip_raw2);
}
static ssize_t tc3xxk_grip_gain_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
return sprintf(buf, "%d,%d,%d,%d\n", 0, 0, 0, 0);
}
static ssize_t tc3xxk_grip_check_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
SENSOR_ERR("event:%d\n", data->grip_event);
return sprintf(buf, "%d\n", data->grip_event);
}
static ssize_t tc3xxk_grip_sw_reset(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t count)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int buff;
int ret;
ret = sscanf(buf, "%d", &buff);
if (ret != 1) {
SENSOR_ERR("cmd read err\n");
return count;
}
if (!(buff == 1)) {
SENSOR_ERR("wrong command(%d)\n", buff);
return count;
}
data->grip_event = 0;
SENSOR_INFO("data(%d)\n", buff);
tc3xxk_grip_cal_reset(data);
return count;
}
static ssize_t grip_sensing_change(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t count)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret, buff;
ret = sscanf(buf, "%d", &buff);
if (ret != 1) {
SENSOR_ERR("cmd read err\n");
return count;
}
if (!(buff == 0 || buff == 1)) {
SENSOR_ERR("wrong command(%d)\n", buff);
return count;
}
grip_sar_sensing(data, buff);
SENSOR_INFO("earjack (%d)\n", buff);
return count;
}
#ifdef CONFIG_SEC_FACTORY
static ssize_t tc3xxk_grip_irq_count_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int result = 0;
if (data->irq_count)
result = -1;
SENSOR_INFO("\n");
return snprintf(buf, PAGE_SIZE, "%d,%d,%d\n",
result, data->irq_count, data->max_diff);
}
static ssize_t tc3xxk_grip_irq_count_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
u8 onoff;
int ret;
ret = kstrtou8(buf, 10, &onoff);
if (ret < 0) {
SENSOR_ERR("kstrtou8 failed.(%d)\n", ret);
return count;
}
mutex_lock(&data->lock_fac);
if (onoff == 0) {
data->abnormal_mode = 0;
} else if (onoff == 1) {
data->abnormal_mode = 1;
data->irq_count = 0;
data->max_diff = 0;
} else {
SENSOR_ERR("unknown value %d\n", onoff);
}
mutex_unlock(&data->lock_fac);
SENSOR_INFO("%d\n", onoff);
return count;
}
#endif //#ifdef CONFIG_SEC_FACTORY
static ssize_t grip_chip_name(struct device *dev,
struct device_attribute *attr, char *buf)
{
return sprintf(buf, "%s\n", MODEL_NAME);
}
static ssize_t grip_vendor_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
return sprintf(buf, "%s\n", VENDOR_NAME);
}
static ssize_t grip_crc_check_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
int ret;
ret = tc3xxk_crc_check(data);
return sprintf(buf, (ret == 0) ? "OK,%x\n" : "NG,%x\n", data->checksum);
}
static ssize_t tc3xxk_enable_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc3xxk_data *data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d\n", data->sar_enable);
}
static DEVICE_ATTR(grip_firm_update, 0220, NULL, tc3xxk_update_store);
static DEVICE_ATTR(grip_firm_update_status, 0444, tc3xxk_firm_status_show, NULL);
static DEVICE_ATTR(grip_firm_version_phone, 0444, tc3xxk_firm_version_show, NULL);
static DEVICE_ATTR(grip_firm_version_panel, 0444, tc3xxk_firm_version_read_show, NULL);
static DEVICE_ATTR(grip_md_version_phone, 0444, tc3xxk_md_version_show, NULL);
static DEVICE_ATTR(grip_md_version_panel, 0444, tc3xxk_md_version_read_show, NULL);
static DEVICE_ATTR(grip_threshold, 0444, tc3xxk_grip1_threshold_show, NULL);
static DEVICE_ATTR(grip2ch_threshold, 0444, tc3xxk_grip2_threshold_show, NULL);
static DEVICE_ATTR(grip_total_cap, 0444, tc3xxk_total_cap1_show, NULL);
static DEVICE_ATTR(grip_total_cap2ch, 0444, tc3xxk_total_cap2_show, NULL);
static DEVICE_ATTR(grip_sar_enable, 0664, tc3xxk_sar_enable_show, tc3xxk_sar_enable_store);
static DEVICE_ATTR(grip_sw_reset, 0220, NULL, tc3xxk_grip_sw_reset);
static DEVICE_ATTR(grip_earjack, 0220, NULL, grip_sensing_change);
static DEVICE_ATTR(grip, 0444, tc3xxk_grip1_show, NULL);
static DEVICE_ATTR(grip2ch, 0444, tc3xxk_grip2_show, NULL);
static DEVICE_ATTR(grip_baseline, 0444, tc3xxk_grip1_baseline_show, NULL);
static DEVICE_ATTR(grip2ch_baseline, 0444, tc3xxk_grip2_baseline_show, NULL);
static DEVICE_ATTR(grip_raw, 0444, tc3xxk_grip1_raw_show, NULL);
static DEVICE_ATTR(grip2ch_raw, 0444, tc3xxk_grip2_raw_show, NULL);
static DEVICE_ATTR(grip_gain, 0444, tc3xxk_grip_gain_show, NULL);
static DEVICE_ATTR(grip_check, 0444, tc3xxk_grip_check_show, NULL);
#ifdef CONFIG_SEC_FACTORY
static DEVICE_ATTR(grip_irq_count, 0664, tc3xxk_grip_irq_count_show, tc3xxk_grip_irq_count_store);
#endif
static DEVICE_ATTR(grip_ref_cap, 0444, grip_ref_cap_show, NULL);
static DEVICE_ATTR(name, 0444, grip_chip_name, NULL);
static DEVICE_ATTR(vendor, 0444, grip_vendor_show, NULL);
static DEVICE_ATTR(grip_crc_check, 0444, grip_crc_check_show, NULL);
static struct device_attribute *sec_grip_attributes[] = {
&dev_attr_grip_firm_update,
&dev_attr_grip_firm_update_status,
&dev_attr_grip_firm_version_phone,
&dev_attr_grip_firm_version_panel,
&dev_attr_grip_md_version_phone,
&dev_attr_grip_md_version_panel,
&dev_attr_grip_threshold,
&dev_attr_grip2ch_threshold,
&dev_attr_grip_total_cap,
&dev_attr_grip_total_cap2ch,
&dev_attr_grip_sar_enable,
&dev_attr_grip_sw_reset,
&dev_attr_grip_earjack,
&dev_attr_grip,
&dev_attr_grip2ch,
&dev_attr_grip_baseline,
&dev_attr_grip2ch_baseline,
&dev_attr_grip_raw,
&dev_attr_grip2ch_raw,
&dev_attr_grip_gain,
&dev_attr_grip_check,
#ifdef CONFIG_SEC_FACTORY
&dev_attr_grip_irq_count,
#endif
&dev_attr_grip_ref_cap,
&dev_attr_name,
&dev_attr_vendor,
&dev_attr_grip_crc_check,
NULL,
};
static DEVICE_ATTR(enable, 0664, tc3xxk_enable_show, tc3xxk_sar_enable_store);
static struct attribute *tc3xxk_attributes[] = {
&dev_attr_enable.attr,
NULL
};
static struct attribute_group tc3xxk_attribute_group = {
.attrs = tc3xxk_attributes
};
#if defined (CONFIG_VBUS_NOTIFIER)
static int tc3xxk_vbus_notification(struct notifier_block *nb,
unsigned long cmd, void *data)
{
struct tc3xxk_data *tkey_data = container_of(nb, struct tc3xxk_data, vbus_nb);
struct i2c_client *client = tkey_data->client;
vbus_status_t vbus_type = *(vbus_status_t *)data;
int ret;
SENSOR_INFO("cmd=%lu, vbus_type=%d\n", cmd, vbus_type);
switch (vbus_type) {
case STATUS_VBUS_HIGH:
SENSOR_INFO("attach\n");
ret = tc3xxk_wake_up(client, TC300K_CMD_WAKE_UP);
ret = tc3xxk_mode_enable(client, TC300K_CMD_TA_ON);
if (ret < 0)
SENSOR_ERR("TA mode ON fail(%d)\n", ret);
break;
case STATUS_VBUS_LOW:
SENSOR_INFO("detach\n");
ret = tc3xxk_wake_up(client, TC300K_CMD_WAKE_UP);
ret = tc3xxk_mode_enable(client, TC300K_CMD_TA_OFF);
if (ret < 0)
SENSOR_ERR("TA mode OFF fail(%d)\n", ret);
break;
default:
break;
}
return 0;
}
#endif
static int tc3xxk_fw_check(struct tc3xxk_data *data)
{
int ret;
if (data->pdata->bringup) {
SENSOR_INFO("firmware update skip, bring up\n");
return 0;
}
ret = tc3xxk_get_fw_version(data, true);
if (ret < 0) {
SENSOR_ERR("i2c fail...[%d], addr[%d]\n",
ret, data->client->addr);
data->fw_ver = 0xFF;
SENSOR_INFO("firmware is blank or i2c fail, try flash firmware to grip\n");
}
if (data->fw_ver == 0xFF) {
SENSOR_INFO(
"fw version 0xFF, Excute firmware update!\n");
ret = tc3xxk_fw_update(data, FW_INKERNEL, true);
if (ret)
return -1;
} else {
ret = tc3xxk_fw_update(data, FW_INKERNEL, false);
if (ret)
return -1;
}
return 0;
}
static int tc3xxk_pinctrl_init(struct tc3xxk_data *data)
{
struct device *dev = &data->client->dev;
int i;
SENSOR_INFO("\n");
// IRQ
data->pinctrl_irq = devm_pinctrl_get(dev);
if (IS_ERR(data->pinctrl_irq)) {
SENSOR_INFO("Failed to get irq pinctrl\n");
data->pinctrl_irq = NULL;
goto i2c_pinctrl_get;
}
#if 0
for (i = 0; i < 2; ++i) {
data->pin_state[i] = pinctrl_lookup_state(data->pinctrl_irq, str_states[i]);
if (IS_ERR(data->pin_state[i])) {
SENSOR_INFO("Failed to get irq pinctrl state\n");
devm_pinctrl_put(data->pinctrl_irq);
data->pinctrl_irq = NULL;
goto i2c_pinctrl_get;
}
}
#endif
i2c_pinctrl_get:
/* for h/w i2c */
dev = data->client->dev.parent->parent;
SENSOR_INFO("use dev's parent\n");
// I2C
data->pinctrl_i2c = devm_pinctrl_get(dev);
if (IS_ERR(data->pinctrl_i2c)) {
SENSOR_ERR("Failed to get i2c pinctrl\n");
goto err_pinctrl_get_i2c;
}
for (i = 2; i < 4; ++i) {
data->pin_state[i] = pinctrl_lookup_state(data->pinctrl_i2c, str_states[i]);
if (IS_ERR(data->pin_state[i])) {
SENSOR_ERR("Failed to get i2c pinctrl state\n");
goto err_pinctrl_get_state_i2c;
}
}
return 0;
err_pinctrl_get_state_i2c:
devm_pinctrl_put(data->pinctrl_i2c);
err_pinctrl_get_i2c:
return -ENODEV;
}
static int tc3xxk_pinctrl(struct tc3xxk_data *data, int state)
{
struct pinctrl *pinctrl_i2c = data->pinctrl_i2c;
struct pinctrl *pinctrl_irq = data->pinctrl_irq;
int ret=0;
switch (state) {
case I_STATE_ON_IRQ:
case I_STATE_OFF_IRQ:
if (pinctrl_irq)
ret = pinctrl_select_state(pinctrl_irq, data->pin_state[state]);
break;
case I_STATE_ON_I2C:
case I_STATE_OFF_I2C:
if (pinctrl_i2c)
ret = pinctrl_select_state(pinctrl_i2c, data->pin_state[state]);
break;
}
if (ret < 0) {
SENSOR_ERR(
"Failed to configure tc3xxk_pinctrl state[%d]\n", state);
return ret;
}
return 0;
}
static void tc3xxk_config_gpio_i2c(struct tc3xxk_data *data, int onoff)
{
SENSOR_ERR("\n");
tc3xxk_pinctrl(data, onoff ? I_STATE_ON_I2C : I_STATE_OFF_I2C);
mdelay(100);
}
static int tc3xxk_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct tc3xxk_platform_data *pdata;
struct tc3xxk_data *data;
struct input_dev *input_dev;
int ret = 0;
SENSOR_INFO("\n");
#ifdef CONFIG_BATTERY_SAMSUNG
if (lpcharge == 1) {
SENSOR_ERR("Do not load driver due to : lpm %d\n", lpcharge);
return -ENODEV;
}
#endif
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
SENSOR_ERR("i2c_check_functionality fail\n");
return -EIO;
}
if (client->dev.of_node) {
pdata = devm_kzalloc(&client->dev,
sizeof(struct tc3xxk_platform_data),
GFP_KERNEL);
if (!pdata) {
SENSOR_ERR("Failed to allocate memory\n");
ret = -ENOMEM;
goto err_alloc_data;
}
ret = tc3xxk_parse_dt(&client->dev, pdata);
if (ret)
goto err_alloc_data;
}else
pdata = client->dev.platform_data;
data = kzalloc(sizeof(struct tc3xxk_data), GFP_KERNEL);
if (!data) {
SENSOR_ERR("Failed to allocate memory\n");
ret = -ENOMEM;
goto err_alloc_data;
}
data->pdata = pdata;
input_dev = input_allocate_device();
if (!input_dev) {
SENSOR_ERR("Failed to allocate memory for input device\n");
ret = -ENOMEM;
goto err_alloc_input;
}
data->input_dev = input_dev;
data->client = client;
if (data->pdata == NULL) {
SENSOR_ERR("failed to get platform data\n");
input_free_device(input_dev);
ret = -EINVAL;
goto err_platform_data;
}
data->irq = -1;
mutex_init(&data->lock_fac);
wake_lock_init(&data->grip_wake_lock, WAKE_LOCK_SUSPEND, "grip wake lock");
INIT_DELAYED_WORK(&data->debug_work, tc3xxk_debug_work_func);
pdata->power = tc3xxk_grip_power;
i2c_set_clientdata(client, data);
tc3xxk_gpio_request(data);
ret = tc3xxk_pinctrl_init(data);
if (ret < 0) {
SENSOR_ERR("Failed to init pinctrl: %d\n", ret);
goto err_pinctrl_init;
}
if(pdata->boot_on_ldo){
data->pdata->power(data, true);
} else {
data->pdata->power(data, true);
msleep(200);
}
data->enabled = true;
client->irq = gpio_to_irq(pdata->gpio_int);
ret = tc3xxk_fw_check(data);
if (ret) {
SENSOR_ERR("failed to firmware check(%d)\n", ret);
goto err_fw_check;
}
input_dev->name = MODULE_NAME;
input_dev->id.bustype = BUS_I2C;
data->grip_ev_val = grip_ev;
data->grip_num = ARRAY_SIZE(grip_ev)/2;
SENSOR_INFO( "number of grips = %d\n", data->grip_num);
input_set_capability(input_dev, EV_REL, REL_MISC);
input_set_drvdata(input_dev, data);
ret = input_register_device(input_dev);
if (ret) {
SENSOR_ERR("fail to register input_dev (%d)\n", ret);
goto err_register_input_dev;
}
ret = sensors_create_symlink(input_dev);
if (ret < 0) {
SENSOR_ERR("Failed to create sysfs symlink\n");
goto err_sysfs_symlink;
}
ret = sysfs_create_group(&input_dev->dev.kobj,
&tc3xxk_attribute_group);
if (ret < 0) {
SENSOR_ERR("Failed to create sysfs group\n");
goto err_sysfs_group;
}
ret = sensors_register(data->dev, data, sec_grip_attributes, MODULE_NAME);
if (ret) {
SENSOR_ERR("could not register grip_sensor(%d)\n", ret);
goto err_sensor_register;
}
data->dev = &client->dev;
#if defined (CONFIG_VBUS_NOTIFIER)
vbus_notifier_register(&data->vbus_nb, tc3xxk_vbus_notification,
VBUS_NOTIFY_DEV_CHARGER);
#endif
ret = request_threaded_irq(client->irq, NULL, tc3xxk_interrupt,
IRQF_TRIGGER_FALLING | IRQF_ONESHOT, MODEL_NAME, data);
if (ret < 0) {
SENSOR_ERR("fail to request irq (%d).\n",
pdata->gpio_int);
goto err_request_irq;
}
disable_irq(client->irq);
data->irq = pdata->gpio_int;
data->irq_check = false;
// default working on stop mode
ret = tc3xxk_wake_up(data->client, TC300K_CMD_WAKE_UP);
ret = tc3xxk_mode_enable(data->client, TC300K_CMD_SAR_DISABLE);
if (ret < 0) {
SENSOR_ERR("Change mode fail(%d)\n", ret);
}
ret = tc3xxk_mode_check(client);
if (ret >= 0) {
data->sar_enable = !!(ret & TC300K_MODE_SAR);
SENSOR_INFO("mode %d, sar %d\n", ret, data->sar_enable);
}
device_init_wakeup(&client->dev, true);
schedule_delayed_work(&data->debug_work, msecs_to_jiffies(20000));
SENSOR_INFO("done\n");
return 0;
err_request_irq:
sensors_unregister(data->dev, sec_grip_attributes);
err_sensor_register:
sysfs_remove_group(&input_dev->dev.kobj, &tc3xxk_attribute_group);
err_sysfs_group:
sensors_remove_symlink(input_dev);
err_sysfs_symlink:
input_unregister_device(input_dev);
input_dev = NULL;
err_register_input_dev:
err_fw_check:
data->pdata->power(data, false);
err_pinctrl_init:
mutex_destroy(&data->lock_fac);
wake_lock_destroy(&data->grip_wake_lock);
err_platform_data:
err_alloc_input:
kfree(data);
err_alloc_data:
SENSOR_ERR("failed\n");
return ret;
}
static int tc3xxk_remove(struct i2c_client *client)
{
struct tc3xxk_data *data = i2c_get_clientdata(client);
device_init_wakeup(&client->dev, false);
wake_lock_destroy(&data->grip_wake_lock);
free_irq(client->irq, data);
input_unregister_device(data->input_dev);
mutex_destroy(&data->lock_fac);
data->pdata->power(data, false);
gpio_free(data->pdata->gpio_int);
gpio_free(data->pdata->gpio_sda);
gpio_free(data->pdata->gpio_scl);
kfree(data);
return 0;
}
static void tc3xxk_shutdown(struct i2c_client *client)
{
struct tc3xxk_data *data = i2c_get_clientdata(client);
SENSOR_INFO("\n");
cancel_delayed_work_sync(&data->debug_work);
device_init_wakeup(&client->dev, false);
wake_lock_destroy(&data->grip_wake_lock);
disable_irq(client->irq);
data->pdata->power(data, false);
}
static int tc3xxk_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct tc3xxk_data *data = i2c_get_clientdata(client);
SENSOR_INFO("sar_enable(%d)\n", data->sar_enable);
cancel_delayed_work_sync(&data->debug_work);
return 0;
}
static int tc3xxk_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct tc3xxk_data *data = i2c_get_clientdata(client);
SENSOR_INFO("sar_enable(%d)\n", data->sar_enable);
schedule_delayed_work(&data->debug_work, msecs_to_jiffies(1000));
return 0;
}
static const struct i2c_device_id tc3xxk_id[] = {
{MODEL_NAME, 0},
{ }
};
MODULE_DEVICE_TABLE(i2c, tc3xxk_id);
static struct of_device_id coreriver_match_table[] = {
{ .compatible = "coreriver,tc3xx-grip",},
{ },
};
static const struct dev_pm_ops tc3xxk_pm_ops = {
.suspend = tc3xxk_suspend,
.resume = tc3xxk_resume,
};
static struct i2c_driver tc3xxk_driver = {
.probe = tc3xxk_probe,
.remove = tc3xxk_remove,
.shutdown = tc3xxk_shutdown,
.driver = {
.name = MODEL_NAME,
.owner = THIS_MODULE,
.pm = &tc3xxk_pm_ops,
.of_match_table = coreriver_match_table,
},
.id_table = tc3xxk_id,
};
static int __init tc3xxk_init(void)
{
return i2c_add_driver(&tc3xxk_driver);
}
static void __exit tc3xxk_exit(void)
{
i2c_del_driver(&tc3xxk_driver);
}
module_init(tc3xxk_init);
module_exit(tc3xxk_exit);
MODULE_AUTHOR("Samsung Electronics");
MODULE_DESCRIPTION("Grip Sensor driver for Coreriver TC3XXK");
MODULE_LICENSE("GPL");