Google Git
Sign in
android / kernel / bcm / 22adcc80b26809fe7b2e751c8f2c1bb17a9b05ed / . / drivers / input / touchscreen / silabs_f760.c
blob: ce1beb9e5a11d773a49ae37dc33565b85f74a5a4 [file] [log] [blame]
/* drivers/input/touchscreen/silabs_f760.c
*
* Copyright (C) 2007 Google, Inc.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/earlysuspend.h>
#include <linux/hrtimer.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <mach/gpio.h>
#include <linux/device.h>
#include <linux/regulator/consumer.h>
#include <linux/firmware.h>
//PSJ #include <plat/syscfg.h>
#define MAX_X 240
#define MAX_Y 320
#define TSP_INT 91
#define TOUCH_EN 43 //PSJ
#define F760_MAX_TOUCH 2
#define ESCAPE_ADDR 0xAA
#define TS_READ_START_ADDR 0x10
#define TS_READ_VERSION_ADDR 0x1F
#define TS_READ_ESD_ADDR 0x1E
#define TS_READ_REGS_LEN 13
#define SILABS_MAX_TOUCH F760_MAX_TOUCH
#define MTSI_VERSION 0x05
//#define __TOUCH_DEBUG__ 1
#define I2C_RETRY_CNT 3
#define TOUCH_ON 1
#define TOUCH_OFF 0
#define PRESS_KEY 1
#define RELEASE_KEY 0
#define MAX_KEYS 2
#define SET_DOWNLOAD_BY_GPIO 1
#define SILABS_TS_NAME "silabs-f760"
#define YTE_MODULE_VER 0x02
#define SMAC_MODULE_VER 0x03
#define YTE_MODULE_VER_OLD 0x04
#define YTE_MODULE_VER_NEW 0x0A
#define SMAC_MODULE_VER_OLD 0x05
#define SMAC_MODULE_VER_NEW 0x07
#define FW_VER 0x03
#define FW_VER_OLD 0x0F
#define FW_VER_OLD_SMAC 0x14
#define FW_VER_NEW_YTE 0x14
#define FW_VER_NEW_SMAC 0x14
#if defined(CONFIG_TARGET_LOCALE_AUS_TEL)
#define T_YTE_MODULE_VER 0x08
#define T_YTE_MODULE_VER_NEW 0x08
#define T_FW_VER_YTE 0x0A
#define T_FW_VER_OLD_YTE 0x0A
#define T_FW_VER_NEW_YTE 0x0E
#define T_SMAC_MODULE_VER 0x14 //Module_ver = 20
#define T_SMAC_FW_VER 0x0F //FW_ver = 15
#endif
#define NUM_TX_CHANNEL 12
#define NUM_RX_CHANNEL 9
#define JIG_MODE_COMMAND 0xA0
#define RAWDATA_ADDRESS 0x003A
#define BASELINE_ADDRESS 0x0112
#define QUICKSENSE_OVERHEAD 6
#define I2CMAP_BUTTON_ADDRESS (0x0212 + 0x22)
#define NUM_MTRBUTTONS 2
static int prev_wdog_val = -1;
static struct workqueue_struct *check_ic_wq;
static struct regulator *touch_regulator=NULL;
//add by brcm
int touch_id[2], posX[2], posY[2], strength[2];
int Press_Check=0;
static int firmware_ret_val = -1;
static int pre_ta_stat = 0;
int touch_check=0;
int tsp_irq;
int tsp_chheck=0;
int TSP_MODULE_ID;
EXPORT_SYMBOL(TSP_MODULE_ID);
int FW_VERSION;
EXPORT_SYMBOL(FW_VERSION);
uint8_t buf_firmware[3];
int firm_update( void );
void set_tsp_for_ta_detect(int);
static int testmode = 1;
int PHONE_VER;
int tsp_status=0;
unsigned long check_node;
int Tx_Channel = NUM_TX_CHANNEL;
int Rx_Channel = NUM_RX_CHANNEL;
uint16_t baseline_node[NUM_TX_CHANNEL][NUM_RX_CHANNEL]={{0,},};
#if SET_DOWNLOAD_BY_GPIO
#include "bootloader.h"
#endif // SET_DOWNLOAD_BY_GPIO
enum
{
TOUCH_SCREEN=0,
TOUCH_KEY
};
struct key_info
{
int key_value;
int key_press;
};
struct muti_touch_info
{
int strength;
int status;
int width;
int posX;
int posY;
};
struct silabs_ts_data {
uint16_t addr;
struct i2c_client *client;
struct input_dev *input_dev;
int use_irq;
struct hrtimer timer;
struct work_struct work;
struct work_struct work_timer;
struct early_suspend early_suspend;
};
struct silabs_ts_data *ts_global;
/* sys fs */
struct class *touch_class;
EXPORT_SYMBOL(touch_class);
struct device *firmware_dev;
EXPORT_SYMBOL(firmware_dev);
static ssize_t firmware_show(struct device *dev, struct device_attribute *attr, char *buf);
static ssize_t firmware_ret_show(struct device *dev, struct device_attribute *attr, char *buf);
static DEVICE_ATTR(firmware , S_IRUGO, firmware_show, NULL);
static DEVICE_ATTR(firmware_ret , S_IRUGO, firmware_ret_show, NULL);
static ssize_t rawdata_show_silabs(struct device *dev, struct device_attribute *attr, char *buf);
static ssize_t raw_enable_silabs(struct device *dev, struct device_attribute *attr, char *buf);
static ssize_t raw_disable_silabs(struct device *dev, struct device_attribute *attr, char *buf);
static ssize_t baseline_show_silabs(struct device *dev, struct device_attribute *attr, char *buf1);
static ssize_t diff_show_silabs(struct device *dev, struct device_attribute *attr, char *buf);
static ssize_t fimware_show_versname(struct device *dev, struct device_attribute *attr, char *buf);
static ssize_t rawdata_pass_fail_silabs(struct device *dev, struct device_attribute *attr, char *buf);
static ssize_t read_node(struct device *dev, struct device_attribute *attr, char *buf);
static DEVICE_ATTR(reference, S_IRUGO, baseline_show_silabs, NULL) ;
static DEVICE_ATTR(raw, S_IRUGO, rawdata_show_silabs, NULL) ;
static DEVICE_ATTR(raw_enable, S_IRUGO, raw_enable_silabs, NULL) ;
static DEVICE_ATTR(raw_disable, S_IRUGO, raw_disable_silabs, NULL) ;
static DEVICE_ATTR(diff, S_IRUGO, diff_show_silabs, NULL) ;
static DEVICE_ATTR(versname, S_IRUGO, fimware_show_versname, NULL) ;
static DEVICE_ATTR(raw_value, S_IRUGO, rawdata_pass_fail_silabs, NULL) ;
static DEVICE_ATTR(node_read, S_IRUGO, read_node, NULL) ;
/* sys fs */
#ifdef CONFIG_HAS_EARLYSUSPEND
static void silabs_ts_early_suspend(struct early_suspend *h);
static void silabs_ts_late_resume(struct early_suspend *h);
#endif
extern int bcm_gpio_pull_up(unsigned int gpio, bool up);
extern int bcm_gpio_pull_up_down_enable(unsigned int gpio, bool enable);
extern int set_irq_type(unsigned int irq, unsigned int type);
//PSJ extern int tsp_charger_type_status;
void TSP_forced_release_forkey(void);
static struct muti_touch_info g_Mtouch_info[SILABS_MAX_TOUCH];
static struct key_info touchkey_status[MAX_KEYS];
void touch_ctrl_regulator(int on_off)
{
int rc;
if(on_off==TOUCH_ON)
{
#if 0
regulator_set_voltage(touch_regulator,2900000,2900000);
regulator_enable(touch_regulator);
#endif
rc = gpio_request(TOUCH_EN,"Touch_en");
if (rc < 0)
{
printk("[TSP] touch_power_control unable to request GPIO pin");
//printk(KERN_ERR "unable to request GPIO pin %d\n", TSP_INT_GPIO_PIN);
}
gpio_direction_output(TOUCH_EN,1);
gpio_set_value(TOUCH_EN,1);
gpio_free(TOUCH_EN);
}
else
{
#if 0
regulator_disable(touch_regulator);
#endif
gpio_request(TOUCH_EN,"Touch_en");
gpio_direction_output(TOUCH_EN,0);
gpio_set_value(TOUCH_EN,0);
gpio_free(TOUCH_EN);
}
}
EXPORT_SYMBOL(touch_ctrl_regulator);
int tsp_reset( void )
{
int ret=1;
printk("[TSP] %s+\n", __func__ );
touch_ctrl_regulator(0);
//PSJ gpio_direction_output(30, 0);
//PSJ gpio_direction_output(27, 0);
//PSJ gpio_direction_output(26, 0);
msleep(200);
// for TSK
TSP_forced_release_forkey();
//PSJ gpio_direction_output(30, 1);
//PSJ gpio_direction_output(27, 1);
//PSJ gpio_direction_output(26, 1);
//PSJ gpio_direction_input(30);
//PSJ gpio_direction_input(27);
//PSJ gpio_direction_input(26);
touch_ctrl_regulator(1);
msleep(200);
return ret;
}
int tsp_i2c_write (unsigned char *rbuf, int num)
{
int ret;
ret = i2c_master_send(ts_global->client, rbuf, num);
if(ret<0) {
printk("[TSP] Error code : %d, %d\n", __LINE__, ret );
}
return ret;
}
EXPORT_SYMBOL(tsp_i2c_write);
int tsp_i2c_read(unsigned char *rbuf, int len)
{
int ret;
ret = i2c_master_recv(ts_global->client, rbuf, len);
if(ret<0) {
printk("[TSP] Error code : %d, %d\n", __LINE__, ret );
}
return ret;
}
EXPORT_SYMBOL(tsp_i2c_read);
void TSP_forced_release_forkey(void)
{
int i, key;
int temp_value=0;
for(i=0; i<SILABS_MAX_TOUCH; i++)
{
if(g_Mtouch_info[i].strength== -1)
continue;
input_report_abs(ts_global->input_dev, ABS_MT_TRACKING_ID, i);
input_report_abs(ts_global->input_dev, ABS_MT_POSITION_X, g_Mtouch_info[i].posX);
input_report_abs(ts_global->input_dev, ABS_MT_POSITION_Y, g_Mtouch_info[i].posY);
input_report_abs(ts_global->input_dev, ABS_MT_TOUCH_MAJOR, 0 );
input_report_abs(ts_global->input_dev, ABS_MT_WIDTH_MAJOR, g_Mtouch_info[i].width);
//PSJ input_report_key(ts_global->input_dev, BTN_TOUCH, 0);
input_mt_sync(ts_global->input_dev);
printk("[TSP] force release\n");
if(g_Mtouch_info[i].strength == 0)
g_Mtouch_info[i].strength = -1;
temp_value++;
}
if(temp_value>0)
input_sync(ts_global->input_dev);
for(key = 0; key < MAX_KEYS ; key++)
{
touchkey_status[key].key_press = RELEASE_KEY;
input_report_key(ts_global->input_dev, touchkey_status[key].key_value, touchkey_status[key].key_press);
}
}
EXPORT_SYMBOL(TSP_forced_release_forkey);
static irqreturn_t silabs_ts_work_func(int irq, void *dev_id)
{
int ret=0, i=0, key=0;
uint8_t buf[TS_READ_REGS_LEN];
int touch_num=0, button_num =0, button_status=0, button_check=0;
struct silabs_ts_data *ts = dev_id;
#ifdef __TOUCH_DEBUG__
printk("[TSP] %s, %d\n", __func__, __LINE__ );
#endif
if(ts ==NULL)
{
printk("[TSP] silabs_ts_work_func : TS NULL\n");
return IRQ_HANDLED;
}
buf[0] = ESCAPE_ADDR;
buf[1] = 0x02;
for(i=0; i<I2C_RETRY_CNT; i++)
{
ret = i2c_master_send(ts->client, buf, 2);
if(ret >=0)
{
ret = i2c_master_recv(ts->client, buf, TS_READ_REGS_LEN);
if(ret >=0)
{
break; // i2c success
}
}
}
if (ret < 0)
{
printk("[TSP] silabs_ts_work_func: i2c failed %d\n", ret);
tsp_reset();
return IRQ_HANDLED;
}
else
{
touch_num = buf[0]&0x0F;
button_num = ((buf[0]&0xC0)>>6);
button_status=((buf[1]&0x10)>>4);
button_check=buf[1]&0x0F;
#ifdef __TOUCH_DEBUG__
printk("[TSP] button_num : %d, touch_num : %d, button_check:%d, buf[1] : %d\n", button_num, touch_num, button_check, buf[1]);
#endif
if(button_check == 0)
{
if(touch_num >0)
{
touch_id[0] = (buf[2]&0xf0)>>4;
posX[0] = (( buf[3]<< (8) ) + buf[4]);
posY[0] = ( buf[5]<< (8) ) + buf[6];
strength[0] = buf[7];
touch_id[1] = (buf[2]&0x0f);
posX[1] = (( buf[8]<< (8) ) + buf[9]);
posY[1] = ( buf[10]<< (8) ) + buf[11];
strength[1] = buf[12];
}
if(touch_num==0)
{
touch_id[0]=0;
touch_id[1]=0;
strength[0]=0;
strength[1]=0;
}
for(i=0; i<2; i++)
{
if(touch_id[i] >=1)
{
g_Mtouch_info[i].status = 1;
}
else if(touch_id[i] ==0 && g_Mtouch_info[i].status == 1)
{
g_Mtouch_info[i].status = 0;
}
else if(touch_id[i] ==0 && g_Mtouch_info[i].status == 0)
{
g_Mtouch_info[i].status = -1;
}
if(g_Mtouch_info[i].status == -1) continue;
input_report_abs(ts->input_dev, ABS_MT_POSITION_X, posX[i]);
input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, posY[i]);
input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, touch_id[i] );
input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, strength[i]);
input_mt_sync(ts->input_dev);
input_report_key(ts->input_dev, BTN_TOUCH, strength[i]);
g_Mtouch_info[i].posX = posX[i];
g_Mtouch_info[i].posY = posY[i];
g_Mtouch_info[i].width = strength[i];
g_Mtouch_info[i].strength = strength[i];
#ifdef __TOUCH_DEBUG__
printk("[TSP] i : %d, x: %d, y: %d\n, 3:%d, 4:%d", touch_id[i], posX[i], posY[i], strength[i], strength[i]);
#endif
}
}
else
{
if (buf[1] & 0x1)
key=0;
if (buf[1] & 0x2)
key=1;
touchkey_status[0].key_value= KEY_MENU;
touchkey_status[1].key_value= KEY_BACK;
touchkey_status[key].key_press=(button_status ? PRESS_KEY : RELEASE_KEY);
input_report_key(ts->input_dev, touchkey_status[key].key_value, touchkey_status[key].key_press);
input_report_key(ts->input_dev, BTN_TOUCH, 1);
#ifdef __TOUCH_DEBUG__
printk(KERN_ERR "[TSP] silabs_ts_work_func: buf[%d] : %d, button_status: %d\n", key, touchkey_status[key].key_value, touchkey_status[key].key_press);
#endif
}
input_sync(ts->input_dev);
}
return IRQ_HANDLED;
}
static irqreturn_t silabs_ts_irq_handler(int irq, void *dev_id)
{
touch_check=1;
#ifdef __TOUCH_DEBUG__
printk("[TSP] %s, %d\n", __func__, __LINE__ );
#endif
return IRQ_WAKE_THREAD;
}
void set_tsp_for_ta_detect(int state)
{
int ret=0;
uint8_t wdog_val[7] = {0x80, 0x05, 0x00, 0x02, 0x12, 0x20, 0x00};
if((tsp_status==0)&&(testmode==1))
{
if(state)
{
printk("[TSP] [1] set_tsp_for_ta_detect!!! state=1\n");
wdog_val[5] = 0x20;
ret = i2c_master_send(ts_global->client, (const char *)&wdog_val, 7);
if(ret<0) {
printk("[TSP] Error code : %d, %d\n", __LINE__, ret );
}
pre_ta_stat = 1;
}
else
{
printk("[TSP] [2] set_tsp_for_ta_detect!!! state=0\n");
wdog_val[5] = 0x00;
ret = i2c_master_send(ts_global->client, (const char *)&wdog_val, 7);
if(ret<0) {
printk("[TSP] Error code : %d, %d\n", __LINE__, ret );
}
pre_ta_stat = 0;
}
}
}
EXPORT_SYMBOL(set_tsp_for_ta_detect);
static void check_ic_work_func(struct work_struct *work_timer)
{
int ret=0;
uint8_t buf_esd[2];
uint8_t wdog_val[1];
struct silabs_ts_data *ts = container_of(work_timer, struct silabs_ts_data, work_timer);
//printk("[TSP] testmode : %d\n", testmode);
buf_esd[0] = ESCAPE_ADDR;
buf_esd[1] = TS_READ_ESD_ADDR;
wdog_val[0] = 1;
touch_check=0;
if(testmode==1)
{
#if 0 //PSJ
if( pre_ta_stat != tsp_charger_type_status )
{
set_tsp_for_ta_detect(tsp_charger_type_status);
}
#endif
ret = i2c_master_send(ts->client, (const char *)&buf_esd, 2);
if(ret >=0)
{
ret = i2c_master_recv(ts->client, wdog_val, 1);
}
if (touch_check==0)
{
if(ret < 0)
{
tsp_reset();
printk(KERN_ERR "silabs_ts_work_func : i2c_master_send [%d]\n", ret);
}
else if(wdog_val[0] == (uint8_t)prev_wdog_val)
{
printk("[TSP] %s tsp_reset counter = %x, prev = %x\n", __func__, wdog_val[0], (uint8_t)prev_wdog_val);
tsp_reset();
prev_wdog_val = -1;
}
else
{
prev_wdog_val = wdog_val[0];
}
}
}
}
static enum hrtimer_restart silabs_watchdog_timer_func(struct hrtimer *timer)
{
queue_work(check_ic_wq, &ts_global->work_timer);
hrtimer_start(&ts_global->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
return HRTIMER_NORESTART;
}
static unsigned int touch_present = 0;
static int silabs_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct silabs_ts_data *ts;
int ret = 0;
touch_ctrl_regulator(TOUCH_ON);
mdelay(200);
touch_ctrl_regulator(TOUCH_OFF);
mdelay(200);
touch_ctrl_regulator(TOUCH_ON);
mdelay(200);
printk("[TSP] %s, %d\n", __func__, __LINE__ );
ts = kzalloc(sizeof(*ts), GFP_KERNEL);
if (ts == NULL) {
ret = -ENOMEM;
goto err_alloc_data_failed;
}
INIT_WORK(&ts->work_timer, check_ic_work_func );
ts->client = client;
i2c_set_clientdata(client, ts);
ts_global = ts;
tsp_irq=client->irq;
hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
ts->timer.function = silabs_watchdog_timer_func;
/* sys fs */
touch_class = class_create(THIS_MODULE, "touch");
if (IS_ERR(touch_class))
pr_err("Failed to create class(touch)!\n");
firmware_dev = device_create(touch_class, NULL, 0, NULL, "firmware");
if (IS_ERR(firmware_dev))
pr_err("Failed to create device(firmware)!\n");
if (device_create_file(firmware_dev, &dev_attr_firmware) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_firmware.attr.name);
if (device_create_file(firmware_dev, &dev_attr_firmware_ret) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_firmware_ret.attr.name);
if (device_create_file(firmware_dev, &dev_attr_versname) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_versname.attr.name);
if (device_create_file(firmware_dev, &dev_attr_raw) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_raw.attr.name);
if (device_create_file(firmware_dev, &dev_attr_reference) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_reference.attr.name);
if (device_create_file(firmware_dev, &dev_attr_diff) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_diff.attr.name);
if (device_create_file(firmware_dev, &dev_attr_raw_value) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_raw_value.attr.name);
if (device_create_file(firmware_dev, &dev_attr_node_read) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_node_read.attr.name);
if (device_create_file(firmware_dev, &dev_attr_raw_enable) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_raw_enable.attr.name);
if (device_create_file(firmware_dev, &dev_attr_raw_disable) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_raw_disable.attr.name);
/* sys fs */
ts->input_dev = input_allocate_device();
if (ts->input_dev == NULL) {
ret = -ENOMEM;
touch_present = 0;
printk(KERN_ERR "silabs_ts_probe: Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
ts->input_dev->name = "sec_touchscreen ";
ts->input_dev->evbit[0] = BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY);
ts->input_dev->keybit[BIT_WORD(KEY_MENU)] |= BIT_MASK(KEY_MENU);
ts->input_dev->keybit[BIT_WORD(KEY_POWER)] |= BIT_MASK(KEY_POWER);
ts->input_dev->keybit[BIT_WORD(KEY_BACK)] |= BIT_MASK(KEY_BACK);
ts->input_dev->keybit[BIT_WORD(KEY_SEARCH)] |= BIT_MASK(KEY_SEARCH);
set_bit(BTN_TOUCH, ts->input_dev->keybit);
set_bit(EV_ABS, ts->input_dev->evbit);
ts->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY);
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, MAX_X, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, MAX_Y, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
set_bit(EV_SYN, ts->input_dev->evbit);
set_bit(EV_KEY, ts->input_dev->evbit);
set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);
/* ts->input_dev->name = ts->keypad_info->name; */
ret = input_register_device(ts->input_dev);
if (ret) {
touch_present = 0;
printk(KERN_ERR "silabs_ts_probe: Unable to register %s input device\n", ts->input_dev->name);
goto err_input_register_device_failed;
}
printk("[TSP] %s, irq=%d\n", __func__, tsp_irq );
gpio_request(TSP_INT, "ts_irq");
gpio_direction_input(TSP_INT);
if (tsp_irq) {
ret = request_threaded_irq(tsp_irq, silabs_ts_irq_handler, silabs_ts_work_func, IRQF_TRIGGER_FALLING|IRQF_ONESHOT, client->name, ts);
if (ret < 0)
dev_err(&client->dev, "request_irq failed, ret:%d \n", ret);
}
#if 1
#ifdef CONFIG_HAS_EARLYSUSPEND
ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN+1;
ts->early_suspend.suspend = silabs_ts_early_suspend;
ts->early_suspend.resume = silabs_ts_late_resume;
register_early_suspend(&ts->early_suspend);
#endif
#endif
if(ts ==NULL)
{
printk("[TSP] silabs_ts_init_read : TS NULL\n");
goto err_input_dev_alloc_failed;
}
touch_present = 1;
buf_firmware[0] = ESCAPE_ADDR;
buf_firmware[1] = TS_READ_VERSION_ADDR;
ret = i2c_master_send(ts->client,(const char *) &buf_firmware, 2);
if(ret < 0)
{
printk(KERN_ERR "silabs_ts_work_func : i2c_master_send [%d]\n", ret);
tsp_chheck=1;
}
if(tsp_chheck==0)
{
ret = i2c_master_recv(ts->client, (char *)&buf_firmware, 3);
if(ret < 0)
{
printk(KERN_ERR "silabs_ts_work_func : i2c_master_recv [%d]\n", ret);
tsp_chheck=1;
}
printk("[TSP] silabs_ts_probe %d, %d, %d\n", buf_firmware[0], buf_firmware[1], buf_firmware[2]);
#if defined(CONFIG_TARGET_LOCALE_AUS_TEL)
if (( buf_firmware[2] == T_YTE_MODULE_VER_NEW)&&(buf_firmware[0] < T_FW_VER_NEW_YTE))
{
TSP_MODULE_ID = buf_firmware[2];
PHONE_VER = T_FW_VER_NEW_YTE;
local_irq_disable();
ret = Firmware_Download();
printk("[TSP] enable_irq : %d\n", __LINE__ );
printk("[TSP] totoroT taeyang 0x08 update : %d\n", __LINE__ );
local_irq_enable();
if(ret == 0)
{
printk(KERN_ERR "SET Download Fail - error code [%d]\n", ret);
}
}
else if(( buf_firmware[2] == T_SMAC_MODULE_VER)&&((buf_firmware[0] < T_SMAC_FW_VER)))
{
TSP_MODULE_ID = buf_firmware[2];
PHONE_VER = T_SMAC_FW_VER;
local_irq_disable();
ret = Firmware_Download();
printk("[TSP] enable_irq : %d\n", __LINE__ );
printk("[TSP] totoroT SMAC 0x14 update : %d\n", __LINE__ );
local_irq_enable();
if(ret == 0)
{
printk(KERN_ERR "SET Download Fail - error code [%d]\n", ret);
}
}
else
#endif
if ((( buf_firmware[2] == YTE_MODULE_VER)||( buf_firmware[2] == SMAC_MODULE_VER))&&(buf_firmware[0] < FW_VER))
{
TSP_MODULE_ID = buf_firmware[2];
PHONE_VER = FW_VER;
local_irq_disable();
//ret = Firmware_Download();
printk("[TSP] enable_irq : %d\n", __LINE__ );
local_irq_enable();
if(ret == 0)
{
printk(KERN_ERR "SET Download Fail - error code [%d]\n", ret);
}
}
else if (( buf_firmware[2] == YTE_MODULE_VER_OLD)&&(buf_firmware[0] < FW_VER_OLD))
{
TSP_MODULE_ID = buf_firmware[2];
PHONE_VER = FW_VER_OLD;
local_irq_disable();
ret = Firmware_Download();
printk("[TSP] enable_irq : %d\n", __LINE__ );
local_irq_enable();
if(ret == 0)
{
printk(KERN_ERR "SET Download Fail - error code [%d]\n", ret);
}
}
else if (( buf_firmware[2] == SMAC_MODULE_VER_OLD)&&(buf_firmware[0] < FW_VER_OLD_SMAC))
{
TSP_MODULE_ID = buf_firmware[2];
PHONE_VER = FW_VER_OLD_SMAC;
local_irq_disable();
ret = Firmware_Download();
printk("[TSP] enable_irq : %d\n", __LINE__ );
local_irq_enable();
if(ret == 0)
{
printk(KERN_ERR "SET Download Fail - error code [%d]\n", ret);
}
}
else if (( buf_firmware[2] == YTE_MODULE_VER_NEW)&&(buf_firmware[0] < FW_VER_NEW_YTE))
{
TSP_MODULE_ID = buf_firmware[2];
PHONE_VER = FW_VER_NEW_YTE;
local_irq_disable();
ret = Firmware_Download();
printk("[TSP] enable_irq : %d\n", __LINE__ );
local_irq_enable();
if(ret == 0)
{
printk(KERN_ERR "SET Download Fail - error code [%d]\n", ret);
}
}
else if (( buf_firmware[2] == SMAC_MODULE_VER_NEW)&&(buf_firmware[0] < FW_VER_NEW_SMAC))
{
TSP_MODULE_ID = buf_firmware[2];
PHONE_VER = FW_VER_NEW_SMAC;
local_irq_disable();
ret = Firmware_Download();
printk("[TSP] enable_irq : %d\n", __LINE__ );
local_irq_enable();
if(ret == 0)
{
printk(KERN_ERR "SET Download Fail - error code [%d]\n", ret);
}
}
else if (( buf_firmware[2] == 0xFF) || (ret<0))
{
TSP_MODULE_ID = buf_firmware[2];
local_irq_disable();
ret = Firmware_Download();
printk("[TSP] enable_irq : %d\n", __LINE__ );
local_irq_enable();
if(ret == 0)
{
printk(KERN_ERR "SET Download Fail - error code [%d]\n", ret);
}
}
hrtimer_start(&ts->timer, ktime_set(2, 0), HRTIMER_MODE_REL);
}
return 0;
err_input_register_device_failed:
printk(KERN_ERR "silabs-ts: err_input_register_device failed\n");
input_free_device(ts->input_dev);
err_input_dev_alloc_failed:
printk(KERN_ERR "silabs-ts: err_input_dev_alloc failed\n");
err_alloc_data_failed:
printk(KERN_ERR "silabs-ts: err_alloc_data failed_\n");
return 1;
}
static int silabs_ts_remove(struct i2c_client *client)
{
struct silabs_ts_data *ts = i2c_get_clientdata(client);
unregister_early_suspend(&ts->early_suspend);
if (tsp_irq)
free_irq(tsp_irq, ts);
//else
// hrtimer_cancel(&ts->timer);
input_unregister_device(ts->input_dev);
kfree(ts);
return 0;
}
static int silabs_ts_suspend(struct i2c_client *client, pm_message_t mesg)
{
int ret;
struct silabs_ts_data *ts = i2c_get_clientdata(client);
printk("[TSP] %s, %d\n", __func__, __LINE__ );
tsp_status=1;
if( touch_present )
{
if (tsp_irq)
{
disable_irq(tsp_irq);
}
ret = cancel_work_sync(&ts->work_timer);
ret = cancel_work_sync(&ts->work);
if (ret && tsp_irq) /* if work was pending disable-count is now 2 */
{
enable_irq(tsp_irq);
}
if(tsp_chheck==0)
hrtimer_cancel(&ts->timer);
touch_ctrl_regulator(TOUCH_OFF);
//PSJ gpio_direction_output(30, 0);
//PSJ gpio_direction_output(27, 0);
//PSJ gpio_direction_output(26, 0);
msleep(400);
}
else
printk("[TSP] TSP isn't present.\n");
TSP_forced_release_forkey();
printk("[TSP] %s-\n", __func__ );
return 0;
}
static int silabs_ts_resume(struct i2c_client *client)
{
int key;
struct silabs_ts_data *ts = i2c_get_clientdata(client);
printk("[TSP] %s, %d\n", __func__, __LINE__ );
//enable_irq(client->irq); // scl wave
printk("[TSP] %s+\n", __func__ );
if( touch_present )
{
//PSJ gpio_direction_output(30, 1);
//PSJ gpio_direction_output(27, 1);
//PSJ gpio_direction_output(26, 1);
//PSJ gpio_direction_input(30);
//PSJ gpio_direction_input(27);
//PSJ gpio_direction_input(26);
touch_ctrl_regulator(TOUCH_ON);
msleep(40);
// for TSK
for(key = 0; key < MAX_KEYS; key++)
touchkey_status[key].key_press = RELEASE_KEY;
prev_wdog_val = -1;
#if 0 //PSJ
if(tsp_charger_type_status == 1)
{
set_tsp_for_ta_detect(tsp_charger_type_status);
}
#endif
#if 0
if( tsp_proximity_irq_status == 1)
{
set_tsp_for_prox_enable(tsp_proximity_irq_status);
}
#endif
if(tsp_chheck==0)
hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
enable_irq(tsp_irq);
}
else
printk("[TSP] TSP isn't present.\n");
printk("[TSP] %s-\n", __func__ );
tsp_status=0;
return 0;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
static void silabs_ts_early_suspend(struct early_suspend *h)
{
struct silabs_ts_data *ts;
ts = container_of(h, struct silabs_ts_data, early_suspend);
silabs_ts_suspend(ts->client, PMSG_SUSPEND);
}
static void silabs_ts_late_resume(struct early_suspend *h)
{
struct silabs_ts_data *ts;
ts = container_of(h, struct silabs_ts_data, early_suspend);
silabs_ts_resume(ts->client);
}
#endif
static const struct i2c_device_id silabs_ts_id[] = {
{ SILABS_TS_NAME, 0 },
{ }
};
static struct i2c_driver silabs_ts_driver = {
.probe = silabs_ts_probe,
.remove = silabs_ts_remove,
#if 1
#ifndef CONFIG_HAS_EARLYSUSPEND
.suspend = silabs_ts_suspend,
.resume = silabs_ts_resume,
#endif
#endif
.id_table = silabs_ts_id,
.driver = {
.name = SILABS_TS_NAME,
},
};
static int __devinit silabs_ts_init(void)
{
check_ic_wq = create_singlethread_workqueue("check_ic_wq");
if (!check_ic_wq)
return -ENOMEM;
touch_regulator = regulator_get(NULL,"touch_vcc");
//PSJ board_sysconfig(SYSCFG_TOUCH, SYSCFG_INIT);
return i2c_add_driver(&silabs_ts_driver);
}
static void __exit silabs_ts_exit(void)
{
if (touch_regulator)
{
regulator_put(touch_regulator);
touch_regulator = NULL;
}
i2c_del_driver(&silabs_ts_driver);
if (check_ic_wq)
destroy_workqueue(check_ic_wq);
}
/* Touch Reference ************************************************************/
static ssize_t raw_enable_silabs(struct device *dev, struct device_attribute *attr, char *buf)
{
printk("[TSP] %s stop. line : %d, \n", __func__,__LINE__);
testmode=0;
return sprintf(buf, "1") ;
}
static ssize_t raw_disable_silabs(struct device *dev, struct device_attribute *attr, char *buf)
{
printk("[TSP] %s stop. line : %d, \n", __func__,__LINE__);
testmode=1;
touch_ctrl_regulator(0);
mdelay(2);
touch_ctrl_regulator(1);
mdelay(300);
return sprintf(buf, "1") ;
}
int silabs_quicksense ( int address, int size, char* buff )
{
uint8_t buf1[7]={0x78, 0x05, 0x00, 0, 0, 0, 0};
int ret;
buf1[3] = (address >> 8) & 0xFF; // Address High Byte
buf1[4] = address & 0xFF; // Address Low Byte
buf1[5] = size;
ret = i2c_master_send(ts_global->client, buf1, 7);
if (ret < 0)
{
printk("[TSP] i2c_master_send fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
ret = i2c_master_recv(ts_global->client, buff, size + QUICKSENSE_OVERHEAD);
if (ret < 0)
{
printk("[TSP] i2c_master_recv fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
return 0;
}
static ssize_t rawdata_pass_fail_silabs(struct device *dev, struct device_attribute *attr, char *buf)
{
int Rx_Channel = NUM_RX_CHANNEL;
uint8_t buffer1[NUM_TX_CHANNEL*NUM_RX_CHANNEL*2+QUICKSENSE_OVERHEAD]={0,};
uint8_t buffer2[NUM_TX_CHANNEL*NUM_RX_CHANNEL*2+QUICKSENSE_OVERHEAD]={0,};
uint16_t rawdata[NUM_TX_CHANNEL][NUM_RX_CHANNEL]={{0,},};
#if defined(CONFIG_TARGET_LOCALE_AUS_TEL)
uint16_t TYE_RAWDATA_MAX[108] = {14250,14370,14370,14390,14320,14290,14265,14175,13915,13515,13660,13665,13700,13620,13590,13555,13460,13195,13470,13615,13615,13650,13585,13550,13515,13415,13145,13470,13600,13590,13625,13565,13530,13500,13405,13130,13455,13590,13600,13630,13555,13515,13485,13300,13110,13410,13555,13590,13620,13520,13485,13460,13360,13080,13245,13490,13555,13600,13505,13490,13475,13415,13410,13230,13470,13540,13600,13520,13480,13460,13400,13280,13215,13445,13505,13565,13500,13460,13430,13375,13235,13215,13430,13480,13535,13480,13455,13430,13350,13195,13380,13415,13445,13495,13440,13415,13395,13320,13160,13935,14110,14130,14190,14110,14090,14060,14000,13825};
uint16_t TYE_RAWDATA_MIN[108] = {10750,10840,10840,10860,10800,10780,10760,10695,10500,10195,10305,10310,10335,10275,10250,10225,10155, 9955,10165,10270,10270,10295,10250,10220,10195,10120, 9920,10160,10260,10255,10280,10235,10210,10185,10110, 9905,10150,10250,10260,10285,10225,10195,10175,10100, 9890,10120,10225,10255,10280,10200,10175,10155,10080, 9870, 9990,10175,10225,10260,10190,10175,10165,10120,10115, 9980,10160,10215,10260,10200,10170,10155,10110,10020, 9970,10140,10190,10235,10185,10155,10130,10090, 9985, 9970,10130,10170,10210,10170,10150,10130,10075, 9955,10095,10120,10145,10180,10140,10120,10105,10050, 9930,10510,10645,10660,10705,10645,10630,10610,10560,10430};
uint16_t SMAC_RAWDATA_MAX[108] = {15075,15183,15165,15194,15106,15077,15054,14971,14698,14692,14844,14859,14902,14801,14755,14720,14627,14346,14668,14814,14828,14880,14792,14741,14700,14606,14327,14660,14788,14792,14847,14768,14713,14667,14571,14298,14622,14749,14771,14821,14733,14682,14637,14539,14260,14566,14704,14737,14784,14686,14644,14608,14518,14240,14415,14654,14700,14755,14658,14636,14612,14558,14606,14401,14638,14686,14745,14653,14613,14590,14537,14453,14387,14628,14675,14735,14644,14589,14575,14527,14403,14367,14603,14650,14698,14619,14568,14557,14493,14339,14536,14583,14619,14668,14599,14549,14533,14459,14298,14799,14982,15011,15075,15003,14955,14917,14852,14696 };
uint16_t SMAC_RAWDATA_MIN[108] = {11143,11223,11209,11230,11166,11144,11127,11065,10864,10860,10972,10983,11014,10940,10906,10880,10811,10604,10842,10950,10960,10998,10934,10895,10866,10796,10589,10836,10930,10934,10974,10916,10875,10841,10770,10568,10808,10901,10917,10955,10889,10852,10819,10747,10540,10766,10868,10893,10928,10855,10824,10798,10730,10526,10655,10832,10866,10906,10834,10818,10800,10760,10796,10645,10820,10855,10899,10831,10801,10784,10745,10683,10634,10812,10847,10891,10824,10783,10773,10737,10645,10619,10793,10828,10864,10805,10768,10759,10713,10599,10744,10779,10805,10842,10791,10753,10741,10687,10568,10939,11074,11095,11143,11089,11053,11025,10978,10862};
#else
uint16_t RAWDATA_MAX[108] = {14350,14510,14560,14610,14710,14680,14780,14780,14440,13720,13990,14080,14150,14190,14190,14260,14250,13910,13650,13940,14040,14110,14150,14150,14210,14200,13870,13610,13890,14000,14080,14120,14120,14200,14170,13840,13570,13870,13960,14040,14080,14080,14160,14150,13820,13560,13830,13920,13990,14020,14020,14110,14120,13790,13540,13800,13900,13960,14000,14000,14090,14100,13770,13400,13760,13900,13980,14030,14040,14150,14200,14270,13380,13750,13890,13980,14020,14040,14140,14160,14050,13370,13730,13870,13960,14010,14010,14100,14130,13980,13440,13720,13860,13960,14000,14000,14100,14130,14180,14150,14560,14730,14830,14870,14870,14960,15000,15010};
uint16_t RAWDATA_MIN[108] = {10610,10720,10770,10800,10870,10850,10930,10920,10680,10140,10340,10410,10460,10490,10480,10540,10530,10280,10090,10300,10370,10430,10460,10460,10500,10500,10250,10060,10270,10340,10410,10440,10440,10490,10470,10230,10030,10250,10320,10380,10400,10410,10460,10460,10210,10020,10220,10290,10340,10360,10360,10430,10440,10190,10010,10200,10270,10320,10350,10350,10410,10420,10180,9900,10170,10270,10330,10370,10380,10460,10500,10540,9890,10160,10270,10330,10360,10370,10450,10470,10390,9880,10150,10250,10320,10350,10360,10420,10440,10330,9930,10140,10250,10310,10350,10350,10420,10450,10480,10460,10760,10880,10960,10990,10990,11060,11090,11100};
#endif
uint8_t buf_firmware_show[3];
int i, j, ret;
printk("[TSP] %s entered. line : %d, \n", __func__,__LINE__);
if(testmode==1) return sprintf(buf, "-1");
#if defined(CONFIG_TARGET_LOCALE_AUS_TEL)
printk("[TSP] rawdata_pass_fail_silabs at AU Version Read Test \n");
buf_firmware_show[0] = ESCAPE_ADDR;
buf_firmware_show[1] = TS_READ_VERSION_ADDR;
ret = i2c_master_send(ts_global->client, &buf_firmware_show, 2);
if(ret < 0)
{
printk(KERN_ERR "silabs_ts_work_func : i2c_master_send [%d]\n", ret);
}
ret = i2c_master_recv(ts_global->client, &buf_firmware_show, 3);
if(ret < 0)
{
printk(KERN_ERR "silabs_ts_work_func : i2c_master_recv [%d]\n", ret);
}
printk("[TSP][rawdata_pass_fail_silabs] ver tsp=0x%x, HW=0x%x, SW=0x%x\n", buf_firmware_show[1], buf_firmware_show[2], buf_firmware_show[0]);
if(buf_firmware_show[2] == T_YTE_MODULE_VER_NEW) //TYE Module
TSP_MODULE_ID = T_YTE_MODULE_VER_NEW;
else if(buf_firmware_show[2] == T_SMAC_MODULE_VER) //TYE Module
TSP_MODULE_ID = T_SMAC_MODULE_VER;
printk("[TSP][rawdata_pass_fail_silabs] TSP_MODULE_ID = 0x%x \n", TSP_MODULE_ID);
#endif
mdelay(300);
buffer1[0] = ESCAPE_ADDR;
buffer1[1] = JIG_MODE_COMMAND;
ret = i2c_master_send(ts_global->client, buffer1, 2);
if (ret < 0)
{
printk("[TSP] i2c_master_send fail! %s : %d, \n", __func__,__LINE__);
return sprintf(buf, "-1");
}
ret = i2c_master_recv(ts_global->client,buffer2, 1);
if (ret < 0)
{
printk("[TSP] i2c_master_recv fail! %s : %d, \n", __func__,__LINE__);
return sprintf(buf, "-1");
}
//
// quicksense format for reading rawdata
//
#if defined(CONFIG_TARGET_LOCALE_AUS_TEL)
ret = silabs_quicksense(RAWDATA_ADDRESS,NUM_TX_CHANNEL*NUM_RX_CHANNEL*2, buffer2);
#else
ret = silabs_quicksense(RAWDATA_ADDRESS,NUM_RX_CHANNEL*2, buffer2);
#endif
if (ret != 0)
{
printk("[TSP] silabs_quicksense fail! %s : %d, \n", __func__,__LINE__);
return sprintf(buf, "-1");
}
#if defined(CONFIG_TARGET_LOCALE_AUS_TEL)
for (i = 0; i < Tx_Channel; i++)
{
for(j = 0 ; j < Rx_Channel; j++)
{
rawdata[i][j] = (buffer2[(i*Rx_Channel+j)*2 + QUICKSENSE_OVERHEAD -1] <<8) + buffer2[(i*Rx_Channel+j)*2+QUICKSENSE_OVERHEAD];
if(TSP_MODULE_ID == T_YTE_MODULE_VER_NEW)
{
if( TYE_RAWDATA_MAX[i*Rx_Channel+j] < rawdata[i][j])
{
printk("[TSP] rawdata_pass_fail_silabs MAX rawdata[%d][%d] = %d \n", i,j,rawdata[i][j]);
return sprintf(buf, "0"); // fail
}
if( TYE_RAWDATA_MIN[i*Rx_Channel+j] > rawdata[i][j])
{
printk("[TSP] rawdata_pass_fail_silabs MIN rawdata[%d][%d] = %d \n", i,j,rawdata[i][j]);
return sprintf(buf, "0"); // fail
}
}
else if(TSP_MODULE_ID == T_SMAC_MODULE_VER)
{
if( SMAC_RAWDATA_MAX[i*Rx_Channel+j] < rawdata[i][j])
{
printk("[TSP] rawdata_pass_fail_silabs MAX rawdata[%d][%d] = %d \n", i,j,rawdata[i][j]);
return sprintf(buf, "0"); // fail
}
if( SMAC_RAWDATA_MIN[i*Rx_Channel+j] > rawdata[i][j])
{
printk("[TSP] rawdata_pass_fail_silabs MIN rawdata[%d][%d] = %d \n", i,j,rawdata[i][j]);
return sprintf(buf, "0"); // fail
}
}
}
}
#else
for (i = 0; i < 1; i++)
{
for(j = 0 ; j < Rx_Channel; j++)
{
rawdata[i][j] = (buffer2[(i*Rx_Channel+j)*2 + QUICKSENSE_OVERHEAD -1] <<8) + buffer2[(i*Rx_Channel+j)*2+QUICKSENSE_OVERHEAD];
if( RAWDATA_MAX[i*Rx_Channel+j] < rawdata[i][j])
{
return sprintf(buf, "0"); // fail
}
if( RAWDATA_MIN[i*Rx_Channel+j] > rawdata[i][j])
{
return sprintf(buf, "0"); // fail
}
}
}
#endif
buf_firmware_show[0] = ESCAPE_ADDR;
buf_firmware_show[1] = TS_READ_VERSION_ADDR;
ret = i2c_master_send(ts_global->client, (const char *)&buf_firmware_show, 2);
if(ret < 0)
{
printk(KERN_ERR "silabs_ts_work_func : i2c_master_send [%d]\n", ret);
}
ret = i2c_master_recv(ts_global->client, (char *)&buf_firmware_show, 3);
if(ret < 0)
{
printk(KERN_ERR "silabs_ts_work_func : i2c_master_recv [%d]\n", ret);
}
printk("[TSP] ver tsp=%x, HW=%x, SW=%x\n", buf_firmware_show[1], buf_firmware_show[2], buf_firmware_show[0]);
#if defined(CONFIG_TARGET_LOCALE_AUS_TEL)
if (buf_firmware_show[2] == T_YTE_MODULE_VER_NEW)
PHONE_VER = T_FW_VER_NEW_YTE;
else if (buf_firmware_show[2] == T_SMAC_MODULE_VER)
PHONE_VER = T_SMAC_FW_VER;
else
#endif
if (( buf_firmware_show[2] == YTE_MODULE_VER)||( buf_firmware_show[2] == SMAC_MODULE_VER))
PHONE_VER = FW_VER;
else if ( buf_firmware_show[2] == YTE_MODULE_VER_OLD)
PHONE_VER = FW_VER_OLD;
else if ( buf_firmware_show[2] == SMAC_MODULE_VER_OLD)
PHONE_VER = FW_VER_OLD_SMAC;
else if ( buf_firmware_show[2] == YTE_MODULE_VER_NEW)
PHONE_VER = FW_VER_NEW_YTE;
else if (buf_firmware_show[2] == SMAC_MODULE_VER_NEW)
PHONE_VER = FW_VER_NEW_SMAC;
printk("[TSP][rawdata_pass_fail_silabs] PHONE_VER = %x \n", PHONE_VER);
if(buf_firmware_show[0]!=PHONE_VER)
return sprintf(buf, "0");
return sprintf(buf, "1"); // success
}
static ssize_t rawdata_show_silabs(struct device *dev, struct device_attribute *attr, char *buf)
{
int Tx_Channel = NUM_TX_CHANNEL;
int Rx_Channel = NUM_RX_CHANNEL;
int written_bytes = 0 ; /* & error check */
uint8_t buffer1[NUM_TX_CHANNEL*NUM_RX_CHANNEL*2+QUICKSENSE_OVERHEAD]={0,};
uint8_t buffer2[NUM_TX_CHANNEL*NUM_RX_CHANNEL*2+QUICKSENSE_OVERHEAD]={0,};
uint16_t rawdata[NUM_TX_CHANNEL][NUM_RX_CHANNEL]={{0,},};
uint16_t baseline[NUM_TX_CHANNEL][NUM_RX_CHANNEL]={{0,},};
int i, j, ret;
printk("[TSP] %s entered. line : %d, \n", __func__,__LINE__);
if(testmode==1) return 0;
mdelay(300);
buffer1[0] = ESCAPE_ADDR;
buffer1[1] = JIG_MODE_COMMAND;
ret = i2c_master_send(ts_global->client, buffer1, 2);
if (ret < 0)
{
printk("[TSP] i2c_master_send fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
ret = i2c_master_recv(ts_global->client,buffer2, 1);
if (ret < 0)
{
printk("[TSP] i2c_master_recv fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
//
// quicksense format for reading baseline
//
ret = silabs_quicksense(BASELINE_ADDRESS,NUM_TX_CHANNEL*NUM_RX_CHANNEL*2, buffer1);
if (ret != 0)
{
printk("[TSP] silabs_quicksense fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
for (i = 0; i < Tx_Channel; i++)
{
for(j = 0 ; j < Rx_Channel; j++)
{
baseline[i][j] = (buffer1[(i*Rx_Channel+j)*2 + QUICKSENSE_OVERHEAD -1] <<8) + buffer1[(i*Rx_Channel+j)*2+QUICKSENSE_OVERHEAD];
}
}
//
// quicksense format for reading rawdata
//
ret = silabs_quicksense(RAWDATA_ADDRESS,NUM_TX_CHANNEL*NUM_RX_CHANNEL*2, buffer2);
if (ret != 0)
{
printk("[TSP] silabs_quicksense fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
for (i = 0; i < Tx_Channel; i++)
{
for(j = 0 ; j < Rx_Channel; j++)
{
rawdata[i][j] = (buffer2[(i*Rx_Channel+j)*2 + QUICKSENSE_OVERHEAD -1] <<8) + buffer2[(i*Rx_Channel+j)*2+QUICKSENSE_OVERHEAD];
written_bytes += sprintf(buf+written_bytes, "%d %d\n", rawdata[i][j], baseline[i][j]-rawdata[i][j]) ;
}
}
if (written_bytes > 0)
return written_bytes ;
return sprintf(buf, "-1") ;
}
static ssize_t baseline_show_silabs(struct device *dev, struct device_attribute *attr, char *buf1)
{
int Tx_Channel = NUM_TX_CHANNEL;
int Rx_Channel = NUM_RX_CHANNEL;
int written_bytes = 0 ; /* & error check */
uint8_t buffer[NUM_TX_CHANNEL*NUM_RX_CHANNEL*2+QUICKSENSE_OVERHEAD]={0,};
uint16_t baseline[NUM_TX_CHANNEL][NUM_RX_CHANNEL]={{0,},};
int i, j, ret;
if(testmode==1) return 0;
printk("[TSP] %s entered. line : %d, \n", __func__,__LINE__);
mdelay(300);
//
// Entering JIG_MODE
//
buffer[0] = ESCAPE_ADDR;
buffer[1] = JIG_MODE_COMMAND;
ret = i2c_master_send(ts_global->client, buffer, 2);
if (ret < 0)
{
printk("[TSP] i2c_master_send fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
ret = i2c_master_recv(ts_global->client,buffer, 1);
if (ret < 0)
{
printk("[TSP] i2c_master_recv fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
//
// quicksense format for reading baseline
//
ret = silabs_quicksense(BASELINE_ADDRESS,NUM_TX_CHANNEL*NUM_RX_CHANNEL*2, buffer);
if (ret != 0)
{
printk("[TSP] silabs_quicksense fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
for (i = 0; i < Tx_Channel; i++)
{
for(j = 0 ; j < Rx_Channel; j++)
{
baseline[i][j] = (buffer[(i*Rx_Channel+j)*2 + QUICKSENSE_OVERHEAD -1] <<8) + buffer[(i*Rx_Channel+j)*2+QUICKSENSE_OVERHEAD];
printk(" %5d", baseline[i][j]);
written_bytes += sprintf(buf1+written_bytes, "%d\n", baseline[i][j]) ;
}
printk("\n");
}
if (written_bytes > 0)
return written_bytes ;
return sprintf(buf1, "-1") ;
}
static ssize_t diff_show_silabs(struct device *dev, struct device_attribute *attr, char *buf)
{
int Tx_Channel = NUM_TX_CHANNEL;
int Rx_Channel = NUM_RX_CHANNEL;
uint8_t buffer1[NUM_TX_CHANNEL*NUM_RX_CHANNEL*2+QUICKSENSE_OVERHEAD]={0,};
uint8_t buffer2[NUM_TX_CHANNEL*NUM_RX_CHANNEL*2+QUICKSENSE_OVERHEAD]={0,};
uint16_t rawdata[NUM_TX_CHANNEL][NUM_RX_CHANNEL]={{0,},};
uint16_t baseline[NUM_TX_CHANNEL][NUM_RX_CHANNEL]={{0,},};
int i, j, ret;
printk("[TSP] %s entered. line : %d, \n", __func__,__LINE__);
if(testmode==1) return 0;
mdelay(300);
buffer1[0] = ESCAPE_ADDR;
buffer1[1] = JIG_MODE_COMMAND;
ret = i2c_master_send(ts_global->client, buffer1, 2);
if (ret < 0)
{
printk("[TSP] i2c_master_send fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
ret = i2c_master_recv(ts_global->client, buffer1, 1);
if (ret < 0)
{
printk("[TSP] i2c_master_recv fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
//
// quicksense format for reading baseline
//
ret = silabs_quicksense(BASELINE_ADDRESS,NUM_TX_CHANNEL*NUM_RX_CHANNEL*2, buffer1);
if (ret != 0)
{
printk("[TSP] silabs_quicksense fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
for (i = 0; i < Tx_Channel; i++)
{
for(j = 0 ; j < Rx_Channel; j++)
{
baseline[i][j] = (buffer1[(i*Rx_Channel+j)*2 + QUICKSENSE_OVERHEAD -1] <<8) + buffer1[(i*Rx_Channel+j)*2+QUICKSENSE_OVERHEAD];
//printk(" %5d", baseline[i][j]);
}
}
//
// quicksense format for reading rawdata
//
ret = silabs_quicksense(RAWDATA_ADDRESS,NUM_TX_CHANNEL*NUM_RX_CHANNEL*2, buffer2);
if (ret != 0)
{
printk("[TSP] silabs_quicksense fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
for (i = 0; i < Tx_Channel; i++)
{
for(j = 0 ; j < Rx_Channel; j++)
{
rawdata[i][j] = (buffer2[(i*Rx_Channel+j)*2 + QUICKSENSE_OVERHEAD -1] <<8) + buffer2[(i*Rx_Channel+j)*2+QUICKSENSE_OVERHEAD];
printk(" %5d", baseline[i][j]-rawdata[i][j]);
}
printk("\n");
}
return 0;
}
static ssize_t firmware_show(struct device *dev, struct device_attribute *attr, char *buf)
{
uint8_t buf_firmware_show[3];
int ret;
/*
buf = [1][2][3][4][5][6][7][8] : [1] - Don't care
[2][3] - module version
[4][5] - TSP part vesion
[6][7] - TSP part vesion
*/
printk("[TSP] %s\n",__func__);
buf_firmware_show[0] = ESCAPE_ADDR;
buf_firmware_show[1] = TS_READ_VERSION_ADDR;
ret = i2c_master_send(ts_global->client,(const char *) &buf_firmware_show, 2);
if(ret < 0)
{
printk(KERN_ERR "silabs_ts_work_func : i2c_master_send [%d]\n", ret);
}
ret = i2c_master_recv(ts_global->client, (char *)&buf_firmware_show, 3);
if(ret < 0)
{
printk(KERN_ERR "silabs_ts_work_func : i2c_master_recv [%d]\n", ret);
}
printk("[TSP] ver tsp=%x, HW=%x, SW=%x\n", buf_firmware_show[1], buf_firmware_show[2], buf_firmware_show[0]);
if (( buf_firmware_show[2] == YTE_MODULE_VER)||( buf_firmware_show[2] == SMAC_MODULE_VER))
{
PHONE_VER = FW_VER;
}
else if ( buf_firmware_show[2] == YTE_MODULE_VER_OLD)
{
PHONE_VER = FW_VER_OLD;
}
else if ( buf_firmware_show[2] == SMAC_MODULE_VER_OLD)
{
PHONE_VER = FW_VER_OLD_SMAC;
sprintf(buf, "10%x%x%x\n", buf_firmware_show[2], buf_firmware_show[0], PHONE_VER);
printk("[TSP] %s\n", buf);
return sprintf(buf, "%s", buf );
}
else if ( buf_firmware_show[2] == YTE_MODULE_VER_NEW)
{
PHONE_VER = FW_VER_NEW_YTE;
sprintf(buf, "10%x%x%x\n", buf_firmware_show[2], buf_firmware_show[0], PHONE_VER);
printk("[TSP] %s\n", buf);
return sprintf(buf, "%s", buf );
}
else if (buf_firmware_show[2] == SMAC_MODULE_VER_NEW)
{
PHONE_VER = FW_VER_NEW_SMAC;
sprintf(buf, "10%x%x%x\n", buf_firmware_show[2], buf_firmware_show[0], PHONE_VER);
printk("[TSP] %s\n", buf);
return sprintf(buf, "%s", buf );
}
#if defined(CONFIG_TARGET_LOCALE_AUS_TEL)
else if (buf_firmware_show[2] == T_YTE_MODULE_VER_NEW)
{
PHONE_VER = T_FW_VER_NEW_YTE;
sprintf(buf, "10%x0%x0%x\n", buf_firmware_show[2], buf_firmware_show[0], PHONE_VER);
printk("[TSP] %s\n", buf);
return sprintf(buf, "%s", buf );
}
else if (buf_firmware_show[2] == T_SMAC_MODULE_VER)
{
PHONE_VER = T_SMAC_FW_VER;
sprintf(buf, "1%x0%x0%x\n", buf_firmware_show[2], buf_firmware_show[0], PHONE_VER);
printk("[TSP] %s\n", buf);
return sprintf(buf, "%s", buf );
}
#endif
sprintf(buf, "10%x0%x0%x\n", buf_firmware_show[2], buf_firmware_show[0], PHONE_VER);
printk("[TSP] %s\n", buf);
return sprintf(buf, "%s", buf );
}
static ssize_t fimware_show_versname(struct device *dev, struct device_attribute *attr, char *buf)
{
uint8_t buf_firmware_ver[3];
int ret;
printk("[TSP] %s\n",__func__);
buf_firmware_ver[0] = ESCAPE_ADDR;
buf_firmware_ver[1] = TS_READ_VERSION_ADDR;
ret = i2c_master_send(ts_global->client,(const char *) &buf_firmware_ver, 2);
if(ret < 0)
{
printk(KERN_ERR "silabs_ts_work_func : i2c_master_send [%d]\n", ret);
}
ret = i2c_master_recv(ts_global->client, (char *) &buf_firmware_ver, 3);
if(ret < 0)
{
printk(KERN_ERR "silabs_ts_work_func : i2c_master_recv [%d]\n", ret);
}
printk("[TSP] ver tsp=%x, HW=%x, SW=%x\n", buf_firmware_ver[1], buf_firmware_ver[2], buf_firmware_ver[0]);
sprintf(buf, "%x\n", buf_firmware_ver[0]);
printk("[TSP] %s\n", buf);
return sprintf(buf, "%s", buf );
}
static ssize_t read_node(struct device *dev, struct device_attribute *attr, char *buf)
{
char *after;
int written_bytes = 0 ; /* & error check */
uint8_t buffer[NUM_TX_CHANNEL*NUM_RX_CHANNEL*2+QUICKSENSE_OVERHEAD]={0,};
int i, j, ret;
check_node = simple_strtoul(buf, &after, 10);
printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
mdelay(300);
//
// Entering JIG_MODE
//
buffer[0] = ESCAPE_ADDR;
buffer[1] = JIG_MODE_COMMAND;
ret = i2c_master_send(ts_global->client, buffer, 2);
if (ret < 0)
{
printk("[TSP] i2c_master_send fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
ret = i2c_master_recv(ts_global->client,buffer, 1);
if (ret < 0)
{
printk("[TSP] i2c_master_recv fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
//
// quicksense format for reading baseline
//
ret = silabs_quicksense(BASELINE_ADDRESS,NUM_TX_CHANNEL*NUM_RX_CHANNEL*2, buffer);
if (ret != 0)
{
printk("[TSP] silabs_quicksense fail! %s : %d, \n", __func__,__LINE__);
return -1;
}
for (i = 0; i < Tx_Channel; i++)
{
for(j = 0 ; j < Rx_Channel; j++)
{
baseline_node[i][j] = (buffer[(i*Rx_Channel+j)*2 + QUICKSENSE_OVERHEAD -1] <<8) + buffer[(i*Rx_Channel+j)*2+QUICKSENSE_OVERHEAD];
printk(" %5d", baseline_node[i][j]);
}
printk("\n");
}
for (j = 0; j < Rx_Channel; j++)
{
for(i = 0 ; i < Tx_Channel; i++)
{
written_bytes += sprintf(buf+written_bytes, ",%d", baseline_node[i][j]) ;
}
}
printk("[TSP] %s\n", buf);
touch_ctrl_regulator(0);
mdelay(2);
touch_ctrl_regulator(1);
mdelay(300);
return written_bytes;
}
/* firmware - update */
static ssize_t firmware_ret_show(struct device *dev, struct device_attribute *attr, char *buf)
{
printk("[TSP] %s!\n", __func__);
printk("[TSP] %s : %d\n", __func__, firmware_ret_val);
firm_update( );
return sprintf(buf, "%d", firmware_ret_val );
}
int firm_update( void )
{
int ret;
printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
disable_irq(tsp_irq);
ret = cancel_work_sync(&ts_global->work_timer);
ret = cancel_work_sync(&ts_global->work);
hrtimer_cancel(&ts_global->timer);
touch_ctrl_regulator(TOUCH_OFF);
mdelay(200);
touch_ctrl_regulator(TOUCH_ON);
mdelay(200);
TSP_MODULE_ID = buf_firmware[2];
local_irq_disable();
firmware_ret_val = Firmware_Download();
local_irq_enable();
msleep(1000);
if( firmware_ret_val )
printk(KERN_INFO "[TSP] %s success, %d\n", __func__, __LINE__);
else
printk(KERN_INFO "[TSP] %s fail, %d\n", __func__, __LINE__);
local_irq_enable();
enable_irq(tsp_irq);
hrtimer_start(&ts_global->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
return 0;
}
module_init(silabs_ts_init);
module_exit(silabs_ts_exit);
MODULE_DESCRIPTION("silabs Touchscreen Driver");
MODULE_LICENSE("GPL");