xref: /linux/drivers/input/touchscreen/st1232.c (revision 25aee3debe0464f6c680173041fa3de30ec9ff54)
1 /*
2  * ST1232 Touchscreen Controller Driver
3  *
4  * Copyright (C) 2010 Renesas Solutions Corp.
5  *	Tony SIM <chinyeow.sim.xt@renesas.com>
6  *
7  * Using code from:
8  *  - android.git.kernel.org: projects/kernel/common.git: synaptics_i2c_rmi.c
9  *	Copyright (C) 2007 Google, Inc.
10  *
11  * This software is licensed under the terms of the GNU General Public
12  * License version 2, as published by the Free Software Foundation, and
13  * may be copied, distributed, and modified under those terms.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  */
20 
21 #include <linux/delay.h>
22 #include <linux/i2c.h>
23 #include <linux/input.h>
24 #include <linux/interrupt.h>
25 #include <linux/module.h>
26 #include <linux/pm_qos.h>
27 #include <linux/slab.h>
28 #include <linux/types.h>
29 
30 #define ST1232_TS_NAME	"st1232-ts"
31 
32 #define MIN_X		0x00
33 #define MIN_Y		0x00
34 #define MAX_X		0x31f	/* (800 - 1) */
35 #define MAX_Y		0x1df	/* (480 - 1) */
36 #define MAX_AREA	0xff
37 #define MAX_FINGERS	2
38 
39 struct st1232_ts_finger {
40 	u16 x;
41 	u16 y;
42 	u8 t;
43 	bool is_valid;
44 };
45 
46 struct st1232_ts_data {
47 	struct i2c_client *client;
48 	struct input_dev *input_dev;
49 	struct st1232_ts_finger finger[MAX_FINGERS];
50 	struct dev_pm_qos_request low_latency_req;
51 };
52 
53 static int st1232_ts_read_data(struct st1232_ts_data *ts)
54 {
55 	struct st1232_ts_finger *finger = ts->finger;
56 	struct i2c_client *client = ts->client;
57 	struct i2c_msg msg[2];
58 	int error;
59 	u8 start_reg;
60 	u8 buf[10];
61 
62 	/* read touchscreen data from ST1232 */
63 	msg[0].addr = client->addr;
64 	msg[0].flags = 0;
65 	msg[0].len = 1;
66 	msg[0].buf = &start_reg;
67 	start_reg = 0x10;
68 
69 	msg[1].addr = ts->client->addr;
70 	msg[1].flags = I2C_M_RD;
71 	msg[1].len = sizeof(buf);
72 	msg[1].buf = buf;
73 
74 	error = i2c_transfer(client->adapter, msg, 2);
75 	if (error < 0)
76 		return error;
77 
78 	/* get "valid" bits */
79 	finger[0].is_valid = buf[2] >> 7;
80 	finger[1].is_valid = buf[5] >> 7;
81 
82 	/* get xy coordinate */
83 	if (finger[0].is_valid) {
84 		finger[0].x = ((buf[2] & 0x0070) << 4) | buf[3];
85 		finger[0].y = ((buf[2] & 0x0007) << 8) | buf[4];
86 		finger[0].t = buf[8];
87 	}
88 
89 	if (finger[1].is_valid) {
90 		finger[1].x = ((buf[5] & 0x0070) << 4) | buf[6];
91 		finger[1].y = ((buf[5] & 0x0007) << 8) | buf[7];
92 		finger[1].t = buf[9];
93 	}
94 
95 	return 0;
96 }
97 
98 static irqreturn_t st1232_ts_irq_handler(int irq, void *dev_id)
99 {
100 	struct st1232_ts_data *ts = dev_id;
101 	struct st1232_ts_finger *finger = ts->finger;
102 	struct input_dev *input_dev = ts->input_dev;
103 	int count = 0;
104 	int i, ret;
105 
106 	ret = st1232_ts_read_data(ts);
107 	if (ret < 0)
108 		goto end;
109 
110 	/* multi touch protocol */
111 	for (i = 0; i < MAX_FINGERS; i++) {
112 		if (!finger[i].is_valid)
113 			continue;
114 
115 		input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, finger[i].t);
116 		input_report_abs(input_dev, ABS_MT_POSITION_X, finger[i].x);
117 		input_report_abs(input_dev, ABS_MT_POSITION_Y, finger[i].y);
118 		input_mt_sync(input_dev);
119 		count++;
120 	}
121 
122 	/* SYN_MT_REPORT only if no contact */
123 	if (!count) {
124 		input_mt_sync(input_dev);
125 		if (ts->low_latency_req.dev) {
126 			dev_pm_qos_remove_request(&ts->low_latency_req);
127 			ts->low_latency_req.dev = NULL;
128 		}
129 	} else if (!ts->low_latency_req.dev) {
130 		/* First contact, request 100 us latency. */
131 		dev_pm_qos_add_ancestor_request(&ts->client->dev,
132 						&ts->low_latency_req, 100);
133 	}
134 
135 	/* SYN_REPORT */
136 	input_sync(input_dev);
137 
138 end:
139 	return IRQ_HANDLED;
140 }
141 
142 static int __devinit st1232_ts_probe(struct i2c_client *client,
143 					const struct i2c_device_id *id)
144 {
145 	struct st1232_ts_data *ts;
146 	struct input_dev *input_dev;
147 	int error;
148 
149 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
150 		dev_err(&client->dev, "need I2C_FUNC_I2C\n");
151 		return -EIO;
152 	}
153 
154 	if (!client->irq) {
155 		dev_err(&client->dev, "no IRQ?\n");
156 		return -EINVAL;
157 	}
158 
159 
160 	ts = kzalloc(sizeof(struct st1232_ts_data), GFP_KERNEL);
161 	input_dev = input_allocate_device();
162 	if (!ts || !input_dev) {
163 		error = -ENOMEM;
164 		goto err_free_mem;
165 	}
166 
167 	ts->client = client;
168 	ts->input_dev = input_dev;
169 
170 	input_dev->name = "st1232-touchscreen";
171 	input_dev->id.bustype = BUS_I2C;
172 	input_dev->dev.parent = &client->dev;
173 
174 	__set_bit(EV_SYN, input_dev->evbit);
175 	__set_bit(EV_KEY, input_dev->evbit);
176 	__set_bit(EV_ABS, input_dev->evbit);
177 
178 	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
179 	input_set_abs_params(input_dev, ABS_MT_POSITION_X, MIN_X, MAX_X, 0, 0);
180 	input_set_abs_params(input_dev, ABS_MT_POSITION_Y, MIN_Y, MAX_Y, 0, 0);
181 
182 	error = request_threaded_irq(client->irq, NULL, st1232_ts_irq_handler,
183 				     IRQF_ONESHOT, client->name, ts);
184 	if (error) {
185 		dev_err(&client->dev, "Failed to register interrupt\n");
186 		goto err_free_mem;
187 	}
188 
189 	error = input_register_device(ts->input_dev);
190 	if (error) {
191 		dev_err(&client->dev, "Unable to register %s input device\n",
192 			input_dev->name);
193 		goto err_free_irq;
194 	}
195 
196 	i2c_set_clientdata(client, ts);
197 	device_init_wakeup(&client->dev, 1);
198 
199 	return 0;
200 
201 err_free_irq:
202 	free_irq(client->irq, ts);
203 err_free_mem:
204 	input_free_device(input_dev);
205 	kfree(ts);
206 	return error;
207 }
208 
209 static int __devexit st1232_ts_remove(struct i2c_client *client)
210 {
211 	struct st1232_ts_data *ts = i2c_get_clientdata(client);
212 
213 	device_init_wakeup(&client->dev, 0);
214 	free_irq(client->irq, ts);
215 	input_unregister_device(ts->input_dev);
216 	kfree(ts);
217 
218 	return 0;
219 }
220 
221 #ifdef CONFIG_PM_SLEEP
222 static int st1232_ts_suspend(struct device *dev)
223 {
224 	struct i2c_client *client = to_i2c_client(dev);
225 
226 	if (device_may_wakeup(&client->dev))
227 		enable_irq_wake(client->irq);
228 	else
229 		disable_irq(client->irq);
230 
231 	return 0;
232 }
233 
234 static int st1232_ts_resume(struct device *dev)
235 {
236 	struct i2c_client *client = to_i2c_client(dev);
237 
238 	if (device_may_wakeup(&client->dev))
239 		disable_irq_wake(client->irq);
240 	else
241 		enable_irq(client->irq);
242 
243 	return 0;
244 }
245 
246 #endif
247 
248 static SIMPLE_DEV_PM_OPS(st1232_ts_pm_ops,
249 			 st1232_ts_suspend, st1232_ts_resume);
250 
251 static const struct i2c_device_id st1232_ts_id[] = {
252 	{ ST1232_TS_NAME, 0 },
253 	{ }
254 };
255 MODULE_DEVICE_TABLE(i2c, st1232_ts_id);
256 
257 #ifdef CONFIG_OF
258 static const struct of_device_id st1232_ts_dt_ids[] __devinitconst = {
259 	{ .compatible = "sitronix,st1232", },
260 	{ }
261 };
262 MODULE_DEVICE_TABLE(of, st1232_ts_dt_ids);
263 #endif
264 
265 static struct i2c_driver st1232_ts_driver = {
266 	.probe		= st1232_ts_probe,
267 	.remove		= __devexit_p(st1232_ts_remove),
268 	.id_table	= st1232_ts_id,
269 	.driver = {
270 		.name	= ST1232_TS_NAME,
271 		.owner	= THIS_MODULE,
272 		.of_match_table = of_match_ptr(st1232_ts_dt_ids),
273 		.pm	= &st1232_ts_pm_ops,
274 	},
275 };
276 
277 module_i2c_driver(st1232_ts_driver);
278 
279 MODULE_AUTHOR("Tony SIM <chinyeow.sim.xt@renesas.com>");
280 MODULE_DESCRIPTION("SITRONIX ST1232 Touchscreen Controller Driver");
281 MODULE_LICENSE("GPL");
282