Skip to content

L
linux
Commit 261314a9 authored by Pavel Machek's avatar Pavel Machek Committed by Greg Kroah-Hartman
Browse files
Options

Staging: HTC Dream: Cleanup Dream touchscreen driver 

This is first part of touchscreen cleanups. I did not remove
earlysuspend functionality for now (to help Google merge the changes).

I mainly introduced helpers to reduce code duplication, and split huge
functions into smaller ones.
Signed-off-by: default avatarPavel Machek <pavel@ucw.cz>
Cc: Arve Hjønnevåg <arve@android.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 2e4d2af9
Show whitespace changes
Inline Side-by-side
Showing with 180 additions and 182 deletions
drivers/staging/dream/synaptics_i2c_rmi.c
View file @ 261314a9
/* drivers/input/keyboard/synaptics_i2c_rmi.c
/*
* Support for synaptics touchscreen.
*
* Copyright (C) 2007 Google, Inc.
* Author: Arve Hjønnevåg <arve@android.com>
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
......@@ -15,6 +17,9 @@
#include <linux/module.h>
#include <linux/delay.h>
#ifdef CONFIG_HAS_EARLYSUSPEND
#include <linux/earlysuspend.h>
#endif
#include <linux/hrtimer.h>
#include <linux/i2c.h>
#include <linux/input.h>
......@@ -23,18 +28,16 @@
#include <linux/platform_device.h>
#include "synaptics_i2c_rmi.h"
#define swap(x, y) do { typeof(x) z = x; x = y; y = z; } while (0)
static struct workqueue_struct *synaptics_wq;
struct synaptics_ts_data {
uint16_t addr;
u16 addr;
struct i2c_client *client;
struct input_dev *input_dev;
int use_irq;
struct hrtimer timer;
struct work_struct work;
uint16_t max[2];
u16 max[2];
int snap_state[2][2];
int snap_down_on[2];
int snap_down_off[2];
......@@ -42,13 +45,28 @@ struct synaptics_ts_data {
int snap_up_off[2];
int snap_down[2];
int snap_up[2];
uint32_t flags;
u32 flags;
int (*power)(int on);
#ifdef CONFIG_HAS_EARLYSUSPEND
struct early_suspend early_suspend;
#endif
};
static int i2c_set(struct synaptics_ts_data *ts, u8 reg, u8 val, char *msg)
{
int ret = i2c_smbus_write_byte_data(ts->client, reg, val);
if (ret < 0)
pr_err("i2c_smbus_write_byte_data failed (%s)\n", msg);
return ret;
}
static int i2c_read(struct synaptics_ts_data *ts, u8 reg, char *msg)
{
int ret = i2c_smbus_read_byte_data(ts->client, reg);
if (ret < 0)
pr_err("i2c_smbus_read_byte_data failed (%s)\n", msg);
return ret;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
static void synaptics_ts_early_suspend(struct early_suspend *h);
static void synaptics_ts_late_resume(struct early_suspend *h);
......@@ -58,106 +76,30 @@ static int synaptics_init_panel(struct synaptics_ts_data *ts)
{
int ret;
ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x10); /* page select = 0x10 */
if (ret < 0) {
printk(KERN_ERR "i2c_smbus_write_byte_data failed for page select\n");
goto err_page_select_failed;
}
ret = i2c_smbus_write_byte_data(ts->client, 0x41, 0x04); /* Set "No Clip Z" */
if (ret < 0)
printk(KERN_ERR "i2c_smbus_write_byte_data failed for No Clip Z\n");
ret = i2c_set(ts, 0xff, 0x10, "set page select");
if (ret == 0)
ret = i2c_set(ts, 0x41, 0x04, "set No Clip Z");
err_page_select_failed:
ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x04); /* page select = 0x04 */
if (ret < 0)
printk(KERN_ERR "i2c_smbus_write_byte_data failed for page select\n");
ret = i2c_smbus_write_byte_data(ts->client, 0xf0, 0x81); /* normal operation, 80 reports per second */
if (ret < 0)
printk(KERN_ERR "synaptics_ts_resume: i2c_smbus_write_byte_data failed\n");
ret = i2c_set(ts, 0xff, 0x04, "fallback page select");
ret = i2c_set(ts, 0xf0, 0x81, "select 80 reports per second");
return ret;
}
static void synaptics_ts_work_func(struct work_struct *work)
static void decode_report(struct synaptics_ts_data *ts, u8 *buf)
{
int i;
int ret;
int bad_data = 0;
struct i2c_msg msg[2];
uint8_t start_reg;
uint8_t buf[15];
struct synaptics_ts_data *ts = container_of(work, struct synaptics_ts_data, work);
msg[0].addr = ts->client->addr;
msg[0].flags = 0;
msg[0].len = 1;
msg[0].buf = &start_reg;
start_reg = 0x00;
msg[1].addr = ts->client->addr;
msg[1].flags = I2C_M_RD;
msg[1].len = sizeof(buf);
msg[1].buf = buf;
/* printk("synaptics_ts_work_func\n"); */
for (i = 0; i < ((ts->use_irq && !bad_data) ? 1 : 10); i++) {
ret = i2c_transfer(ts->client->adapter, msg, 2);
if (ret < 0) {
printk(KERN_ERR "synaptics_ts_work_func: i2c_transfer failed\n");
bad_data = 1;
} else {
/* printk("synaptics_ts_work_func: %x %x %x %x %x %x" */
/* " %x %x %x %x %x %x %x %x %x, ret %d\n", */
/* buf[0], buf[1], buf[2], buf[3], */
/* buf[4], buf[5], buf[6], buf[7], */
/* buf[8], buf[9], buf[10], buf[11], */
/* buf[12], buf[13], buf[14], ret); */
if ((buf[14] & 0xc0) != 0x40) {
printk(KERN_WARNING "synaptics_ts_work_func:"
" bad read %x %x %x %x %x %x %x %x %x"
" %x %x %x %x %x %x, ret %d\n",
buf[0], buf[1], buf[2], buf[3],
buf[4], buf[5], buf[6], buf[7],
buf[8], buf[9], buf[10], buf[11],
buf[12], buf[13], buf[14], ret);
if (bad_data)
synaptics_init_panel(ts);
bad_data = 1;
continue;
}
bad_data = 0;
if ((buf[14] & 1) == 0) {
/* printk("read %d coordinates\n", i); */
break;
} else {
int pos[2][2];
int f, a;
int base;
/* int x = buf[3] | (uint16_t)(buf[2] & 0x1f) << 8; */
/* int y = buf[5] | (uint16_t)(buf[4] & 0x1f) << 8; */
int base = 2;
int z = buf[1];
int w = buf[0] >> 4;
int finger = buf[0] & 7;
/* int x2 = buf[3+6] | (uint16_t)(buf[2+6] & 0x1f) << 8; */
/* int y2 = buf[5+6] | (uint16_t)(buf[4+6] & 0x1f) << 8; */
/* int z2 = buf[1+6]; */
/* int w2 = buf[0+6] >> 4; */
/* int finger2 = buf[0+6] & 7; */
/* int dx = (int8_t)buf[12]; */
/* int dy = (int8_t)buf[13]; */
int finger2_pressed;
/* printk("x %4d, y %4d, z %3d, w %2d, F %d, 2nd: x %4d, y %4d, z %3d, w %2d, F %d, dx %4d, dy %4d\n", */
/* x, y, z, w, finger, */
/* x2, y2, z2, w2, finger2, */
/* dx, dy); */
base = 2;
for (f = 0; f < 2; f++) {
uint32_t flip_flag = SYNAPTICS_FLIP_X;
u32 flip_flag = SYNAPTICS_FLIP_X;
for (a = 0; a < 2; a++) {
int p = buf[base + 1];
p |= (uint16_t)(buf[base] & 0x1f) << 8;
p |= (u16)(buf[base] & 0x1f) << 8;
if (ts->flags & flip_flag)
p = ts->max[a] - p;
if (ts->flags & SYNAPTICS_SNAP_TO_INACTIVE_EDGE) {
......@@ -200,8 +142,53 @@ static void synaptics_ts_work_func(struct work_struct *work)
input_report_abs(ts->input_dev, ABS_HAT0Y, pos[1][1]);
}
input_sync(ts->input_dev);
}
static void synaptics_ts_work_func(struct work_struct *work)
{
int i;
int ret;
int bad_data = 0;
struct i2c_msg msg[2];
u8 start_reg = 0;
u8 buf[15];
struct synaptics_ts_data *ts =
container_of(work, struct synaptics_ts_data, work);
msg[0].addr = ts->client->addr;
msg[0].flags = 0;
msg[0].len = 1;
msg[0].buf = &start_reg;
msg[1].addr = ts->client->addr;
msg[1].flags = I2C_M_RD;
msg[1].len = sizeof(buf);
msg[1].buf = buf;
for (i = 0; i < ((ts->use_irq && !bad_data) ? 1 : 10); i++) {
ret = i2c_transfer(ts->client->adapter, msg, 2);
if (ret < 0) {
pr_err("ts_work: i2c_transfer failed\n");
bad_data = 1;
continue;
}
if ((buf[14] & 0xc0) != 0x40) {
pr_warning("synaptics_ts_work_func:"
" bad read %x %x %x %x %x %x %x %x %x"
" %x %x %x %x %x %x, ret %d\n",
buf[0], buf[1], buf[2], buf[3],
buf[4], buf[5], buf[6], buf[7],
buf[8], buf[9], buf[10], buf[11],
buf[12], buf[13], buf[14], ret);
if (bad_data)
synaptics_init_panel(ts);
bad_data = 1;
continue;
}
bad_data = 0;
if ((buf[14] & 1) == 0)
break;
decode_report(ts, buf);
}
if (ts->use_irq)
enable_irq(ts->client->irq);
......@@ -209,8 +196,8 @@ static void synaptics_ts_work_func(struct work_struct *work)
static enum hrtimer_restart synaptics_ts_timer_func(struct hrtimer *timer)
{
struct synaptics_ts_data *ts = container_of(timer, struct synaptics_ts_data, timer);
/* printk("synaptics_ts_timer_func\n"); */
struct synaptics_ts_data *ts =
container_of(timer, struct synaptics_ts_data, timer);
queue_work(synaptics_wq, &ts->work);
......@@ -222,12 +209,46 @@ static irqreturn_t synaptics_ts_irq_handler(int irq, void *dev_id)
{
struct synaptics_ts_data *ts = dev_id;
/* printk("synaptics_ts_irq_handler\n"); */
disable_irq(ts->client->irq);
disable_irq_nosync(ts->client->irq);
queue_work(synaptics_wq, &ts->work);
return IRQ_HANDLED;
}
static int detect(struct synaptics_ts_data *ts, u32 *panel_version)
{
int ret;
int retry = 10;
ret = i2c_set(ts, 0xf4, 0x01, "reset device");
while (retry-- > 0) {
ret = i2c_smbus_read_byte_data(ts->client, 0xe4);
if (ret >= 0)
break;
msleep(100);
}
if (ret < 0) {
pr_err("i2c_smbus_read_byte_data failed\n");
return ret;
}
*panel_version = ret << 8;
ret = i2c_read(ts, 0xe5, "product minor");
if (ret < 0)
return ret;
*panel_version |= ret;
ret = i2c_read(ts, 0xe3, "property");
if (ret < 0)
return ret;
pr_info("synaptics: version %x, product property %x\n",
*panel_version, ret);
return 0;
}
static struct synaptics_i2c_rmi_platform_data fake_pdata;
static int synaptics_ts_probe(
struct i2c_client *client, const struct i2c_device_id *id)
{
......@@ -251,7 +272,7 @@ static int synaptics_ts_probe(
int snap_top_off;
int snap_bottom_on;
int snap_bottom_off;
uint32_t panel_version;
uint32_t panel_version = 0;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
printk(KERN_ERR "synaptics_ts_probe: need I2C_FUNC_I2C\n");
......@@ -270,48 +291,21 @@ static int synaptics_ts_probe(
pdata = client->dev.platform_data;
if (pdata)
ts->power = pdata->power;
else
pdata = &fake_pdata;
if (ts->power) {
ret = ts->power(1);
if (ret < 0) {
printk(KERN_ERR "synaptics_ts_probe power on failed\n");
pr_err("synaptics_ts_probe power on failed\n");
goto err_power_failed;
}
}
ret = i2c_smbus_write_byte_data(ts->client, 0xf4, 0x01); /* device command = reset */
if (ret < 0) {
printk(KERN_ERR "i2c_smbus_write_byte_data failed\n");
/* fail? */
}
{
int retry = 10;
while (retry-- > 0) {
ret = i2c_smbus_read_byte_data(ts->client, 0xe4);
if (ret >= 0)
break;
msleep(100);
}
}
if (ret < 0) {
printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
goto err_detect_failed;
}
printk(KERN_INFO "synaptics_ts_probe: Product Major Version %x\n", ret);
panel_version = ret << 8;
ret = i2c_smbus_read_byte_data(ts->client, 0xe5);
if (ret < 0) {
printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
ret = detect(ts, &panel_version);
if (ret)
goto err_detect_failed;
}
printk(KERN_INFO "synaptics_ts_probe: Product Minor Version %x\n", ret);
panel_version |= ret;
ret = i2c_smbus_read_byte_data(ts->client, 0xe3);
if (ret < 0) {
printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
goto err_detect_failed;
}
printk(KERN_INFO "synaptics_ts_probe: product property %x\n", ret);
if (pdata) {
while (pdata->version > panel_version)
......@@ -397,29 +391,30 @@ static int synaptics_ts_probe(
}
ret = i2c_smbus_read_word_data(ts->client, 0x04);
if (ret < 0) {
printk(KERN_ERR "i2c_smbus_read_word_data failed\n");
pr_err("i2c_smbus_read_word_data failed\n");
goto err_detect_failed;
}
ts->max[0] = max_x = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8);
ret = i2c_smbus_read_word_data(ts->client, 0x06);
if (ret < 0) {
printk(KERN_ERR "i2c_smbus_read_word_data failed\n");
pr_err("i2c_smbus_read_word_data failed\n");
goto err_detect_failed;
}
ts->max[1] = max_y = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8);
if (ts->flags & SYNAPTICS_SWAP_XY)
swap(max_x, max_y);
ret = synaptics_init_panel(ts); /* will also switch back to page 0x04 */
/* will also switch back to page 0x04 */
ret = synaptics_init_panel(ts);
if (ret < 0) {
printk(KERN_ERR "synaptics_init_panel failed\n");
pr_err("synaptics_init_panel failed\n");
goto err_detect_failed;
}
ts->input_dev = input_allocate_device();
if (ts->input_dev == NULL) {
ret = -ENOMEM;
printk(KERN_ERR "synaptics_ts_probe: Failed to allocate input device\n");
pr_err("synaptics: Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
ts->input_dev->name = "synaptics-rmi-touchscreen";
......@@ -497,7 +492,8 @@ static int synaptics_ts_probe(
register_early_suspend(&ts->early_suspend);
#endif
printk(KERN_INFO "synaptics_ts_probe: Start touchscreen %s in %s mode\n", ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");
pr_info("synaptics: Start touchscreen %s in %s mode\n",
ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");
return 0;
......@@ -528,6 +524,7 @@ static int synaptics_ts_remove(struct i2c_client *client)
return 0;
}
#ifdef CONFIG_PM
static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
{
int ret;
......@@ -540,17 +537,13 @@ static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
ret = cancel_work_sync(&ts->work);
if (ret && ts->use_irq) /* if work was pending disable-count is now 2 */
enable_irq(client->irq);
ret = i2c_smbus_write_byte_data(ts->client, 0xf1, 0); /* disable interrupt */
if (ret < 0)
printk(KERN_ERR "synaptics_ts_suspend: i2c_smbus_write_byte_data failed\n");
i2c_set(ts, 0xf1, 0, "disable interrupt");
i2c_set(ts, 0xf0, 0x86, "deep sleep");
ret = i2c_smbus_write_byte_data(client, 0xf0, 0x86); /* deep sleep */
if (ret < 0)
printk(KERN_ERR "synaptics_ts_suspend: i2c_smbus_write_byte_data failed\n");
if (ts->power) {
ret = ts->power(0);
if (ret < 0)
printk(KERN_ERR "synaptics_ts_resume power off failed\n");
pr_err("synaptics_ts_suspend power off failed\n");
}
return 0;
}
......@@ -563,18 +556,16 @@ static int synaptics_ts_resume(struct i2c_client *client)
if (ts->power) {
ret = ts->power(1);
if (ret < 0)
printk(KERN_ERR "synaptics_ts_resume power on failed\n");
pr_err("synaptics_ts_resume power on failed\n");
}
synaptics_init_panel(ts);
if (ts->use_irq)
if (ts->use_irq) {
enable_irq(client->irq);
if (!ts->use_irq)
i2c_set(ts, 0xf1, 0x01, "enable abs int");
} else
hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
else
i2c_smbus_write_byte_data(ts->client, 0xf1, 0x01); /* enable abs int */
return 0;
}
......@@ -594,6 +585,12 @@ static void synaptics_ts_late_resume(struct early_suspend *h)
synaptics_ts_resume(ts->client);
}
#endif
#else
#define synaptics_ts_suspend NULL
#define synaptics_ts_resume NULL
#endif
static const struct i2c_device_id synaptics_ts_id[] = {
{ SYNAPTICS_I2C_RMI_NAME, 0 },
......@@ -633,3 +630,4 @@ module_exit(synaptics_ts_exit);
MODULE_DESCRIPTION("Synaptics Touchscreen Driver");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Arve Hjønnevåg <arve@android.com>");
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7