1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/delay.h>
22#include <linux/gpio.h>
23#include <linux/i2c.h>
24#include <linux/input.h>
25#include <linux/interrupt.h>
26#include <linux/module.h>
27#include <linux/of.h>
28#include <linux/of_gpio.h>
29#include <linux/pm_qos.h>
30#include <linux/slab.h>
31#include <linux/types.h>
32#include <linux/platform_data/st1232_pdata.h>
33
34#define ST1232_TS_NAME "st1232-ts"
35
36#define MIN_X 0x00
37#define MIN_Y 0x00
38#define MAX_X 0x31f
39#define MAX_Y 0x1df
40#define MAX_AREA 0xff
41#define MAX_FINGERS 2
42
43struct st1232_ts_finger {
44 u16 x;
45 u16 y;
46 u8 t;
47 bool is_valid;
48};
49
50struct st1232_ts_data {
51 struct i2c_client *client;
52 struct input_dev *input_dev;
53 struct st1232_ts_finger finger[MAX_FINGERS];
54 struct dev_pm_qos_request low_latency_req;
55 int reset_gpio;
56};
57
58static int st1232_ts_read_data(struct st1232_ts_data *ts)
59{
60 struct st1232_ts_finger *finger = ts->finger;
61 struct i2c_client *client = ts->client;
62 struct i2c_msg msg[2];
63 int error;
64 u8 start_reg;
65 u8 buf[10];
66
67
68 msg[0].addr = client->addr;
69 msg[0].flags = 0;
70 msg[0].len = 1;
71 msg[0].buf = &start_reg;
72 start_reg = 0x10;
73
74 msg[1].addr = ts->client->addr;
75 msg[1].flags = I2C_M_RD;
76 msg[1].len = sizeof(buf);
77 msg[1].buf = buf;
78
79 error = i2c_transfer(client->adapter, msg, 2);
80 if (error < 0)
81 return error;
82
83
84 finger[0].is_valid = buf[2] >> 7;
85 finger[1].is_valid = buf[5] >> 7;
86
87
88 if (finger[0].is_valid) {
89 finger[0].x = ((buf[2] & 0x0070) << 4) | buf[3];
90 finger[0].y = ((buf[2] & 0x0007) << 8) | buf[4];
91 finger[0].t = buf[8];
92 }
93
94 if (finger[1].is_valid) {
95 finger[1].x = ((buf[5] & 0x0070) << 4) | buf[6];
96 finger[1].y = ((buf[5] & 0x0007) << 8) | buf[7];
97 finger[1].t = buf[9];
98 }
99
100 return 0;
101}
102
103static irqreturn_t st1232_ts_irq_handler(int irq, void *dev_id)
104{
105 struct st1232_ts_data *ts = dev_id;
106 struct st1232_ts_finger *finger = ts->finger;
107 struct input_dev *input_dev = ts->input_dev;
108 int count = 0;
109 int i, ret;
110
111 ret = st1232_ts_read_data(ts);
112 if (ret < 0)
113 goto end;
114
115
116 for (i = 0; i < MAX_FINGERS; i++) {
117 if (!finger[i].is_valid)
118 continue;
119
120 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, finger[i].t);
121 input_report_abs(input_dev, ABS_MT_POSITION_X, finger[i].x);
122 input_report_abs(input_dev, ABS_MT_POSITION_Y, finger[i].y);
123 input_mt_sync(input_dev);
124 count++;
125 }
126
127
128 if (!count) {
129 input_mt_sync(input_dev);
130 if (ts->low_latency_req.dev) {
131 dev_pm_qos_remove_request(&ts->low_latency_req);
132 ts->low_latency_req.dev = NULL;
133 }
134 } else if (!ts->low_latency_req.dev) {
135
136 dev_pm_qos_add_ancestor_request(&ts->client->dev,
137 &ts->low_latency_req,
138 DEV_PM_QOS_RESUME_LATENCY, 100);
139 }
140
141
142 input_sync(input_dev);
143
144end:
145 return IRQ_HANDLED;
146}
147
148static void st1232_ts_power(struct st1232_ts_data *ts, bool poweron)
149{
150 if (gpio_is_valid(ts->reset_gpio))
151 gpio_direction_output(ts->reset_gpio, poweron);
152}
153
154static int st1232_ts_probe(struct i2c_client *client,
155 const struct i2c_device_id *id)
156{
157 struct st1232_ts_data *ts;
158 struct st1232_pdata *pdata = dev_get_platdata(&client->dev);
159 struct input_dev *input_dev;
160 int error;
161
162 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
163 dev_err(&client->dev, "need I2C_FUNC_I2C\n");
164 return -EIO;
165 }
166
167 if (!client->irq) {
168 dev_err(&client->dev, "no IRQ?\n");
169 return -EINVAL;
170 }
171
172 ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
173 if (!ts)
174 return -ENOMEM;
175
176 input_dev = devm_input_allocate_device(&client->dev);
177 if (!input_dev)
178 return -ENOMEM;
179
180 ts->client = client;
181 ts->input_dev = input_dev;
182
183 if (pdata)
184 ts->reset_gpio = pdata->reset_gpio;
185 else if (client->dev.of_node)
186 ts->reset_gpio = of_get_gpio(client->dev.of_node, 0);
187 else
188 ts->reset_gpio = -ENODEV;
189
190 if (gpio_is_valid(ts->reset_gpio)) {
191 error = devm_gpio_request(&client->dev, ts->reset_gpio, NULL);
192 if (error) {
193 dev_err(&client->dev,
194 "Unable to request GPIO pin %d.\n",
195 ts->reset_gpio);
196 return error;
197 }
198 }
199
200 st1232_ts_power(ts, true);
201
202 input_dev->name = "st1232-touchscreen";
203 input_dev->id.bustype = BUS_I2C;
204 input_dev->dev.parent = &client->dev;
205
206 __set_bit(EV_SYN, input_dev->evbit);
207 __set_bit(EV_KEY, input_dev->evbit);
208 __set_bit(EV_ABS, input_dev->evbit);
209
210 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
211 input_set_abs_params(input_dev, ABS_MT_POSITION_X, MIN_X, MAX_X, 0, 0);
212 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, MIN_Y, MAX_Y, 0, 0);
213
214 error = devm_request_threaded_irq(&client->dev, client->irq,
215 NULL, st1232_ts_irq_handler,
216 IRQF_ONESHOT,
217 client->name, ts);
218 if (error) {
219 dev_err(&client->dev, "Failed to register interrupt\n");
220 return error;
221 }
222
223 error = input_register_device(ts->input_dev);
224 if (error) {
225 dev_err(&client->dev, "Unable to register %s input device\n",
226 input_dev->name);
227 return error;
228 }
229
230 i2c_set_clientdata(client, ts);
231 device_init_wakeup(&client->dev, 1);
232
233 return 0;
234}
235
236static int st1232_ts_remove(struct i2c_client *client)
237{
238 struct st1232_ts_data *ts = i2c_get_clientdata(client);
239
240 st1232_ts_power(ts, false);
241
242 return 0;
243}
244
245static int __maybe_unused st1232_ts_suspend(struct device *dev)
246{
247 struct i2c_client *client = to_i2c_client(dev);
248 struct st1232_ts_data *ts = i2c_get_clientdata(client);
249
250 if (device_may_wakeup(&client->dev)) {
251 enable_irq_wake(client->irq);
252 } else {
253 disable_irq(client->irq);
254 st1232_ts_power(ts, false);
255 }
256
257 return 0;
258}
259
260static int __maybe_unused st1232_ts_resume(struct device *dev)
261{
262 struct i2c_client *client = to_i2c_client(dev);
263 struct st1232_ts_data *ts = i2c_get_clientdata(client);
264
265 if (device_may_wakeup(&client->dev)) {
266 disable_irq_wake(client->irq);
267 } else {
268 st1232_ts_power(ts, true);
269 enable_irq(client->irq);
270 }
271
272 return 0;
273}
274
275static SIMPLE_DEV_PM_OPS(st1232_ts_pm_ops,
276 st1232_ts_suspend, st1232_ts_resume);
277
278static const struct i2c_device_id st1232_ts_id[] = {
279 { ST1232_TS_NAME, 0 },
280 { }
281};
282MODULE_DEVICE_TABLE(i2c, st1232_ts_id);
283
284#ifdef CONFIG_OF
285static const struct of_device_id st1232_ts_dt_ids[] = {
286 { .compatible = "sitronix,st1232", },
287 { }
288};
289MODULE_DEVICE_TABLE(of, st1232_ts_dt_ids);
290#endif
291
292static struct i2c_driver st1232_ts_driver = {
293 .probe = st1232_ts_probe,
294 .remove = st1232_ts_remove,
295 .id_table = st1232_ts_id,
296 .driver = {
297 .name = ST1232_TS_NAME,
298 .of_match_table = of_match_ptr(st1232_ts_dt_ids),
299 .pm = &st1232_ts_pm_ops,
300 },
301};
302
303module_i2c_driver(st1232_ts_driver);
304
305MODULE_AUTHOR("Tony SIM <chinyeow.sim.xt@renesas.com>");
306MODULE_DESCRIPTION("SITRONIX ST1232 Touchscreen Controller Driver");
307MODULE_LICENSE("GPL");
308
