1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/gpio/consumer.h>
21#include <linux/interrupt.h>
22#include <linux/i2c.h>
23#include <linux/input.h>
24#include <linux/input/mt.h>
25#include <linux/input/touchscreen.h>
26#include <linux/module.h>
27#include <linux/of.h>
28#include <linux/delay.h>
29
30
31#define EKTF2127_NOISE 0x40
32#define EKTF2127_RESPONSE 0x52
33#define EKTF2127_REQUEST 0x53
34#define EKTF2127_HELLO 0x55
35#define EKTF2127_REPORT 0x5d
36#define EKTF2127_CALIB_DONE 0x66
37
38
39#define EKTF2127_ENV_NOISY 0x41
40#define EKTF2127_HEIGHT 0x60
41#define EKTF2127_WIDTH 0x63
42
43
44#define EKTF2127_TOUCH_REPORT_SIZE 21
45#define EKTF2127_MAX_TOUCHES 5
46
47struct ektf2127_ts {
48 struct i2c_client *client;
49 struct input_dev *input;
50 struct gpio_desc *power_gpios;
51 struct touchscreen_properties prop;
52};
53
54static void ektf2127_parse_coordinates(const u8* buf, unsigned int touch_count,
55 struct input_mt_pos *touches)
56{
57 int index = 0;
58 int i;
59
60 for (i = 0; i < touch_count; i++) {
61 index = 2 + i * 3;
62
63 touches[i].x = (buf[index] & 0x0f);
64 touches[i].x <<= 8;
65 touches[i].x |= buf[index + 2];
66
67 touches[i].y = (buf[index] & 0xf0);
68 touches[i].y <<= 4;
69 touches[i].y |= buf[index + 1];
70 }
71}
72
73static void ektf2127_report_event(struct ektf2127_ts *ts, const u8 *buf)
74{
75 struct input_mt_pos touches[EKTF2127_MAX_TOUCHES];
76 int slots[EKTF2127_MAX_TOUCHES];
77 unsigned int touch_count, i;
78
79 touch_count = buf[1] & 0x07;
80 if (touch_count > EKTF2127_MAX_TOUCHES) {
81 dev_err(&ts->client->dev,
82 "Too many touches %d > %d\n",
83 touch_count, EKTF2127_MAX_TOUCHES);
84 touch_count = EKTF2127_MAX_TOUCHES;
85 }
86
87 ektf2127_parse_coordinates(buf, touch_count, touches);
88 input_mt_assign_slots(ts->input, slots, touches,
89 touch_count, 0);
90
91 for (i = 0; i < touch_count; i++) {
92 input_mt_slot(ts->input, slots[i]);
93 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
94 touchscreen_report_pos(ts->input, &ts->prop,
95 touches[i].x, touches[i].y, true);
96 }
97
98 input_mt_sync_frame(ts->input);
99 input_sync(ts->input);
100}
101
102static irqreturn_t ektf2127_irq(int irq, void *dev_id)
103{
104 struct ektf2127_ts *ts = dev_id;
105 struct device *dev = &ts->client->dev;
106 char buf[EKTF2127_TOUCH_REPORT_SIZE];
107 int ret;
108
109 ret = i2c_master_recv(ts->client, buf, EKTF2127_TOUCH_REPORT_SIZE);
110 if (ret != EKTF2127_TOUCH_REPORT_SIZE) {
111 dev_err(dev, "Error reading touch data: %d\n", ret);
112 goto out;
113 }
114
115 switch (buf[0]) {
116 case EKTF2127_REPORT:
117 ektf2127_report_event(ts, buf);
118 break;
119
120 case EKTF2127_NOISE:
121 if (buf[1] == EKTF2127_ENV_NOISY)
122 dev_dbg(dev, "Environment is electrically noisy\n");
123 break;
124
125 case EKTF2127_HELLO:
126 case EKTF2127_CALIB_DONE:
127 break;
128
129 default:
130 dev_err(dev, "Unexpected packet header byte %#02x\n", buf[0]);
131 break;
132 }
133
134out:
135 return IRQ_HANDLED;
136}
137
138static int ektf2127_start(struct input_dev *dev)
139{
140 struct ektf2127_ts *ts = input_get_drvdata(dev);
141
142 enable_irq(ts->client->irq);
143 gpiod_set_value_cansleep(ts->power_gpios, 1);
144
145 return 0;
146}
147
148static void ektf2127_stop(struct input_dev *dev)
149{
150 struct ektf2127_ts *ts = input_get_drvdata(dev);
151
152 disable_irq(ts->client->irq);
153 gpiod_set_value_cansleep(ts->power_gpios, 0);
154}
155
156static int __maybe_unused ektf2127_suspend(struct device *dev)
157{
158 struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev));
159
160 mutex_lock(&ts->input->mutex);
161 if (ts->input->users)
162 ektf2127_stop(ts->input);
163 mutex_unlock(&ts->input->mutex);
164
165 return 0;
166}
167
168static int __maybe_unused ektf2127_resume(struct device *dev)
169{
170 struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev));
171
172 mutex_lock(&ts->input->mutex);
173 if (ts->input->users)
174 ektf2127_start(ts->input);
175 mutex_unlock(&ts->input->mutex);
176
177 return 0;
178}
179
180static SIMPLE_DEV_PM_OPS(ektf2127_pm_ops, ektf2127_suspend,
181 ektf2127_resume);
182
183static int ektf2127_query_dimension(struct i2c_client *client, bool width)
184{
185 struct device *dev = &client->dev;
186 const char *what = width ? "width" : "height";
187 u8 what_code = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT;
188 u8 buf[4];
189 int ret;
190 int error;
191
192
193 buf[0] = EKTF2127_REQUEST;
194 buf[1] = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT;
195 buf[2] = 0x00;
196 buf[3] = 0x00;
197 ret = i2c_master_send(client, buf, sizeof(buf));
198 if (ret != sizeof(buf)) {
199 error = ret < 0 ? ret : -EIO;
200 dev_err(dev, "Failed to request %s: %d\n", what, error);
201 return error;
202 }
203
204 msleep(20);
205
206
207 ret = i2c_master_recv(client, buf, sizeof(buf));
208 if (ret != sizeof(buf)) {
209 error = ret < 0 ? ret : -EIO;
210 dev_err(dev, "Failed to receive %s data: %d\n", what, error);
211 return error;
212 }
213
214 if (buf[0] != EKTF2127_RESPONSE || buf[1] != what_code) {
215 dev_err(dev, "Unexpected %s data: %#02x %#02x\n",
216 what, buf[0], buf[1]);
217 return -EIO;
218 }
219
220 return (((buf[3] & 0xf0) << 4) | buf[2]) - 1;
221}
222
223static int ektf2127_probe(struct i2c_client *client,
224 const struct i2c_device_id *id)
225{
226 struct device *dev = &client->dev;
227 struct ektf2127_ts *ts;
228 struct input_dev *input;
229 u8 buf[4];
230 int max_x, max_y;
231 int error;
232
233 if (!client->irq) {
234 dev_err(dev, "Error no irq specified\n");
235 return -EINVAL;
236 }
237
238 ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
239 if (!ts)
240 return -ENOMEM;
241
242
243 ts->power_gpios = devm_gpiod_get(dev, "power", GPIOD_OUT_HIGH);
244 if (IS_ERR(ts->power_gpios)) {
245 error = PTR_ERR(ts->power_gpios);
246 if (error != -EPROBE_DEFER)
247 dev_err(dev, "Error getting power gpio: %d\n", error);
248 return error;
249 }
250
251 input = devm_input_allocate_device(dev);
252 if (!input)
253 return -ENOMEM;
254
255 input->name = client->name;
256 input->id.bustype = BUS_I2C;
257 input->open = ektf2127_start;
258 input->close = ektf2127_stop;
259
260 ts->client = client;
261
262
263 msleep(20);
264 i2c_master_recv(ts->client, buf, sizeof(buf));
265
266
267 max_x = ektf2127_query_dimension(client, true);
268 if (max_x < 0)
269 return max_x;
270
271 max_y = ektf2127_query_dimension(client, false);
272 if (max_y < 0)
273 return max_y;
274
275 input_set_abs_params(input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
276 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
277 touchscreen_parse_properties(input, true, &ts->prop);
278
279 error = input_mt_init_slots(input, EKTF2127_MAX_TOUCHES,
280 INPUT_MT_DIRECT |
281 INPUT_MT_DROP_UNUSED |
282 INPUT_MT_TRACK);
283 if (error)
284 return error;
285
286 ts->input = input;
287 input_set_drvdata(input, ts);
288
289 error = devm_request_threaded_irq(dev, client->irq,
290 NULL, ektf2127_irq,
291 IRQF_ONESHOT, client->name, ts);
292 if (error) {
293 dev_err(dev, "Error requesting irq: %d\n", error);
294 return error;
295 }
296
297
298 ektf2127_stop(ts->input);
299
300 error = input_register_device(input);
301 if (error)
302 return error;
303
304 i2c_set_clientdata(client, ts);
305
306 return 0;
307}
308
309#ifdef CONFIG_OF
310static const struct of_device_id ektf2127_of_match[] = {
311 { .compatible = "elan,ektf2127" },
312 {}
313};
314MODULE_DEVICE_TABLE(of, ektf2127_of_match);
315#endif
316
317static const struct i2c_device_id ektf2127_i2c_id[] = {
318 { "ektf2127", 0 },
319 {}
320};
321MODULE_DEVICE_TABLE(i2c, ektf2127_i2c_id);
322
323static struct i2c_driver ektf2127_driver = {
324 .driver = {
325 .name = "elan_ektf2127",
326 .pm = &ektf2127_pm_ops,
327 .of_match_table = of_match_ptr(ektf2127_of_match),
328 },
329 .probe = ektf2127_probe,
330 .id_table = ektf2127_i2c_id,
331};
332module_i2c_driver(ektf2127_driver);
333
334MODULE_DESCRIPTION("ELAN eKTF2127 I2C Touchscreen Driver");
335MODULE_AUTHOR("Michel Verlaan, Siebren Vroegindeweij");
336MODULE_LICENSE("GPL");
337
