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