static void abov_tk_reset(struct abov_tk_info *info)
{
struct i2c_client *client = info->client;
if (info->enabled == false)
return;
dev_notice(&client->dev, "%s++\n", __func__);
disable_irq_nosync(info->irq);
info->enabled = false;
release_all_fingers(info);
abov_tk_reset_for_bootmode(info);
msleep(ABOV_RESET_DELAY);
abov_tk_dual_detection_mode(info, 1);
if (info->glovemode)
abov_glove_mode_enable(client, CMD_GLOVE_ON);
info->enabled = true;
enable_irq(info->irq);
dev_notice(&client->dev, "%s--\n", __func__);
}
void TSP_force_released(void)
{
pr_err("%s satrt!\n", __func__);
if (tsp_enabled == false) {
pr_err("[TSP] Disabled\n");
return;
}
release_all_fingers(ts_data);
touch_is_pressed = 0;
}
static int melfas_ts_suspend(struct i2c_client *client, pm_message_t mesg)
{
int ret;
int i;
struct melfas_ts_data *ts = i2c_get_clientdata(client);
disable_irq(client->irq);
tsp_enabled = false;
release_all_fingers(ts);
ts->gpio();
ts->power(false);
return 0;
}
static void tc300k_reset(struct tc300k_data *data)
{
release_all_fingers(data);
disable_irq(data->irq);
data->pdata->keyled(false);
data->pdata->power(false);
msleep(50);
data->pdata->power(true);
data->pdata->keyled(true);
msleep(50);
enable_irq(data->irq);
msleep(50);
}
static ssize_t tsp_call_release_touch(struct device *dev, struct device_attribute *attr, char *buf)
{
struct melfas_ts_data *ts = dev_get_drvdata(dev);
printk(" %s is called\n", __func__);
disable_irq(ts->client->irq);
release_all_fingers(ts);
ts->gpio();
ts->power(false);
msleep(200);
ts->power(true);
enable_irq(ts->client->irq);
return sprintf(buf,"0\n");
}
static ssize_t set_tsp_module_control(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct melfas_ts_data *ts = dev_get_drvdata(dev);
char write_buffer[2];
if (*buf == '0' && tsp_enabled == true) {
tsp_enabled = false;
release_all_fingers(ts);
ts->power(false);
msleep(200);
} else if (*buf == '1' && tsp_enabled == false) {
ts->power(true);
msleep(200);
melfas_i2c_write(ts->client, (char *)write_buffer, 2);
msleep(150);
tsp_enabled = true;
} else
pr_info("[TSP]tsp_power_control bad command!");
return count;
}
static ssize_t
tsp_firm_update_mode(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct melfas_ts_data *ts = dev_get_drvdata(dev);
int ret = 0;
if (!tsp_enabled)
return 0;
disable_irq(ts->client->irq);
firm_status_data = 1;
ts->set_touch_i2c_to_gpio();
pr_info("[TSP] ADB F/W UPDATE MODE ENTER!");
if (*buf == 'S')
ret = mms100_download(ts->pdata);
else if (*buf == 'F')
ret = mms100_download_file(ts->pdata);
pr_info("[TSP] ADB F/W UPDATE MODE FROM %s END! %s",
(*buf == 'S' ? "BINARY" : "FILE"), (ret ? "fail" : "success"));
firm_status_data = (ret ? 3 : 2);
ts->set_touch_i2c();
release_all_fingers(ts);
ts->power(0);
msleep(200);
ts->power(1);
msleep(100);
enable_irq(ts->client->irq);
return count;
}
static int abov_tk_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct abov_tk_info *info = i2c_get_clientdata(client);
if (!info->enabled)
return 0;
dev_notice(&info->client->dev, "%s: users=%d\n", __func__,
info->input_dev->users);
disable_irq(info->irq);
info->enabled = false;
release_all_fingers(info);
if (info->pdata->power)
info->pdata->power(info->pdata, false);
else
abov_sleep_mode(client, CMD_STOP_MODE);
return 0;
}
static void check_intensity_data(struct melfas_ts_data *ts, int num)
{
u8 write_buffer[6];
u8 read_buffer[2];
int sensing_line, exciting_line;
int gpio = ts->pdata->gpio_int;
int i = 0, ret;
if (0 == reference_data[0]) {
disable_irq(ts->client->irq);
/* enter the debug mode */
write_buffer[0] = 0xB0;
write_buffer[1] = 0x1A;
write_buffer[2] = 0x0;
write_buffer[3] = 0x0;
write_buffer[4] = 0x0;
write_buffer[5] = 0x01;
melfas_i2c_write(ts->client, (char *)write_buffer, 6);
/* wating for the interrupt*/
while (gpio_get_value(gpio)) {
pr_info(".");
udelay(100);
}
/* read the dummy data */
melfas_i2c_read(ts->client, 0xBF, 2, read_buffer);
if (debug_print)
pr_info("[TSP] read the dummy data\n");
write_buffer[5] = 0x07;
for (sensing_line = 0; sensing_line < X_LINE; sensing_line++) {
for (exciting_line = 0; exciting_line < Y_LINE;
exciting_line++) {
write_buffer[2] = exciting_line;
write_buffer[3] = sensing_line;
melfas_i2c_write(ts->client,
(char *)write_buffer, 6);
melfas_i2c_read(ts->client, 0xBF, 2,
read_buffer);
reference_data[exciting_line +
sensing_line * Y_LINE] =
(read_buffer[1] & 0xf) << 8
| read_buffer[0];
}
}
msleep(200);
melfas_ts_suspend(ts->client, PMSG_SUSPEND);
msleep(200);
melfas_ts_resume(ts->client);
msleep(100);
enable_irq(ts->client->irq);
msleep(100);
}
disable_irq(ts->client->irq);
release_all_fingers(ts);
write_buffer[0] = 0xB0;
write_buffer[1] = 0x1A;
write_buffer[2] = 0x0;
write_buffer[3] = 0x0;
write_buffer[4] = 0x0;
write_buffer[5] = 0x04;
for (sensing_line = 0; sensing_line < X_LINE; sensing_line++) {
for (exciting_line = 0; exciting_line < Y_LINE;\
exciting_line++) {
write_buffer[2] = exciting_line;
write_buffer[3] = sensing_line;
melfas_i2c_write(ts->client, (char *)write_buffer, 6);
melfas_i2c_read(ts->client, 0xBF, 2, read_buffer);
intensity_data[exciting_line + sensing_line * Y_LINE] =
(read_buffer[1] & 0xf) << 8 | read_buffer[0];
}
}
enable_irq(ts->client->irq);
}
static int check_delta_data(struct melfas_ts_data *ts)
{
u8 write_buffer[6];
u8 read_buffer[2];
int sensing_line, exciting_line;
int gpio = ts->client->irq - NR_MSM_IRQS;
int ret = 0;
disable_irq(ts->client->irq);
/* enter the debug mode */
write_buffer[0] = 0xA0;
write_buffer[1] = 0x1A;
write_buffer[2] = 0x0;
write_buffer[3] = 0x0;
write_buffer[4] = 0x0;
write_buffer[5] = 0x01;
melfas_i2c_write(ts->client, (char *)write_buffer, 6);
/* wating for the interrupt*/
while (gpio_get_value(gpio)) {
printk(".");
udelay(100);
}
if (debug_print)
pr_info("[TSP] read dummy\n");
/* read the dummy data */
melfas_i2c_read(ts->client, 0xA8, 2, read_buffer);
if (debug_print)
pr_info("[TSP] read inspenction data\n");
write_buffer[5] = 0x02;
for (sensing_line = 0; sensing_line < 14; sensing_line++) {
for (exciting_line =0; exciting_line < 26; exciting_line++) {
write_buffer[2] = exciting_line;
write_buffer[3] = sensing_line;
melfas_i2c_write(ts->client, (char *)write_buffer, 6);
melfas_i2c_read(ts->client, 0xA8, 2, read_buffer);
inspection_data[exciting_line + sensing_line * 26] =
(read_buffer[1] & 0xf) << 8 | read_buffer[0];
printk("%d.", inspection_data[exciting_line + sensing_line * 26]);
if(inspection_data[exciting_line + sensing_line * 26] < 100
|| inspection_data[exciting_line + sensing_line * 26] > 900)
ret = -1;
}
printk(" \n");
}
pr_info("[TSP] Reading data end.\n");
// release_all_fingers(ts);
msleep(200);
release_all_fingers(ts);
ts->gpio();
ts->power(false);
msleep(200);
ts->power(true);
enable_irq(ts->client->irq);
return ret;
}
static int tc300k_fw_check(struct tc300k_data *data)
{
struct i2c_client *client = data->client;
int ret;
bool update = false;
ret = get_fw_version(data, true);
if (ret < 0) {
#if 0
if (info->pdata->lcd_connect) {
/* tsp connect check */
dev_err(&client->dev,
"%s: i2c fail. but lcd connected\n",
__func__);
dev_err(&client->dev,
"excute firm update\n");
update = true;
} else {
#endif
dev_err(&client->dev,
"%s: i2c fail...[%d], addr[%d]\n",
__func__, ret, data->client->addr);
dev_err(&client->dev,
"%s: touchkey driver unload\n", __func__);
return ret;
}
if (data->fw_ver < TC300K_FIRMWARE_VER) {
dev_notice(&client->dev,
"fw_version check excute firmware update(0x%x, 0x%x)\n",
data->fw_ver, TC300K_FIRMWARE_VER);
update = true;
}
if (update) {
ret = tc300k_fw_update(data, FW_INKERNEL, true);
if (ret)
return -1;
}
return 0;
}
static int __devinit tc300k_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct input_dev *input_dev;
struct tc300k_data *data;
int ret;
int i;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev,
"i2c_check_functionality fail\n");
return -EIO;
}
data = kzalloc(sizeof(struct tc300k_data), GFP_KERNEL);
if (!data) {
dev_err(&client->dev, "Failed to allocate memory\n");
ret = -ENOMEM;
goto err_alloc_data;
}
input_dev = input_allocate_device();
if (!input_dev) {
dev_err(&client->dev,
"Failed to allocate memory for input device\n");
ret = -ENOMEM;
goto err_alloc_input;
}
data->client = client;
data->input_dev = input_dev;
data->pdata = client->dev.platform_data;
if (data->pdata == NULL) {
pr_err("failed to get platform data\n");
ret = -EINVAL;
goto err_platform_data;
}
data->irq = -1;
mutex_init(&data->lock);
data->key_num = data->pdata->key_num;
dev_info(&client->dev, "number of keys = %d\n", data->key_num);
data->keycode = data->pdata->keycode;
#if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP)
for (i = 1; i < data->key_num; i++)
dev_info(&client->dev, "keycode[%d]= %3d\n", i, data->keycode[i]);
#endif
i2c_set_clientdata(client, data);
data->pdata->keyled(true);
data->pdata->power(true);
data->enabled = true;
msleep(TC300K_POWERON_DELAY);
ret = tc300k_fw_check(data);
if (ret) {
dev_err(&client->dev,
"failed to firmware check(%d)\n", ret);
goto err_fw_check;
}
snprintf(data->phys, sizeof(data->phys),
"%s/input0", dev_name(&client->dev));
input_dev->name = "sec_touchkey";
input_dev->phys = data->phys;
input_dev->id.bustype = BUS_I2C;
input_dev->dev.parent = &client->dev;
input_dev->open = tc300k_input_open;
input_dev->close = tc300k_input_close;
set_bit(EV_KEY, input_dev->evbit);
set_bit(EV_LED, input_dev->evbit);
set_bit(LED_MISC, input_dev->ledbit);
for (i = 1; i < data->key_num; i++)
set_bit(data->keycode[i], input_dev->keybit);
input_set_drvdata(input_dev, data);
ret = input_register_device(input_dev);
if (ret) {
dev_err(&client->dev, "fail to register input_dev (%d)\n",
ret);
goto err_register_input_dev;
}
ret = request_threaded_irq(client->irq, NULL, tc300k_interrupt,
IRQF_TRIGGER_LOW | IRQF_ONESHOT,
TC300K_NAME, data);
if (ret < 0) {
dev_err(&client->dev, "fail to request irq (%d).\n",
client->irq);
goto err_request_irq;
}
data->irq = client->irq;
#ifdef CONFIG_HAS_EARLYSUSPEND
data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
data->early_suspend.suspend = tc300k_early_suspend;
data->early_suspend.resume = tc300k_late_resume;
register_early_suspend(&data->early_suspend);
#endif
data->sec_touchkey = device_create(sec_class,
NULL, 0, data, "sec_touchkey");
if (IS_ERR(data->sec_touchkey))
dev_err(&client->dev,
"Failed to create device for the touchkey sysfs\n");
ret = sysfs_create_group(&data->sec_touchkey->kobj,
&sec_touchkey_attr_group);
if (ret)
dev_err(&client->dev, "Failed to create sysfs group\n");
dev_info(&client->dev, "%s done\n", __func__);
return 0;
err_request_irq:
input_unregister_device(input_dev);
err_register_input_dev:
err_fw_check:
mutex_destroy(&data->lock);
data->pdata->keyled(false);
data->pdata->power(false);
err_platform_data:
input_free_device(input_dev);
err_alloc_input:
kfree(data);
err_alloc_data:
return ret;
}
static int __devexit tc300k_remove(struct i2c_client *client)
{
struct tc300k_data *data = i2c_get_clientdata(client);
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&data->early_suspend);
#endif
free_irq(data->irq, data);
input_unregister_device(data->input_dev);
input_free_device(data->input_dev);
mutex_destroy(&data->lock);
data->pdata->keyled(false);
data->pdata->power(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 tc300k_shutdown(struct i2c_client *client)
{
struct tc300k_data *data = i2c_get_clientdata(client);
data->pdata->keyled(false);
data->pdata->power(false);
}
#if defined(CONFIG_PM)
static int tc300k_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct tc300k_data *data = i2c_get_clientdata(client);
int i;
int ret;
mutex_lock(&data->lock);
if (!data->enabled)
return 0;
dev_notice(&data->client->dev, "%s: users=%d\n",
__func__, data->input_dev->users);
disable_irq(data->irq);
data->enabled = false;
release_all_fingers(data);
data->pdata->power(false);
data->pdata->keyled(false);
mutex_unlock(&data->lock);
return 0;
}
static int tc300k_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct tc300k_data *data = i2c_get_clientdata(client);
mutex_lock(&data->lock);
if (data->enabled)
return 0;
dev_notice(&data->client->dev, "%s: users=%d\n",
__func__, data->input_dev->users);
data->enabled = true;
data->pdata->keyled(true);
data->pdata->power(true);
msleep(50);
enable_irq(data->irq);
msleep(50);
mutex_unlock(&data->lock);
return 0;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
static void tc300k_early_suspend(struct early_suspend *h)
{
struct tc300k_data *data;
data = container_of(h, struct tc300k_data, early_suspend);
tc300k_suspend(&data->client->dev);
}
static void tc300k_late_resume(struct early_suspend *h)
{
struct tc300k_data *data;
data = container_of(h, struct tc300k_data, early_suspend);
tc300k_resume(&data->client->dev);
}
#endif
static void tc300k_input_close(struct input_dev *dev)
{
struct tc300k_data *data = input_get_drvdata(dev);
dev_info(&data->client->dev, "%s: users=%d\n", __func__,
data->input_dev->users);
tc300k_suspend(&data->client->dev);
}
static int tc300k_input_open(struct input_dev *dev)
{
struct tc300k_data *data = input_get_drvdata(dev);
dev_info(&data->client->dev, "%s: users=%d\n", __func__,
data->input_dev->users);
tc300k_resume(&data->client->dev);
return 0;
}
#endif /* CONFIG_PM */
#if 0
#if defined(CONFIG_PM) || defined(CONFIG_HAS_EARLYSUSPEND)
static const struct dev_pm_ops tc300k_pm_ops = {
.suspend = tc300k_suspend,
.resume = tc300k_resume,
};
#endif
#endif
static const struct i2c_device_id tc300k_id[] = {
{TC300K_NAME, 0},
{ }
};
MODULE_DEVICE_TABLE(i2c, tc300k_id);
static struct i2c_driver tc300k_driver = {
.probe = tc300k_probe,
.remove = __devexit_p(tc300k_remove),
.shutdown = tc300k_shutdown,
.driver = {
.name = TC300K_NAME,
.owner = THIS_MODULE,
#if 0
#if defined(CONFIG_PM) && !defined(CONFIG_HAS_EARLYSUSPEND)
.pm = &tc370_pm_ops,
#endif
#endif
},
.id_table = tc300k_id,
};
