1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Driver for Pixcir I2C touchscreen controllers.
4  *
5  * Copyright (C) 2010-2011 Pixcir, Inc.
6  */
7 
8 #include <linux/delay.h>
9 #include <linux/module.h>
10 #include <linux/interrupt.h>
11 #include <linux/slab.h>
12 #include <linux/i2c.h>
13 #include <linux/input.h>
14 #include <linux/input/mt.h>
15 #include <linux/input/touchscreen.h>
16 #include <linux/gpio.h>
17 #include <linux/gpio/consumer.h>
18 #include <linux/of_device.h>
19 #include <linux/platform_data/pixcir_i2c_ts.h>
20 #include <asm/unaligned.h>
21 
22 #define PIXCIR_MAX_SLOTS       5 /* Max fingers supported by driver */
23 
24 struct pixcir_i2c_ts_data {
25 	struct i2c_client *client;
26 	struct input_dev *input;
27 	struct gpio_desc *gpio_attb;
28 	struct gpio_desc *gpio_reset;
29 	struct gpio_desc *gpio_enable;
30 	struct gpio_desc *gpio_wake;
31 	const struct pixcir_i2c_chip_data *chip;
32 	struct touchscreen_properties prop;
33 	int max_fingers;	/* Max fingers supported in this instance */
34 	bool running;
35 };
36 
37 struct pixcir_report_data {
38 	int num_touches;
39 	struct input_mt_pos pos[PIXCIR_MAX_SLOTS];
40 	int ids[PIXCIR_MAX_SLOTS];
41 };
42 
43 static void pixcir_ts_parse(struct pixcir_i2c_ts_data *tsdata,
44 			    struct pixcir_report_data *report)
45 {
46 	u8 rdbuf[2 + PIXCIR_MAX_SLOTS * 5];
47 	u8 wrbuf[1] = { 0 };
48 	u8 *bufptr;
49 	u8 touch;
50 	int ret, i;
51 	int readsize;
52 	const struct pixcir_i2c_chip_data *chip = tsdata->chip;
53 
54 	memset(report, 0, sizeof(struct pixcir_report_data));
55 
56 	i = chip->has_hw_ids ? 1 : 0;
57 	readsize = 2 + tsdata->max_fingers * (4 + i);
58 	if (readsize > sizeof(rdbuf))
59 		readsize = sizeof(rdbuf);
60 
61 	ret = i2c_master_send(tsdata->client, wrbuf, sizeof(wrbuf));
62 	if (ret != sizeof(wrbuf)) {
63 		dev_err(&tsdata->client->dev,
64 			"%s: i2c_master_send failed(), ret=%d\n",
65 			__func__, ret);
66 		return;
67 	}
68 
69 	ret = i2c_master_recv(tsdata->client, rdbuf, readsize);
70 	if (ret != readsize) {
71 		dev_err(&tsdata->client->dev,
72 			"%s: i2c_master_recv failed(), ret=%d\n",
73 			__func__, ret);
74 		return;
75 	}
76 
77 	touch = rdbuf[0] & 0x7;
78 	if (touch > tsdata->max_fingers)
79 		touch = tsdata->max_fingers;
80 
81 	report->num_touches = touch;
82 	bufptr = &rdbuf[2];
83 
84 	for (i = 0; i < touch; i++) {
85 		touchscreen_set_mt_pos(&report->pos[i], &tsdata->prop,
86 				       get_unaligned_le16(bufptr),
87 				       get_unaligned_le16(bufptr + 2));
88 		if (chip->has_hw_ids) {
89 			report->ids[i] = bufptr[4];
90 			bufptr = bufptr + 5;
91 		} else {
92 			bufptr = bufptr + 4;
93 		}
94 	}
95 }
96 
97 static void pixcir_ts_report(struct pixcir_i2c_ts_data *ts,
98 			     struct pixcir_report_data *report)
99 {
100 	int slots[PIXCIR_MAX_SLOTS];
101 	int n, i, slot;
102 	struct device *dev = &ts->client->dev;
103 	const struct pixcir_i2c_chip_data *chip = ts->chip;
104 
105 	n = report->num_touches;
106 	if (n > PIXCIR_MAX_SLOTS)
107 		n = PIXCIR_MAX_SLOTS;
108 
109 	if (!ts->chip->has_hw_ids)
110 		input_mt_assign_slots(ts->input, slots, report->pos, n, 0);
111 
112 	for (i = 0; i < n; i++) {
113 		if (chip->has_hw_ids) {
114 			slot = input_mt_get_slot_by_key(ts->input,
115 							report->ids[i]);
116 			if (slot < 0) {
117 				dev_dbg(dev, "no free slot for id 0x%x\n",
118 					report->ids[i]);
119 				continue;
120 			}
121 		} else {
122 			slot = slots[i];
123 		}
124 
125 		input_mt_slot(ts->input, slot);
126 		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
127 
128 		input_report_abs(ts->input, ABS_MT_POSITION_X,
129 				 report->pos[i].x);
130 		input_report_abs(ts->input, ABS_MT_POSITION_Y,
131 				 report->pos[i].y);
132 
133 		dev_dbg(dev, "%d: slot %d, x %d, y %d\n",
134 			i, slot, report->pos[i].x, report->pos[i].y);
135 	}
136 
137 	input_mt_sync_frame(ts->input);
138 	input_sync(ts->input);
139 }
140 
141 static irqreturn_t pixcir_ts_isr(int irq, void *dev_id)
142 {
143 	struct pixcir_i2c_ts_data *tsdata = dev_id;
144 	struct pixcir_report_data report;
145 
146 	while (tsdata->running) {
147 		/* parse packet */
148 		pixcir_ts_parse(tsdata, &report);
149 
150 		/* report it */
151 		pixcir_ts_report(tsdata, &report);
152 
153 		if (gpiod_get_value_cansleep(tsdata->gpio_attb)) {
154 			if (report.num_touches) {
155 				/*
156 				 * Last report with no finger up?
157 				 * Do it now then.
158 				 */
159 				input_mt_sync_frame(tsdata->input);
160 				input_sync(tsdata->input);
161 			}
162 			break;
163 		}
164 
165 		msleep(20);
166 	}
167 
168 	return IRQ_HANDLED;
169 }
170 
171 static void pixcir_reset(struct pixcir_i2c_ts_data *tsdata)
172 {
173 	if (!IS_ERR_OR_NULL(tsdata->gpio_reset)) {
174 		gpiod_set_value_cansleep(tsdata->gpio_reset, 1);
175 		ndelay(100);	/* datasheet section 1.2.3 says 80ns min. */
176 		gpiod_set_value_cansleep(tsdata->gpio_reset, 0);
177 		/* wait for controller ready. 100ms guess. */
178 		msleep(100);
179 	}
180 }
181 
182 static int pixcir_set_power_mode(struct pixcir_i2c_ts_data *ts,
183 				 enum pixcir_power_mode mode)
184 {
185 	struct device *dev = &ts->client->dev;
186 	int ret;
187 
188 	if (mode == PIXCIR_POWER_ACTIVE || mode == PIXCIR_POWER_IDLE) {
189 		if (ts->gpio_wake)
190 			gpiod_set_value_cansleep(ts->gpio_wake, 1);
191 	}
192 
193 	ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_POWER_MODE);
194 	if (ret < 0) {
195 		dev_err(dev, "%s: can't read reg 0x%x : %d\n",
196 			__func__, PIXCIR_REG_POWER_MODE, ret);
197 		return ret;
198 	}
199 
200 	ret &= ~PIXCIR_POWER_MODE_MASK;
201 	ret |= mode;
202 
203 	/* Always AUTO_IDLE */
204 	ret |= PIXCIR_POWER_ALLOW_IDLE;
205 
206 	ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_POWER_MODE, ret);
207 	if (ret < 0) {
208 		dev_err(dev, "%s: can't write reg 0x%x : %d\n",
209 			__func__, PIXCIR_REG_POWER_MODE, ret);
210 		return ret;
211 	}
212 
213 	if (mode == PIXCIR_POWER_HALT) {
214 		if (ts->gpio_wake)
215 			gpiod_set_value_cansleep(ts->gpio_wake, 0);
216 	}
217 
218 	return 0;
219 }
220 
221 /*
222  * Set the interrupt mode for the device i.e. ATTB line behaviour
223  *
224  * @polarity : 1 for active high, 0 for active low.
225  */
226 static int pixcir_set_int_mode(struct pixcir_i2c_ts_data *ts,
227 			       enum pixcir_int_mode mode, bool polarity)
228 {
229 	struct device *dev = &ts->client->dev;
230 	int ret;
231 
232 	ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_INT_MODE);
233 	if (ret < 0) {
234 		dev_err(dev, "%s: can't read reg 0x%x : %d\n",
235 			__func__, PIXCIR_REG_INT_MODE, ret);
236 		return ret;
237 	}
238 
239 	ret &= ~PIXCIR_INT_MODE_MASK;
240 	ret |= mode;
241 
242 	if (polarity)
243 		ret |= PIXCIR_INT_POL_HIGH;
244 	else
245 		ret &= ~PIXCIR_INT_POL_HIGH;
246 
247 	ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_INT_MODE, ret);
248 	if (ret < 0) {
249 		dev_err(dev, "%s: can't write reg 0x%x : %d\n",
250 			__func__, PIXCIR_REG_INT_MODE, ret);
251 		return ret;
252 	}
253 
254 	return 0;
255 }
256 
257 /*
258  * Enable/disable interrupt generation
259  */
260 static int pixcir_int_enable(struct pixcir_i2c_ts_data *ts, bool enable)
261 {
262 	struct device *dev = &ts->client->dev;
263 	int ret;
264 
265 	ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_INT_MODE);
266 	if (ret < 0) {
267 		dev_err(dev, "%s: can't read reg 0x%x : %d\n",
268 			__func__, PIXCIR_REG_INT_MODE, ret);
269 		return ret;
270 	}
271 
272 	if (enable)
273 		ret |= PIXCIR_INT_ENABLE;
274 	else
275 		ret &= ~PIXCIR_INT_ENABLE;
276 
277 	ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_INT_MODE, ret);
278 	if (ret < 0) {
279 		dev_err(dev, "%s: can't write reg 0x%x : %d\n",
280 			__func__, PIXCIR_REG_INT_MODE, ret);
281 		return ret;
282 	}
283 
284 	return 0;
285 }
286 
287 static int pixcir_start(struct pixcir_i2c_ts_data *ts)
288 {
289 	struct device *dev = &ts->client->dev;
290 	int error;
291 
292 	if (ts->gpio_enable) {
293 		gpiod_set_value_cansleep(ts->gpio_enable, 1);
294 		msleep(100);
295 	}
296 
297 	/* LEVEL_TOUCH interrupt with active low polarity */
298 	error = pixcir_set_int_mode(ts, PIXCIR_INT_LEVEL_TOUCH, 0);
299 	if (error) {
300 		dev_err(dev, "Failed to set interrupt mode: %d\n", error);
301 		return error;
302 	}
303 
304 	ts->running = true;
305 	mb();	/* Update status before IRQ can fire */
306 
307 	/* enable interrupt generation */
308 	error = pixcir_int_enable(ts, true);
309 	if (error) {
310 		dev_err(dev, "Failed to enable interrupt generation: %d\n",
311 			error);
312 		return error;
313 	}
314 
315 	return 0;
316 }
317 
318 static int pixcir_stop(struct pixcir_i2c_ts_data *ts)
319 {
320 	int error;
321 
322 	/* Disable interrupt generation */
323 	error = pixcir_int_enable(ts, false);
324 	if (error) {
325 		dev_err(&ts->client->dev,
326 			"Failed to disable interrupt generation: %d\n",
327 			error);
328 		return error;
329 	}
330 
331 	/* Exit ISR if running, no more report parsing */
332 	ts->running = false;
333 	mb();	/* update status before we synchronize irq */
334 
335 	/* Wait till running ISR is complete */
336 	synchronize_irq(ts->client->irq);
337 
338 	if (ts->gpio_enable)
339 		gpiod_set_value_cansleep(ts->gpio_enable, 0);
340 
341 	return 0;
342 }
343 
344 static int pixcir_input_open(struct input_dev *dev)
345 {
346 	struct pixcir_i2c_ts_data *ts = input_get_drvdata(dev);
347 
348 	return pixcir_start(ts);
349 }
350 
351 static void pixcir_input_close(struct input_dev *dev)
352 {
353 	struct pixcir_i2c_ts_data *ts = input_get_drvdata(dev);
354 
355 	pixcir_stop(ts);
356 }
357 
358 static int __maybe_unused pixcir_i2c_ts_suspend(struct device *dev)
359 {
360 	struct i2c_client *client = to_i2c_client(dev);
361 	struct pixcir_i2c_ts_data *ts = i2c_get_clientdata(client);
362 	struct input_dev *input = ts->input;
363 	int ret = 0;
364 
365 	mutex_lock(&input->mutex);
366 
367 	if (device_may_wakeup(&client->dev)) {
368 		if (!input->users) {
369 			ret = pixcir_start(ts);
370 			if (ret) {
371 				dev_err(dev, "Failed to start\n");
372 				goto unlock;
373 			}
374 		}
375 	} else if (input->users) {
376 		ret = pixcir_stop(ts);
377 	}
378 
379 unlock:
380 	mutex_unlock(&input->mutex);
381 
382 	return ret;
383 }
384 
385 static int __maybe_unused pixcir_i2c_ts_resume(struct device *dev)
386 {
387 	struct i2c_client *client = to_i2c_client(dev);
388 	struct pixcir_i2c_ts_data *ts = i2c_get_clientdata(client);
389 	struct input_dev *input = ts->input;
390 	int ret = 0;
391 
392 	mutex_lock(&input->mutex);
393 
394 	if (device_may_wakeup(&client->dev)) {
395 		if (!input->users) {
396 			ret = pixcir_stop(ts);
397 			if (ret) {
398 				dev_err(dev, "Failed to stop\n");
399 				goto unlock;
400 			}
401 		}
402 	} else if (input->users) {
403 		ret = pixcir_start(ts);
404 	}
405 
406 unlock:
407 	mutex_unlock(&input->mutex);
408 
409 	return ret;
410 }
411 
412 static SIMPLE_DEV_PM_OPS(pixcir_dev_pm_ops,
413 			 pixcir_i2c_ts_suspend, pixcir_i2c_ts_resume);
414 
415 #ifdef CONFIG_OF
416 static const struct of_device_id pixcir_of_match[];
417 
418 static int pixcir_parse_dt(struct device *dev,
419 			   struct pixcir_i2c_ts_data *tsdata)
420 {
421 	tsdata->chip = of_device_get_match_data(dev);
422 	if (!tsdata->chip)
423 		return -EINVAL;
424 
425 	return 0;
426 }
427 #else
428 static int pixcir_parse_dt(struct device *dev,
429 			   struct pixcir_i2c_ts_data *tsdata)
430 {
431 	return -EINVAL;
432 }
433 #endif
434 
435 static int pixcir_i2c_ts_probe(struct i2c_client *client,
436 			       const struct i2c_device_id *id)
437 {
438 	const struct pixcir_ts_platform_data *pdata =
439 			dev_get_platdata(&client->dev);
440 	struct device *dev = &client->dev;
441 	struct pixcir_i2c_ts_data *tsdata;
442 	struct input_dev *input;
443 	int error;
444 
445 	tsdata = devm_kzalloc(dev, sizeof(*tsdata), GFP_KERNEL);
446 	if (!tsdata)
447 		return -ENOMEM;
448 
449 	if (pdata) {
450 		tsdata->chip = &pdata->chip;
451 	} else if (dev->of_node) {
452 		error = pixcir_parse_dt(dev, tsdata);
453 		if (error)
454 			return error;
455 	} else {
456 		dev_err(dev, "platform data not defined\n");
457 		return -EINVAL;
458 	}
459 
460 	if (!tsdata->chip->max_fingers) {
461 		dev_err(dev, "Invalid max_fingers in chip data\n");
462 		return -EINVAL;
463 	}
464 
465 	input = devm_input_allocate_device(dev);
466 	if (!input) {
467 		dev_err(dev, "Failed to allocate input device\n");
468 		return -ENOMEM;
469 	}
470 
471 	tsdata->client = client;
472 	tsdata->input = input;
473 
474 	input->name = client->name;
475 	input->id.bustype = BUS_I2C;
476 	input->open = pixcir_input_open;
477 	input->close = pixcir_input_close;
478 	input->dev.parent = dev;
479 
480 	if (pdata) {
481 		input_set_abs_params(input, ABS_MT_POSITION_X, 0, pdata->x_max, 0, 0);
482 		input_set_abs_params(input, ABS_MT_POSITION_Y, 0, pdata->y_max, 0, 0);
483 	} else {
484 		input_set_capability(input, EV_ABS, ABS_MT_POSITION_X);
485 		input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y);
486 		touchscreen_parse_properties(input, true, &tsdata->prop);
487 		if (!input_abs_get_max(input, ABS_MT_POSITION_X) ||
488 		    !input_abs_get_max(input, ABS_MT_POSITION_Y)) {
489 			dev_err(dev, "Touchscreen size is not specified\n");
490 			return -EINVAL;
491 		}
492 	}
493 
494 	tsdata->max_fingers = tsdata->chip->max_fingers;
495 	if (tsdata->max_fingers > PIXCIR_MAX_SLOTS) {
496 		tsdata->max_fingers = PIXCIR_MAX_SLOTS;
497 		dev_info(dev, "Limiting maximum fingers to %d\n",
498 			 tsdata->max_fingers);
499 	}
500 
501 	error = input_mt_init_slots(input, tsdata->max_fingers,
502 				    INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
503 	if (error) {
504 		dev_err(dev, "Error initializing Multi-Touch slots\n");
505 		return error;
506 	}
507 
508 	input_set_drvdata(input, tsdata);
509 
510 	tsdata->gpio_attb = devm_gpiod_get(dev, "attb", GPIOD_IN);
511 	if (IS_ERR(tsdata->gpio_attb)) {
512 		error = PTR_ERR(tsdata->gpio_attb);
513 		dev_err(dev, "Failed to request ATTB gpio: %d\n", error);
514 		return error;
515 	}
516 
517 	tsdata->gpio_reset = devm_gpiod_get_optional(dev, "reset",
518 						     GPIOD_OUT_LOW);
519 	if (IS_ERR(tsdata->gpio_reset)) {
520 		error = PTR_ERR(tsdata->gpio_reset);
521 		dev_err(dev, "Failed to request RESET gpio: %d\n", error);
522 		return error;
523 	}
524 
525 	tsdata->gpio_wake = devm_gpiod_get_optional(dev, "wake",
526 						    GPIOD_OUT_HIGH);
527 	if (IS_ERR(tsdata->gpio_wake)) {
528 		error = PTR_ERR(tsdata->gpio_wake);
529 		if (error != -EPROBE_DEFER)
530 			dev_err(dev, "Failed to get wake gpio: %d\n", error);
531 		return error;
532 	}
533 
534 	tsdata->gpio_enable = devm_gpiod_get_optional(dev, "enable",
535 						      GPIOD_OUT_HIGH);
536 	if (IS_ERR(tsdata->gpio_enable)) {
537 		error = PTR_ERR(tsdata->gpio_enable);
538 		if (error != -EPROBE_DEFER)
539 			dev_err(dev, "Failed to get enable gpio: %d\n", error);
540 		return error;
541 	}
542 
543 	if (tsdata->gpio_enable)
544 		msleep(100);
545 
546 	error = devm_request_threaded_irq(dev, client->irq, NULL, pixcir_ts_isr,
547 					  IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
548 					  client->name, tsdata);
549 	if (error) {
550 		dev_err(dev, "failed to request irq %d\n", client->irq);
551 		return error;
552 	}
553 
554 	pixcir_reset(tsdata);
555 
556 	/* Always be in IDLE mode to save power, device supports auto wake */
557 	error = pixcir_set_power_mode(tsdata, PIXCIR_POWER_IDLE);
558 	if (error) {
559 		dev_err(dev, "Failed to set IDLE mode\n");
560 		return error;
561 	}
562 
563 	/* Stop device till opened */
564 	error = pixcir_stop(tsdata);
565 	if (error)
566 		return error;
567 
568 	error = input_register_device(input);
569 	if (error)
570 		return error;
571 
572 	i2c_set_clientdata(client, tsdata);
573 
574 	return 0;
575 }
576 
577 static const struct i2c_device_id pixcir_i2c_ts_id[] = {
578 	{ "pixcir_ts", 0 },
579 	{ "pixcir_tangoc", 0 },
580 	{ }
581 };
582 MODULE_DEVICE_TABLE(i2c, pixcir_i2c_ts_id);
583 
584 #ifdef CONFIG_OF
585 static const struct pixcir_i2c_chip_data pixcir_ts_data = {
586 	.max_fingers = 2,
587 	/* no hw id support */
588 };
589 
590 static const struct pixcir_i2c_chip_data pixcir_tangoc_data = {
591 	.max_fingers = 5,
592 	.has_hw_ids = true,
593 };
594 
595 static const struct of_device_id pixcir_of_match[] = {
596 	{ .compatible = "pixcir,pixcir_ts", .data = &pixcir_ts_data },
597 	{ .compatible = "pixcir,pixcir_tangoc", .data = &pixcir_tangoc_data },
598 	{ }
599 };
600 MODULE_DEVICE_TABLE(of, pixcir_of_match);
601 #endif
602 
603 static struct i2c_driver pixcir_i2c_ts_driver = {
604 	.driver = {
605 		.name	= "pixcir_ts",
606 		.pm	= &pixcir_dev_pm_ops,
607 		.of_match_table = of_match_ptr(pixcir_of_match),
608 	},
609 	.probe		= pixcir_i2c_ts_probe,
610 	.id_table	= pixcir_i2c_ts_id,
611 };
612 
613 module_i2c_driver(pixcir_i2c_ts_driver);
614 
615 MODULE_AUTHOR("Jianchun Bian <jcbian@pixcir.com.cn>, Dequan Meng <dqmeng@pixcir.com.cn>");
616 MODULE_DESCRIPTION("Pixcir I2C Touchscreen Driver");
617 MODULE_LICENSE("GPL");
618