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