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