1/*
  2 * Driver for ELAN eKTF2127 i2c touchscreen controller
  3 *
  4 * For this driver the layout of the Chipone icn8318 i2c
  5 * touchscreencontroller is used.
  6 *
  7 * This program is free software; you can redistribute it and/or modify
  8 * it under the terms of the GNU General Public License as published by
  9 * the Free Software Foundation; either version 2 of the License, or
 10 * (at your option) any later version.
 11 *
 12 * Author:
 13 * Michel Verlaan <michel.verl@gmail.com>
 14 * Siebren Vroegindeweij <siebren.vroegindeweij@hotmail.com>
 15 *
 16 * Original chipone_icn8318 driver:
 17 * Hans de Goede <hdegoede@redhat.com>
 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/* Packet header defines (first byte of data send / received) */
 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/* Register defines (second byte of data send / received) */
 39#define EKTF2127_ENV_NOISY		0x41
 40#define EKTF2127_HEIGHT			0x60
 41#define EKTF2127_WIDTH			0x63
 42
 43/* 2 bytes header + 5 * 3 bytes coordinates + 3 bytes pressure info + footer */
 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	/* Request dimension */
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	/* Read response */
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	/* This requests the gpio *and* turns on the touchscreen controller */
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	/* Read hello (ignore result, depends on initial power state) */
263	msleep(20);
264	i2c_master_recv(ts->client, buf, sizeof(buf));
265
266	/* Read resolution from chip */
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	/* Stop device till opened */
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");