1 | // SPDX-License-Identifier: GPL-2.0 |
2 | // Samsung S6SY761 Touchscreen device driver |
3 | // |
4 | // Copyright (c) 2017 Samsung Electronics Co., Ltd. |
5 | // Copyright (c) 2017 Andi Shyti <andi@etezian.org> |
6 | |
7 | #include <asm/unaligned.h> |
8 | #include <linux/delay.h> |
9 | #include <linux/i2c.h> |
10 | #include <linux/input/mt.h> |
11 | #include <linux/input/touchscreen.h> |
12 | #include <linux/interrupt.h> |
13 | #include <linux/irq.h> |
14 | #include <linux/module.h> |
15 | #include <linux/pm_runtime.h> |
16 | #include <linux/regulator/consumer.h> |
17 | |
18 | /* commands */ |
19 | #define S6SY761_SENSE_ON 0x10 |
20 | #define S6SY761_SENSE_OFF 0x11 |
21 | #define S6SY761_TOUCH_FUNCTION 0x30 /* R/W for get/set */ |
22 | #define S6SY761_FIRMWARE_INTEGRITY 0x21 |
23 | #define S6SY761_PANEL_INFO 0x23 |
24 | #define S6SY761_DEVICE_ID 0x52 |
25 | #define S6SY761_BOOT_STATUS 0x55 |
26 | #define S6SY761_READ_ONE_EVENT 0x60 |
27 | #define S6SY761_READ_ALL_EVENT 0x61 |
28 | #define S6SY761_CLEAR_EVENT_STACK 0x62 |
29 | #define S6SY761_APPLICATION_MODE 0xe4 |
30 | |
31 | /* events */ |
32 | #define S6SY761_EVENT_INFO 0x02 |
33 | #define S6SY761_EVENT_VENDOR_INFO 0x07 |
34 | |
35 | /* info */ |
36 | #define S6SY761_INFO_BOOT_COMPLETE 0x00 |
37 | |
38 | /* firmware status */ |
39 | #define S6SY761_FW_OK 0x80 |
40 | |
41 | /* |
42 | * the functionalities are put as a reference |
43 | * as in the device I am using none of them |
44 | * works therefore not used in this driver yet. |
45 | */ |
46 | /* touchscreen functionalities */ |
47 | #define S6SY761_MASK_TOUCH BIT(0) |
48 | #define S6SY761_MASK_HOVER BIT(1) |
49 | #define S6SY761_MASK_COVER BIT(2) |
50 | #define S6SY761_MASK_GLOVE BIT(3) |
51 | #define S6SY761_MASK_STYLUS BIT(4) |
52 | #define S6SY761_MASK_PALM BIT(5) |
53 | #define S6SY761_MASK_WET BIT(6) |
54 | #define S6SY761_MASK_PROXIMITY BIT(7) |
55 | |
56 | /* boot status (BS) */ |
57 | #define S6SY761_BS_BOOT_LOADER 0x10 |
58 | #define S6SY761_BS_APPLICATION 0x20 |
59 | |
60 | /* event id */ |
61 | #define S6SY761_EVENT_ID_COORDINATE 0x00 |
62 | #define S6SY761_EVENT_ID_STATUS 0x01 |
63 | |
64 | /* event register masks */ |
65 | #define S6SY761_MASK_TOUCH_STATE 0xc0 /* byte 0 */ |
66 | #define S6SY761_MASK_TID 0x3c |
67 | #define S6SY761_MASK_EID 0x03 |
68 | #define S6SY761_MASK_X 0xf0 /* byte 3 */ |
69 | #define S6SY761_MASK_Y 0x0f |
70 | #define S6SY761_MASK_Z 0x3f /* byte 6 */ |
71 | #define S6SY761_MASK_LEFT_EVENTS 0x3f /* byte 7 */ |
72 | #define S6SY761_MASK_TOUCH_TYPE 0xc0 /* MSB in byte 6, LSB in byte 7 */ |
73 | |
74 | /* event touch state values */ |
75 | #define S6SY761_TS_NONE 0x00 |
76 | #define S6SY761_TS_PRESS 0x01 |
77 | #define S6SY761_TS_MOVE 0x02 |
78 | #define S6SY761_TS_RELEASE 0x03 |
79 | |
80 | /* application modes */ |
81 | #define S6SY761_APP_NORMAL 0x0 |
82 | #define S6SY761_APP_LOW_POWER 0x1 |
83 | #define S6SY761_APP_TEST 0x2 |
84 | #define S6SY761_APP_FLASH 0x3 |
85 | #define S6SY761_APP_SLEEP 0x4 |
86 | |
87 | #define S6SY761_EVENT_SIZE 8 |
88 | #define S6SY761_EVENT_COUNT 32 |
89 | #define S6SY761_DEVID_SIZE 3 |
90 | #define S6SY761_PANEL_ID_SIZE 11 |
91 | #define S6SY761_TS_STATUS_SIZE 5 |
92 | #define S6SY761_MAX_FINGERS 10 |
93 | |
94 | #define S6SY761_DEV_NAME "s6sy761" |
95 | |
96 | enum s6sy761_regulators { |
97 | S6SY761_REGULATOR_VDD, |
98 | S6SY761_REGULATOR_AVDD, |
99 | }; |
100 | |
101 | struct s6sy761_data { |
102 | struct i2c_client *client; |
103 | struct regulator_bulk_data regulators[2]; |
104 | struct input_dev *input; |
105 | struct touchscreen_properties prop; |
106 | |
107 | u8 data[S6SY761_EVENT_SIZE * S6SY761_EVENT_COUNT]; |
108 | |
109 | u16 devid; |
110 | u8 tx_channel; |
111 | }; |
112 | |
113 | /* |
114 | * We can't simply use i2c_smbus_read_i2c_block_data because we |
115 | * need to read more than 255 bytes |
116 | */ |
117 | static int s6sy761_read_events(struct s6sy761_data *sdata, u16 n_events) |
118 | { |
119 | u8 cmd = S6SY761_READ_ALL_EVENT; |
120 | struct i2c_msg msgs[2] = { |
121 | { |
122 | .addr = sdata->client->addr, |
123 | .len = 1, |
124 | .buf = &cmd, |
125 | }, |
126 | { |
127 | .addr = sdata->client->addr, |
128 | .flags = I2C_M_RD, |
129 | .len = (n_events * S6SY761_EVENT_SIZE), |
130 | .buf = sdata->data + S6SY761_EVENT_SIZE, |
131 | }, |
132 | }; |
133 | int ret; |
134 | |
135 | ret = i2c_transfer(adap: sdata->client->adapter, msgs, ARRAY_SIZE(msgs)); |
136 | if (ret < 0) |
137 | return ret; |
138 | |
139 | return ret == ARRAY_SIZE(msgs) ? 0 : -EIO; |
140 | } |
141 | |
142 | static void s6sy761_report_coordinates(struct s6sy761_data *sdata, |
143 | u8 *event, u8 tid) |
144 | { |
145 | u8 major = event[4]; |
146 | u8 minor = event[5]; |
147 | u8 z = event[6] & S6SY761_MASK_Z; |
148 | u16 x = (event[1] << 4) | ((event[3] & S6SY761_MASK_X) >> 4); |
149 | u16 y = (event[2] << 4) | (event[3] & S6SY761_MASK_Y); |
150 | |
151 | input_mt_slot(dev: sdata->input, slot: tid); |
152 | |
153 | input_mt_report_slot_state(dev: sdata->input, MT_TOOL_FINGER, active: true); |
154 | input_report_abs(dev: sdata->input, ABS_MT_POSITION_X, value: x); |
155 | input_report_abs(dev: sdata->input, ABS_MT_POSITION_Y, value: y); |
156 | input_report_abs(dev: sdata->input, ABS_MT_TOUCH_MAJOR, value: major); |
157 | input_report_abs(dev: sdata->input, ABS_MT_TOUCH_MINOR, value: minor); |
158 | input_report_abs(dev: sdata->input, ABS_MT_PRESSURE, value: z); |
159 | |
160 | input_sync(dev: sdata->input); |
161 | } |
162 | |
163 | static void s6sy761_report_release(struct s6sy761_data *sdata, |
164 | u8 *event, u8 tid) |
165 | { |
166 | input_mt_slot(dev: sdata->input, slot: tid); |
167 | input_mt_report_slot_state(dev: sdata->input, MT_TOOL_FINGER, active: false); |
168 | |
169 | input_sync(dev: sdata->input); |
170 | } |
171 | |
172 | static void s6sy761_handle_coordinates(struct s6sy761_data *sdata, u8 *event) |
173 | { |
174 | u8 tid; |
175 | u8 touch_state; |
176 | |
177 | if (unlikely(!(event[0] & S6SY761_MASK_TID))) |
178 | return; |
179 | |
180 | tid = ((event[0] & S6SY761_MASK_TID) >> 2) - 1; |
181 | touch_state = (event[0] & S6SY761_MASK_TOUCH_STATE) >> 6; |
182 | |
183 | switch (touch_state) { |
184 | |
185 | case S6SY761_TS_NONE: |
186 | break; |
187 | case S6SY761_TS_RELEASE: |
188 | s6sy761_report_release(sdata, event, tid); |
189 | break; |
190 | case S6SY761_TS_PRESS: |
191 | case S6SY761_TS_MOVE: |
192 | s6sy761_report_coordinates(sdata, event, tid); |
193 | break; |
194 | } |
195 | } |
196 | |
197 | static void s6sy761_handle_events(struct s6sy761_data *sdata, u8 n_events) |
198 | { |
199 | int i; |
200 | |
201 | for (i = 0; i < n_events; i++) { |
202 | u8 *event = &sdata->data[i * S6SY761_EVENT_SIZE]; |
203 | u8 event_id = event[0] & S6SY761_MASK_EID; |
204 | |
205 | if (!event[0]) |
206 | return; |
207 | |
208 | switch (event_id) { |
209 | |
210 | case S6SY761_EVENT_ID_COORDINATE: |
211 | s6sy761_handle_coordinates(sdata, event); |
212 | break; |
213 | |
214 | case S6SY761_EVENT_ID_STATUS: |
215 | break; |
216 | |
217 | default: |
218 | break; |
219 | } |
220 | } |
221 | } |
222 | |
223 | static irqreturn_t s6sy761_irq_handler(int irq, void *dev) |
224 | { |
225 | struct s6sy761_data *sdata = dev; |
226 | int ret; |
227 | u8 n_events; |
228 | |
229 | ret = i2c_smbus_read_i2c_block_data(client: sdata->client, |
230 | S6SY761_READ_ONE_EVENT, |
231 | S6SY761_EVENT_SIZE, |
232 | values: sdata->data); |
233 | if (ret < 0) { |
234 | dev_err(&sdata->client->dev, "failed to read events\n" ); |
235 | return IRQ_HANDLED; |
236 | } |
237 | |
238 | if (!sdata->data[0]) |
239 | return IRQ_HANDLED; |
240 | |
241 | n_events = sdata->data[7] & S6SY761_MASK_LEFT_EVENTS; |
242 | if (unlikely(n_events > S6SY761_EVENT_COUNT - 1)) |
243 | return IRQ_HANDLED; |
244 | |
245 | if (n_events) { |
246 | ret = s6sy761_read_events(sdata, n_events); |
247 | if (ret < 0) { |
248 | dev_err(&sdata->client->dev, "failed to read events\n" ); |
249 | return IRQ_HANDLED; |
250 | } |
251 | } |
252 | |
253 | s6sy761_handle_events(sdata, n_events: n_events + 1); |
254 | |
255 | return IRQ_HANDLED; |
256 | } |
257 | |
258 | static int s6sy761_input_open(struct input_dev *dev) |
259 | { |
260 | struct s6sy761_data *sdata = input_get_drvdata(dev); |
261 | |
262 | return i2c_smbus_write_byte(client: sdata->client, S6SY761_SENSE_ON); |
263 | } |
264 | |
265 | static void s6sy761_input_close(struct input_dev *dev) |
266 | { |
267 | struct s6sy761_data *sdata = input_get_drvdata(dev); |
268 | int ret; |
269 | |
270 | ret = i2c_smbus_write_byte(client: sdata->client, S6SY761_SENSE_OFF); |
271 | if (ret) |
272 | dev_err(&sdata->client->dev, "failed to turn off sensing\n" ); |
273 | } |
274 | |
275 | static ssize_t s6sy761_sysfs_devid(struct device *dev, |
276 | struct device_attribute *attr, char *buf) |
277 | { |
278 | struct s6sy761_data *sdata = dev_get_drvdata(dev); |
279 | |
280 | return sprintf(buf, fmt: "%#x\n" , sdata->devid); |
281 | } |
282 | |
283 | static DEVICE_ATTR(devid, 0444, s6sy761_sysfs_devid, NULL); |
284 | |
285 | static struct attribute *s6sy761_sysfs_attrs[] = { |
286 | &dev_attr_devid.attr, |
287 | NULL |
288 | }; |
289 | |
290 | static struct attribute_group s6sy761_attribute_group = { |
291 | .attrs = s6sy761_sysfs_attrs |
292 | }; |
293 | |
294 | static int s6sy761_power_on(struct s6sy761_data *sdata) |
295 | { |
296 | u8 buffer[S6SY761_EVENT_SIZE]; |
297 | u8 event; |
298 | int ret; |
299 | |
300 | ret = regulator_bulk_enable(ARRAY_SIZE(sdata->regulators), |
301 | consumers: sdata->regulators); |
302 | if (ret) |
303 | return ret; |
304 | |
305 | msleep(msecs: 140); |
306 | |
307 | /* double check whether the touch is functional */ |
308 | ret = i2c_smbus_read_i2c_block_data(client: sdata->client, |
309 | S6SY761_READ_ONE_EVENT, |
310 | S6SY761_EVENT_SIZE, |
311 | values: buffer); |
312 | if (ret < 0) |
313 | return ret; |
314 | |
315 | event = (buffer[0] >> 2) & 0xf; |
316 | |
317 | if ((event != S6SY761_EVENT_INFO && |
318 | event != S6SY761_EVENT_VENDOR_INFO) || |
319 | buffer[1] != S6SY761_INFO_BOOT_COMPLETE) { |
320 | return -ENODEV; |
321 | } |
322 | |
323 | ret = i2c_smbus_read_byte_data(client: sdata->client, S6SY761_BOOT_STATUS); |
324 | if (ret < 0) |
325 | return ret; |
326 | |
327 | /* for some reasons the device might be stuck in the bootloader */ |
328 | if (ret != S6SY761_BS_APPLICATION) |
329 | return -ENODEV; |
330 | |
331 | /* enable touch functionality */ |
332 | ret = i2c_smbus_write_word_data(client: sdata->client, |
333 | S6SY761_TOUCH_FUNCTION, |
334 | S6SY761_MASK_TOUCH); |
335 | if (ret) |
336 | return ret; |
337 | |
338 | return 0; |
339 | } |
340 | |
341 | static int s6sy761_hw_init(struct s6sy761_data *sdata, |
342 | unsigned int *max_x, unsigned int *max_y) |
343 | { |
344 | u8 buffer[S6SY761_PANEL_ID_SIZE]; /* larger read size */ |
345 | int ret; |
346 | |
347 | ret = s6sy761_power_on(sdata); |
348 | if (ret) |
349 | return ret; |
350 | |
351 | ret = i2c_smbus_read_i2c_block_data(client: sdata->client, |
352 | S6SY761_DEVICE_ID, |
353 | S6SY761_DEVID_SIZE, |
354 | values: buffer); |
355 | if (ret < 0) |
356 | return ret; |
357 | |
358 | sdata->devid = get_unaligned_be16(p: buffer + 1); |
359 | |
360 | ret = i2c_smbus_read_i2c_block_data(client: sdata->client, |
361 | S6SY761_PANEL_INFO, |
362 | S6SY761_PANEL_ID_SIZE, |
363 | values: buffer); |
364 | if (ret < 0) |
365 | return ret; |
366 | |
367 | *max_x = get_unaligned_be16(p: buffer); |
368 | *max_y = get_unaligned_be16(p: buffer + 2); |
369 | |
370 | /* if no tx channels defined, at least keep one */ |
371 | sdata->tx_channel = max_t(u8, buffer[8], 1); |
372 | |
373 | ret = i2c_smbus_read_byte_data(client: sdata->client, |
374 | S6SY761_FIRMWARE_INTEGRITY); |
375 | if (ret < 0) |
376 | return ret; |
377 | else if (ret != S6SY761_FW_OK) |
378 | return -ENODEV; |
379 | |
380 | return 0; |
381 | } |
382 | |
383 | static void s6sy761_power_off(void *data) |
384 | { |
385 | struct s6sy761_data *sdata = data; |
386 | |
387 | disable_irq(irq: sdata->client->irq); |
388 | regulator_bulk_disable(ARRAY_SIZE(sdata->regulators), |
389 | consumers: sdata->regulators); |
390 | } |
391 | |
392 | static int s6sy761_probe(struct i2c_client *client) |
393 | { |
394 | struct s6sy761_data *sdata; |
395 | unsigned int max_x, max_y; |
396 | int err; |
397 | |
398 | if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_I2C | |
399 | I2C_FUNC_SMBUS_BYTE_DATA | |
400 | I2C_FUNC_SMBUS_I2C_BLOCK)) |
401 | return -ENODEV; |
402 | |
403 | sdata = devm_kzalloc(dev: &client->dev, size: sizeof(*sdata), GFP_KERNEL); |
404 | if (!sdata) |
405 | return -ENOMEM; |
406 | |
407 | i2c_set_clientdata(client, data: sdata); |
408 | sdata->client = client; |
409 | |
410 | sdata->regulators[S6SY761_REGULATOR_VDD].supply = "vdd" ; |
411 | sdata->regulators[S6SY761_REGULATOR_AVDD].supply = "avdd" ; |
412 | err = devm_regulator_bulk_get(dev: &client->dev, |
413 | ARRAY_SIZE(sdata->regulators), |
414 | consumers: sdata->regulators); |
415 | if (err) |
416 | return err; |
417 | |
418 | err = devm_add_action_or_reset(&client->dev, s6sy761_power_off, sdata); |
419 | if (err) |
420 | return err; |
421 | |
422 | err = s6sy761_hw_init(sdata, max_x: &max_x, max_y: &max_y); |
423 | if (err) |
424 | return err; |
425 | |
426 | sdata->input = devm_input_allocate_device(&client->dev); |
427 | if (!sdata->input) |
428 | return -ENOMEM; |
429 | |
430 | sdata->input->name = S6SY761_DEV_NAME; |
431 | sdata->input->id.bustype = BUS_I2C; |
432 | sdata->input->open = s6sy761_input_open; |
433 | sdata->input->close = s6sy761_input_close; |
434 | |
435 | input_set_abs_params(dev: sdata->input, ABS_MT_POSITION_X, min: 0, max: max_x, fuzz: 0, flat: 0); |
436 | input_set_abs_params(dev: sdata->input, ABS_MT_POSITION_Y, min: 0, max: max_y, fuzz: 0, flat: 0); |
437 | input_set_abs_params(dev: sdata->input, ABS_MT_TOUCH_MAJOR, min: 0, max: 255, fuzz: 0, flat: 0); |
438 | input_set_abs_params(dev: sdata->input, ABS_MT_TOUCH_MINOR, min: 0, max: 255, fuzz: 0, flat: 0); |
439 | input_set_abs_params(dev: sdata->input, ABS_MT_TOUCH_MAJOR, min: 0, max: 255, fuzz: 0, flat: 0); |
440 | input_set_abs_params(dev: sdata->input, ABS_MT_TOUCH_MINOR, min: 0, max: 255, fuzz: 0, flat: 0); |
441 | input_set_abs_params(dev: sdata->input, ABS_MT_PRESSURE, min: 0, max: 255, fuzz: 0, flat: 0); |
442 | |
443 | touchscreen_parse_properties(input: sdata->input, multitouch: true, prop: &sdata->prop); |
444 | |
445 | if (!input_abs_get_max(dev: sdata->input, ABS_X) || |
446 | !input_abs_get_max(dev: sdata->input, ABS_Y)) { |
447 | dev_warn(&client->dev, "the axis have not been set\n" ); |
448 | } |
449 | |
450 | err = input_mt_init_slots(dev: sdata->input, num_slots: sdata->tx_channel, |
451 | INPUT_MT_DIRECT); |
452 | if (err) |
453 | return err; |
454 | |
455 | input_set_drvdata(dev: sdata->input, data: sdata); |
456 | |
457 | err = input_register_device(sdata->input); |
458 | if (err) |
459 | return err; |
460 | |
461 | err = devm_request_threaded_irq(dev: &client->dev, irq: client->irq, NULL, |
462 | thread_fn: s6sy761_irq_handler, |
463 | IRQF_TRIGGER_LOW | IRQF_ONESHOT, |
464 | devname: "s6sy761_irq" , dev_id: sdata); |
465 | if (err) |
466 | return err; |
467 | |
468 | err = devm_device_add_group(dev: &client->dev, grp: &s6sy761_attribute_group); |
469 | if (err) |
470 | return err; |
471 | |
472 | pm_runtime_enable(dev: &client->dev); |
473 | |
474 | return 0; |
475 | } |
476 | |
477 | static void s6sy761_remove(struct i2c_client *client) |
478 | { |
479 | pm_runtime_disable(dev: &client->dev); |
480 | } |
481 | |
482 | static int s6sy761_runtime_suspend(struct device *dev) |
483 | { |
484 | struct s6sy761_data *sdata = dev_get_drvdata(dev); |
485 | |
486 | return i2c_smbus_write_byte_data(client: sdata->client, |
487 | S6SY761_APPLICATION_MODE, S6SY761_APP_SLEEP); |
488 | } |
489 | |
490 | static int s6sy761_runtime_resume(struct device *dev) |
491 | { |
492 | struct s6sy761_data *sdata = dev_get_drvdata(dev); |
493 | |
494 | return i2c_smbus_write_byte_data(client: sdata->client, |
495 | S6SY761_APPLICATION_MODE, S6SY761_APP_NORMAL); |
496 | } |
497 | |
498 | static int s6sy761_suspend(struct device *dev) |
499 | { |
500 | struct s6sy761_data *sdata = dev_get_drvdata(dev); |
501 | |
502 | s6sy761_power_off(data: sdata); |
503 | |
504 | return 0; |
505 | } |
506 | |
507 | static int s6sy761_resume(struct device *dev) |
508 | { |
509 | struct s6sy761_data *sdata = dev_get_drvdata(dev); |
510 | |
511 | enable_irq(irq: sdata->client->irq); |
512 | |
513 | return s6sy761_power_on(sdata); |
514 | } |
515 | |
516 | static const struct dev_pm_ops s6sy761_pm_ops = { |
517 | SYSTEM_SLEEP_PM_OPS(s6sy761_suspend, s6sy761_resume) |
518 | RUNTIME_PM_OPS(s6sy761_runtime_suspend, s6sy761_runtime_resume, NULL) |
519 | }; |
520 | |
521 | #ifdef CONFIG_OF |
522 | static const struct of_device_id s6sy761_of_match[] = { |
523 | { .compatible = "samsung,s6sy761" , }, |
524 | { }, |
525 | }; |
526 | MODULE_DEVICE_TABLE(of, s6sy761_of_match); |
527 | #endif |
528 | |
529 | static const struct i2c_device_id s6sy761_id[] = { |
530 | { "s6sy761" , 0 }, |
531 | { }, |
532 | }; |
533 | MODULE_DEVICE_TABLE(i2c, s6sy761_id); |
534 | |
535 | static struct i2c_driver s6sy761_driver = { |
536 | .driver = { |
537 | .name = S6SY761_DEV_NAME, |
538 | .of_match_table = of_match_ptr(s6sy761_of_match), |
539 | .pm = pm_ptr(&s6sy761_pm_ops), |
540 | }, |
541 | .probe = s6sy761_probe, |
542 | .remove = s6sy761_remove, |
543 | .id_table = s6sy761_id, |
544 | }; |
545 | |
546 | module_i2c_driver(s6sy761_driver); |
547 | |
548 | MODULE_AUTHOR("Andi Shyti <andi.shyti@samsung.com>" ); |
549 | MODULE_DESCRIPTION("Samsung S6SY761 Touch Screen" ); |
550 | MODULE_LICENSE("GPL v2" ); |
551 | |