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
96enum s6sy761_regulators {
97	S6SY761_REGULATOR_VDD,
98	S6SY761_REGULATOR_AVDD,
99};
100
101struct 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 */
117static 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(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
142static 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(sdata->input, tid);
152
153	input_mt_report_slot_state(sdata->input, MT_TOOL_FINGER, true);
154	input_report_abs(sdata->input, ABS_MT_POSITION_X, x);
155	input_report_abs(sdata->input, ABS_MT_POSITION_Y, y);
156	input_report_abs(sdata->input, ABS_MT_TOUCH_MAJOR, major);
157	input_report_abs(sdata->input, ABS_MT_TOUCH_MINOR, minor);
158	input_report_abs(sdata->input, ABS_MT_PRESSURE, z);
159
160	input_sync(sdata->input);
161}
162
163static void s6sy761_report_release(struct s6sy761_data *sdata,
164				   u8 *event, u8 tid)
165{
166	input_mt_slot(sdata->input, tid);
167	input_mt_report_slot_state(sdata->input, MT_TOOL_FINGER, false);
168
169	input_sync(sdata->input);
170}
171
172static 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
197static 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
223static 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(sdata->client,
230					    S6SY761_READ_ONE_EVENT,
231					    S6SY761_EVENT_SIZE,
232					    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 +  1);
254
255	return IRQ_HANDLED;
256}
257
258static 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(sdata->client, S6SY761_SENSE_ON);
263}
264
265static 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(sdata->client, S6SY761_SENSE_OFF);
271	if (ret)
272		dev_err(&sdata->client->dev, "failed to turn off sensing\n");
273}
274
275static 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, "%#x\n", sdata->devid);
281}
282
283static DEVICE_ATTR(devid, 0444, s6sy761_sysfs_devid, NULL);
284
285static struct attribute *s6sy761_sysfs_attrs[] = {
286	&dev_attr_devid.attr,
287	NULL
288};
289ATTRIBUTE_GROUPS(s6sy761_sysfs);
290
291static int s6sy761_power_on(struct s6sy761_data *sdata)
292{
293	u8 buffer[S6SY761_EVENT_SIZE];
294	u8 event;
295	int ret;
296
297	ret = regulator_bulk_enable(ARRAY_SIZE(sdata->regulators),
298				    sdata->regulators);
299	if (ret)
300		return ret;
301
302	msleep(140);
303
304	/* double check whether the touch is functional */
305	ret = i2c_smbus_read_i2c_block_data(sdata->client,
306					    S6SY761_READ_ONE_EVENT,
307					    S6SY761_EVENT_SIZE,
308					    buffer);
309	if (ret < 0)
310		return ret;
311
312	event = (buffer[0] >> 2) & 0xf;
313
314	if ((event != S6SY761_EVENT_INFO &&
315	     event != S6SY761_EVENT_VENDOR_INFO) ||
316	    buffer[1] != S6SY761_INFO_BOOT_COMPLETE) {
317		return -ENODEV;
318	}
319
320	ret = i2c_smbus_read_byte_data(sdata->client, S6SY761_BOOT_STATUS);
321	if (ret < 0)
322		return ret;
323
324	/* for some reasons the device might be stuck in the bootloader */
325	if (ret != S6SY761_BS_APPLICATION)
326		return -ENODEV;
327
328	/* enable touch functionality */
329	ret = i2c_smbus_write_word_data(sdata->client,
330					S6SY761_TOUCH_FUNCTION,
331					S6SY761_MASK_TOUCH);
332	if (ret)
333		return ret;
334
335	return 0;
336}
337
338static int s6sy761_hw_init(struct s6sy761_data *sdata,
339			   unsigned int *max_x, unsigned int *max_y)
340{
341	u8 buffer[S6SY761_PANEL_ID_SIZE]; /* larger read size */
342	int ret;
343
344	ret = s6sy761_power_on(sdata);
345	if (ret)
346		return ret;
347
348	ret = i2c_smbus_read_i2c_block_data(sdata->client,
349					    S6SY761_DEVICE_ID,
350					    S6SY761_DEVID_SIZE,
351					    buffer);
352	if (ret < 0)
353		return ret;
354
355	sdata->devid = get_unaligned_be16(buffer + 1);
356
357	ret = i2c_smbus_read_i2c_block_data(sdata->client,
358					    S6SY761_PANEL_INFO,
359					    S6SY761_PANEL_ID_SIZE,
360					    buffer);
361	if (ret < 0)
362		return ret;
363
364	*max_x = get_unaligned_be16(buffer);
365	*max_y = get_unaligned_be16(buffer + 2);
366
367	/* if no tx channels defined, at least keep one */
368	sdata->tx_channel = max_t(u8, buffer[8], 1);
369
370	ret = i2c_smbus_read_byte_data(sdata->client,
371				       S6SY761_FIRMWARE_INTEGRITY);
372	if (ret < 0)
373		return ret;
374	else if (ret != S6SY761_FW_OK)
375		return -ENODEV;
376
377	return 0;
378}
379
380static void s6sy761_power_off(void *data)
381{
382	struct s6sy761_data *sdata = data;
383
384	disable_irq(sdata->client->irq);
385	regulator_bulk_disable(ARRAY_SIZE(sdata->regulators),
386						sdata->regulators);
387}
388
389static int s6sy761_probe(struct i2c_client *client)
390{
391	struct s6sy761_data *sdata;
392	unsigned int max_x, max_y;
393	int err;
394
395	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
396						I2C_FUNC_SMBUS_BYTE_DATA |
397						I2C_FUNC_SMBUS_I2C_BLOCK))
398		return -ENODEV;
399
400	sdata = devm_kzalloc(&client->dev, sizeof(*sdata), GFP_KERNEL);
401	if (!sdata)
402		return -ENOMEM;
403
404	i2c_set_clientdata(client, sdata);
405	sdata->client = client;
406
407	sdata->regulators[S6SY761_REGULATOR_VDD].supply = "vdd";
408	sdata->regulators[S6SY761_REGULATOR_AVDD].supply = "avdd";
409	err = devm_regulator_bulk_get(&client->dev,
410				      ARRAY_SIZE(sdata->regulators),
411				      sdata->regulators);
412	if (err)
413		return err;
414
415	err = devm_add_action_or_reset(&client->dev, s6sy761_power_off, sdata);
416	if (err)
417		return err;
418
419	err = s6sy761_hw_init(sdata, &max_x, &max_y);
420	if (err)
421		return err;
422
423	sdata->input = devm_input_allocate_device(&client->dev);
424	if (!sdata->input)
425		return -ENOMEM;
426
427	sdata->input->name = S6SY761_DEV_NAME;
428	sdata->input->id.bustype = BUS_I2C;
429	sdata->input->open = s6sy761_input_open;
430	sdata->input->close = s6sy761_input_close;
431
432	input_set_abs_params(sdata->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
433	input_set_abs_params(sdata->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
434	input_set_abs_params(sdata->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
435	input_set_abs_params(sdata->input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
436	input_set_abs_params(sdata->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
437	input_set_abs_params(sdata->input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
438	input_set_abs_params(sdata->input, ABS_MT_PRESSURE, 0, 255, 0, 0);
439
440	touchscreen_parse_properties(sdata->input, true, &sdata->prop);
441
442	if (!input_abs_get_max(sdata->input, ABS_X) ||
443	    !input_abs_get_max(sdata->input, ABS_Y)) {
444		dev_warn(&client->dev, "the axis have not been set\n");
445	}
446
447	err = input_mt_init_slots(sdata->input, sdata->tx_channel,
448				  INPUT_MT_DIRECT);
449	if (err)
450		return err;
451
452	input_set_drvdata(sdata->input, sdata);
453
454	err = input_register_device(sdata->input);
455	if (err)
456		return err;
457
458	err = devm_request_threaded_irq(&client->dev, client->irq, NULL,
459					s6sy761_irq_handler,
460					IRQF_TRIGGER_LOW | IRQF_ONESHOT,
461					"s6sy761_irq", sdata);
462	if (err)
463		return err;
464
465	pm_runtime_enable(&client->dev);
466
467	return 0;
468}
469
470static void s6sy761_remove(struct i2c_client *client)
471{
472	pm_runtime_disable(&client->dev);
473}
474
475static int s6sy761_runtime_suspend(struct device *dev)
476{
477	struct s6sy761_data *sdata = dev_get_drvdata(dev);
478
479	return i2c_smbus_write_byte_data(sdata->client,
480				S6SY761_APPLICATION_MODE, S6SY761_APP_SLEEP);
481}
482
483static int s6sy761_runtime_resume(struct device *dev)
484{
485	struct s6sy761_data *sdata = dev_get_drvdata(dev);
486
487	return i2c_smbus_write_byte_data(sdata->client,
488				S6SY761_APPLICATION_MODE, S6SY761_APP_NORMAL);
489}
490
491static int s6sy761_suspend(struct device *dev)
492{
493	struct s6sy761_data *sdata = dev_get_drvdata(dev);
494
495	s6sy761_power_off(sdata);
496
497	return 0;
498}
499
500static int s6sy761_resume(struct device *dev)
501{
502	struct s6sy761_data *sdata = dev_get_drvdata(dev);
503
504	enable_irq(sdata->client->irq);
505
506	return s6sy761_power_on(sdata);
507}
508
509static const struct dev_pm_ops s6sy761_pm_ops = {
510	SYSTEM_SLEEP_PM_OPS(s6sy761_suspend, s6sy761_resume)
511	RUNTIME_PM_OPS(s6sy761_runtime_suspend, s6sy761_runtime_resume, NULL)
512};
513
514#ifdef CONFIG_OF
515static const struct of_device_id s6sy761_of_match[] = {
516	{ .compatible = "samsung,s6sy761", },
517	{ },
518};
519MODULE_DEVICE_TABLE(of, s6sy761_of_match);
520#endif
521
522static const struct i2c_device_id s6sy761_id[] = {
523	{ "s6sy761", 0 },
524	{ },
525};
526MODULE_DEVICE_TABLE(i2c, s6sy761_id);
527
528static struct i2c_driver s6sy761_driver = {
529	.driver = {
530		.name = S6SY761_DEV_NAME,
531		.dev_groups = s6sy761_sysfs_groups,
532		.of_match_table = of_match_ptr(s6sy761_of_match),
533		.pm = pm_ptr(&s6sy761_pm_ops),
534	},
535	.probe = s6sy761_probe,
536	.remove = s6sy761_remove,
537	.id_table = s6sy761_id,
538};
539
540module_i2c_driver(s6sy761_driver);
541
542MODULE_AUTHOR("Andi Shyti <andi.shyti@samsung.com>");
543MODULE_DESCRIPTION("Samsung S6SY761 Touch Screen");
544MODULE_LICENSE("GPL v2");
545