1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2021
4  * Author(s): Giulio Benetti <giulio.benetti@benettiengineering.com>
5  */
6 
7 #include <linux/delay.h>
8 #include <linux/gpio/consumer.h>
9 #include <linux/i2c.h>
10 #include <linux/interrupt.h>
11 #include <linux/input.h>
12 #include <linux/input/mt.h>
13 #include <linux/input/touchscreen.h>
14 #include <linux/irq.h>
15 #include <linux/regulator/consumer.h>
16 #include <linux/regmap.h>
17 
18 #include <asm/unaligned.h>
19 
20 #define HY46XX_CHKSUM_CODE		0x1
21 #define HY46XX_FINGER_NUM		0x2
22 #define HY46XX_CHKSUM_LEN		0x7
23 #define HY46XX_THRESHOLD		0x80
24 #define HY46XX_GLOVE_EN			0x84
25 #define HY46XX_REPORT_SPEED		0x88
26 #define HY46XX_PWR_NOISE_EN		0x89
27 #define HY46XX_FILTER_DATA		0x8A
28 #define HY46XX_GAIN			0x92
29 #define HY46XX_EDGE_OFFSET		0x93
30 #define HY46XX_RX_NR_USED		0x94
31 #define HY46XX_TX_NR_USED		0x95
32 #define HY46XX_PWR_MODE			0xA5
33 #define HY46XX_FW_VERSION		0xA6
34 #define HY46XX_LIB_VERSION		0xA7
35 #define HY46XX_TP_INFO			0xA8
36 #define HY46XX_TP_CHIP_ID		0xA9
37 #define HY46XX_BOOT_VER			0xB0
38 
39 #define HY46XX_TPLEN			0x6
40 #define HY46XX_REPORT_PKT_LEN		0x44
41 
42 #define HY46XX_MAX_SUPPORTED_POINTS	11
43 
44 #define TOUCH_EVENT_DOWN		0x00
45 #define TOUCH_EVENT_UP			0x01
46 #define TOUCH_EVENT_CONTACT		0x02
47 #define TOUCH_EVENT_RESERVED		0x03
48 
49 struct hycon_hy46xx_data {
50 	struct i2c_client *client;
51 	struct input_dev *input;
52 	struct touchscreen_properties prop;
53 	struct regulator *vcc;
54 
55 	struct gpio_desc *reset_gpio;
56 
57 	struct mutex mutex;
58 	struct regmap *regmap;
59 
60 	int threshold;
61 	bool glove_enable;
62 	int report_speed;
63 	bool noise_filter_enable;
64 	int filter_data;
65 	int gain;
66 	int edge_offset;
67 	int rx_number_used;
68 	int tx_number_used;
69 	int power_mode;
70 	int fw_version;
71 	int lib_version;
72 	int tp_information;
73 	int tp_chip_id;
74 	int bootloader_version;
75 };
76 
77 static const struct regmap_config hycon_hy46xx_i2c_regmap_config = {
78 	.reg_bits = 8,
79 	.val_bits = 8,
80 };
81 
82 static bool hycon_hy46xx_check_checksum(struct hycon_hy46xx_data *tsdata, u8 *buf)
83 {
84 	u8 chksum = 0;
85 	int i;
86 
87 	for (i = 2; i < buf[HY46XX_CHKSUM_LEN]; i++)
88 		chksum += buf[i];
89 
90 	if (chksum == buf[HY46XX_CHKSUM_CODE])
91 		return true;
92 
93 	dev_err_ratelimited(&tsdata->client->dev,
94 			    "checksum error: 0x%02x expected, got 0x%02x\n",
95 			    chksum, buf[HY46XX_CHKSUM_CODE]);
96 
97 	return false;
98 }
99 
100 static irqreturn_t hycon_hy46xx_isr(int irq, void *dev_id)
101 {
102 	struct hycon_hy46xx_data *tsdata = dev_id;
103 	struct device *dev = &tsdata->client->dev;
104 	u8 rdbuf[HY46XX_REPORT_PKT_LEN];
105 	int i, x, y, id;
106 	int error;
107 
108 	memset(rdbuf, 0, sizeof(rdbuf));
109 
110 	error = regmap_bulk_read(tsdata->regmap, 0, rdbuf, sizeof(rdbuf));
111 	if (error) {
112 		dev_err_ratelimited(dev, "Unable to fetch data, error: %d\n",
113 				    error);
114 		goto out;
115 	}
116 
117 	if (!hycon_hy46xx_check_checksum(tsdata, rdbuf))
118 		goto out;
119 
120 	for (i = 0; i < HY46XX_MAX_SUPPORTED_POINTS; i++) {
121 		u8 *buf = &rdbuf[3 + (HY46XX_TPLEN * i)];
122 		int type = buf[0] >> 6;
123 
124 		if (type == TOUCH_EVENT_RESERVED)
125 			continue;
126 
127 		x = get_unaligned_be16(buf) & 0x0fff;
128 		y = get_unaligned_be16(buf + 2) & 0x0fff;
129 
130 		id = buf[2] >> 4;
131 
132 		input_mt_slot(tsdata->input, id);
133 		if (input_mt_report_slot_state(tsdata->input, MT_TOOL_FINGER,
134 					       type != TOUCH_EVENT_UP))
135 			touchscreen_report_pos(tsdata->input, &tsdata->prop,
136 					       x, y, true);
137 	}
138 
139 	input_mt_report_pointer_emulation(tsdata->input, false);
140 	input_sync(tsdata->input);
141 
142 out:
143 	return IRQ_HANDLED;
144 }
145 
146 struct hycon_hy46xx_attribute {
147 	struct device_attribute dattr;
148 	size_t field_offset;
149 	u8 address;
150 	u8 limit_low;
151 	u8 limit_high;
152 };
153 
154 #define HYCON_ATTR_U8(_field, _mode, _address, _limit_low, _limit_high)	\
155 	struct hycon_hy46xx_attribute hycon_hy46xx_attr_##_field = {		\
156 		.dattr = __ATTR(_field, _mode,				\
157 				hycon_hy46xx_setting_show,			\
158 				hycon_hy46xx_setting_store),			\
159 		.field_offset = offsetof(struct hycon_hy46xx_data, _field),	\
160 		.address = _address,					\
161 		.limit_low = _limit_low,				\
162 		.limit_high = _limit_high,				\
163 	}
164 
165 #define HYCON_ATTR_BOOL(_field, _mode, _address)			\
166 	struct hycon_hy46xx_attribute hycon_hy46xx_attr_##_field = {		\
167 		.dattr = __ATTR(_field, _mode,				\
168 				hycon_hy46xx_setting_show,			\
169 				hycon_hy46xx_setting_store),			\
170 		.field_offset = offsetof(struct hycon_hy46xx_data, _field),	\
171 		.address = _address,					\
172 		.limit_low = false,					\
173 		.limit_high = true,					\
174 	}
175 
176 static ssize_t hycon_hy46xx_setting_show(struct device *dev,
177 				   struct device_attribute *dattr, char *buf)
178 {
179 	struct i2c_client *client = to_i2c_client(dev);
180 	struct hycon_hy46xx_data *tsdata = i2c_get_clientdata(client);
181 	struct hycon_hy46xx_attribute *attr =
182 			container_of(dattr, struct hycon_hy46xx_attribute, dattr);
183 	u8 *field = (u8 *)tsdata + attr->field_offset;
184 	size_t count = 0;
185 	int error = 0;
186 	int val;
187 
188 	mutex_lock(&tsdata->mutex);
189 
190 	error = regmap_read(tsdata->regmap, attr->address, &val);
191 	if (error < 0) {
192 		dev_err(&tsdata->client->dev,
193 			"Failed to fetch attribute %s, error %d\n",
194 			dattr->attr.name, error);
195 		goto out;
196 	}
197 
198 	if (val != *field) {
199 		dev_warn(&tsdata->client->dev,
200 			 "%s: read (%d) and stored value (%d) differ\n",
201 			 dattr->attr.name, val, *field);
202 		*field = val;
203 	}
204 
205 	count = scnprintf(buf, PAGE_SIZE, "%d\n", val);
206 
207 out:
208 	mutex_unlock(&tsdata->mutex);
209 	return error ?: count;
210 }
211 
212 static ssize_t hycon_hy46xx_setting_store(struct device *dev,
213 					struct device_attribute *dattr,
214 					const char *buf, size_t count)
215 {
216 	struct i2c_client *client = to_i2c_client(dev);
217 	struct hycon_hy46xx_data *tsdata = i2c_get_clientdata(client);
218 	struct hycon_hy46xx_attribute *attr =
219 			container_of(dattr, struct hycon_hy46xx_attribute, dattr);
220 	u8 *field = (u8 *)tsdata + attr->field_offset;
221 	unsigned int val;
222 	int error;
223 
224 	mutex_lock(&tsdata->mutex);
225 
226 	error = kstrtouint(buf, 0, &val);
227 	if (error)
228 		goto out;
229 
230 	if (val < attr->limit_low || val > attr->limit_high) {
231 		error = -ERANGE;
232 		goto out;
233 	}
234 
235 	error = regmap_write(tsdata->regmap, attr->address, val);
236 	if (error < 0) {
237 		dev_err(&tsdata->client->dev,
238 			"Failed to update attribute %s, error: %d\n",
239 			dattr->attr.name, error);
240 		goto out;
241 	}
242 	*field = val;
243 
244 out:
245 	mutex_unlock(&tsdata->mutex);
246 	return error ?: count;
247 }
248 
249 static HYCON_ATTR_U8(threshold, 0644, HY46XX_THRESHOLD, 0, 255);
250 static HYCON_ATTR_BOOL(glove_enable, 0644, HY46XX_GLOVE_EN);
251 static HYCON_ATTR_U8(report_speed, 0644, HY46XX_REPORT_SPEED, 0, 255);
252 static HYCON_ATTR_BOOL(noise_filter_enable, 0644, HY46XX_PWR_NOISE_EN);
253 static HYCON_ATTR_U8(filter_data, 0644, HY46XX_FILTER_DATA, 0, 5);
254 static HYCON_ATTR_U8(gain, 0644, HY46XX_GAIN, 0, 5);
255 static HYCON_ATTR_U8(edge_offset, 0644, HY46XX_EDGE_OFFSET, 0, 5);
256 static HYCON_ATTR_U8(fw_version, 0444, HY46XX_FW_VERSION, 0, 255);
257 static HYCON_ATTR_U8(lib_version, 0444, HY46XX_LIB_VERSION, 0, 255);
258 static HYCON_ATTR_U8(tp_information, 0444, HY46XX_TP_INFO, 0, 255);
259 static HYCON_ATTR_U8(tp_chip_id, 0444, HY46XX_TP_CHIP_ID, 0, 255);
260 static HYCON_ATTR_U8(bootloader_version, 0444, HY46XX_BOOT_VER, 0, 255);
261 
262 static struct attribute *hycon_hy46xx_attrs[] = {
263 	&hycon_hy46xx_attr_threshold.dattr.attr,
264 	&hycon_hy46xx_attr_glove_enable.dattr.attr,
265 	&hycon_hy46xx_attr_report_speed.dattr.attr,
266 	&hycon_hy46xx_attr_noise_filter_enable.dattr.attr,
267 	&hycon_hy46xx_attr_filter_data.dattr.attr,
268 	&hycon_hy46xx_attr_gain.dattr.attr,
269 	&hycon_hy46xx_attr_edge_offset.dattr.attr,
270 	&hycon_hy46xx_attr_fw_version.dattr.attr,
271 	&hycon_hy46xx_attr_lib_version.dattr.attr,
272 	&hycon_hy46xx_attr_tp_information.dattr.attr,
273 	&hycon_hy46xx_attr_tp_chip_id.dattr.attr,
274 	&hycon_hy46xx_attr_bootloader_version.dattr.attr,
275 	NULL
276 };
277 
278 static const struct attribute_group hycon_hy46xx_attr_group = {
279 	.attrs = hycon_hy46xx_attrs,
280 };
281 
282 static void hycon_hy46xx_get_defaults(struct device *dev, struct hycon_hy46xx_data *tsdata)
283 {
284 	bool val_bool;
285 	int error;
286 	u32 val;
287 
288 	error = device_property_read_u32(dev, "hycon,threshold", &val);
289 	if (!error) {
290 		error = regmap_write(tsdata->regmap, HY46XX_THRESHOLD, val);
291 		if (error < 0)
292 			goto out;
293 
294 		tsdata->threshold = val;
295 	}
296 
297 	val_bool = device_property_read_bool(dev, "hycon,glove-enable");
298 	error = regmap_write(tsdata->regmap, HY46XX_GLOVE_EN, val_bool);
299 	if (error < 0)
300 		goto out;
301 	tsdata->glove_enable = val_bool;
302 
303 	error = device_property_read_u32(dev, "hycon,report-speed-hz", &val);
304 	if (!error) {
305 		error = regmap_write(tsdata->regmap, HY46XX_REPORT_SPEED, val);
306 		if (error < 0)
307 			goto out;
308 
309 		tsdata->report_speed = val;
310 	}
311 
312 	val_bool = device_property_read_bool(dev, "hycon,noise-filter-enable");
313 	error = regmap_write(tsdata->regmap, HY46XX_PWR_NOISE_EN, val_bool);
314 	if (error < 0)
315 		goto out;
316 	tsdata->noise_filter_enable = val_bool;
317 
318 	error = device_property_read_u32(dev, "hycon,filter-data", &val);
319 	if (!error) {
320 		error = regmap_write(tsdata->regmap, HY46XX_FILTER_DATA, val);
321 		if (error < 0)
322 			goto out;
323 
324 		tsdata->filter_data = val;
325 	}
326 
327 	error = device_property_read_u32(dev, "hycon,gain", &val);
328 	if (!error) {
329 		error = regmap_write(tsdata->regmap, HY46XX_GAIN, val);
330 		if (error < 0)
331 			goto out;
332 
333 		tsdata->gain = val;
334 	}
335 
336 	error = device_property_read_u32(dev, "hycon,edge-offset", &val);
337 	if (!error) {
338 		error = regmap_write(tsdata->regmap, HY46XX_EDGE_OFFSET, val);
339 		if (error < 0)
340 			goto out;
341 
342 		tsdata->edge_offset = val;
343 	}
344 
345 	return;
346 out:
347 	dev_err(&tsdata->client->dev, "Failed to set default settings");
348 }
349 
350 static void hycon_hy46xx_get_parameters(struct hycon_hy46xx_data *tsdata)
351 {
352 	int error;
353 	u32 val;
354 
355 	error = regmap_read(tsdata->regmap, HY46XX_THRESHOLD, &val);
356 	if (error < 0)
357 		goto out;
358 	tsdata->threshold = val;
359 
360 	error = regmap_read(tsdata->regmap, HY46XX_GLOVE_EN, &val);
361 	if (error < 0)
362 		goto out;
363 	tsdata->glove_enable = val;
364 
365 	error = regmap_read(tsdata->regmap, HY46XX_REPORT_SPEED, &val);
366 	if (error < 0)
367 		goto out;
368 	tsdata->report_speed = val;
369 
370 	error = regmap_read(tsdata->regmap, HY46XX_PWR_NOISE_EN, &val);
371 	if (error < 0)
372 		goto out;
373 	tsdata->noise_filter_enable = val;
374 
375 	error = regmap_read(tsdata->regmap, HY46XX_FILTER_DATA, &val);
376 	if (error < 0)
377 		goto out;
378 	tsdata->filter_data = val;
379 
380 	error = regmap_read(tsdata->regmap, HY46XX_GAIN, &val);
381 	if (error < 0)
382 		goto out;
383 	tsdata->gain = val;
384 
385 	error = regmap_read(tsdata->regmap, HY46XX_EDGE_OFFSET, &val);
386 	if (error < 0)
387 		goto out;
388 	tsdata->edge_offset = val;
389 
390 	error = regmap_read(tsdata->regmap, HY46XX_RX_NR_USED, &val);
391 	if (error < 0)
392 		goto out;
393 	tsdata->rx_number_used = val;
394 
395 	error = regmap_read(tsdata->regmap, HY46XX_TX_NR_USED, &val);
396 	if (error < 0)
397 		goto out;
398 	tsdata->tx_number_used = val;
399 
400 	error = regmap_read(tsdata->regmap, HY46XX_PWR_MODE, &val);
401 	if (error < 0)
402 		goto out;
403 	tsdata->power_mode = val;
404 
405 	error = regmap_read(tsdata->regmap, HY46XX_FW_VERSION, &val);
406 	if (error < 0)
407 		goto out;
408 	tsdata->fw_version = val;
409 
410 	error = regmap_read(tsdata->regmap, HY46XX_LIB_VERSION, &val);
411 	if (error < 0)
412 		goto out;
413 	tsdata->lib_version = val;
414 
415 	error = regmap_read(tsdata->regmap, HY46XX_TP_INFO, &val);
416 	if (error < 0)
417 		goto out;
418 	tsdata->tp_information = val;
419 
420 	error = regmap_read(tsdata->regmap, HY46XX_TP_CHIP_ID, &val);
421 	if (error < 0)
422 		goto out;
423 	tsdata->tp_chip_id = val;
424 
425 	error = regmap_read(tsdata->regmap, HY46XX_BOOT_VER, &val);
426 	if (error < 0)
427 		goto out;
428 	tsdata->bootloader_version = val;
429 
430 	return;
431 out:
432 	dev_err(&tsdata->client->dev, "Failed to read default settings");
433 }
434 
435 static void hycon_hy46xx_disable_regulator(void *arg)
436 {
437 	struct hycon_hy46xx_data *data = arg;
438 
439 	regulator_disable(data->vcc);
440 }
441 
442 static int hycon_hy46xx_probe(struct i2c_client *client)
443 {
444 	struct hycon_hy46xx_data *tsdata;
445 	struct input_dev *input;
446 	int error;
447 
448 	dev_dbg(&client->dev, "probing for HYCON HY46XX I2C\n");
449 
450 	tsdata = devm_kzalloc(&client->dev, sizeof(*tsdata), GFP_KERNEL);
451 	if (!tsdata)
452 		return -ENOMEM;
453 
454 	tsdata->vcc = devm_regulator_get(&client->dev, "vcc");
455 	if (IS_ERR(tsdata->vcc)) {
456 		error = PTR_ERR(tsdata->vcc);
457 		if (error != -EPROBE_DEFER)
458 			dev_err(&client->dev,
459 				"failed to request regulator: %d\n", error);
460 		return error;
461 	}
462 
463 	error = regulator_enable(tsdata->vcc);
464 	if (error < 0) {
465 		dev_err(&client->dev, "failed to enable vcc: %d\n", error);
466 		return error;
467 	}
468 
469 	error = devm_add_action_or_reset(&client->dev,
470 					 hycon_hy46xx_disable_regulator,
471 					 tsdata);
472 	if (error)
473 		return error;
474 
475 	tsdata->reset_gpio = devm_gpiod_get_optional(&client->dev,
476 						     "reset", GPIOD_OUT_LOW);
477 	if (IS_ERR(tsdata->reset_gpio)) {
478 		error = PTR_ERR(tsdata->reset_gpio);
479 		dev_err(&client->dev,
480 			"Failed to request GPIO reset pin, error %d\n", error);
481 		return error;
482 	}
483 
484 	if (tsdata->reset_gpio) {
485 		usleep_range(5000, 6000);
486 		gpiod_set_value_cansleep(tsdata->reset_gpio, 1);
487 		usleep_range(5000, 6000);
488 		gpiod_set_value_cansleep(tsdata->reset_gpio, 0);
489 		msleep(1000);
490 	}
491 
492 	input = devm_input_allocate_device(&client->dev);
493 	if (!input) {
494 		dev_err(&client->dev, "failed to allocate input device.\n");
495 		return -ENOMEM;
496 	}
497 
498 	mutex_init(&tsdata->mutex);
499 	tsdata->client = client;
500 	tsdata->input = input;
501 
502 	tsdata->regmap = devm_regmap_init_i2c(client,
503 					      &hycon_hy46xx_i2c_regmap_config);
504 	if (IS_ERR(tsdata->regmap)) {
505 		dev_err(&client->dev, "regmap allocation failed\n");
506 		return PTR_ERR(tsdata->regmap);
507 	}
508 
509 	hycon_hy46xx_get_defaults(&client->dev, tsdata);
510 	hycon_hy46xx_get_parameters(tsdata);
511 
512 	input->name = "Hycon Capacitive Touch";
513 	input->id.bustype = BUS_I2C;
514 	input->dev.parent = &client->dev;
515 
516 	input_set_abs_params(input, ABS_MT_POSITION_X, 0, -1, 0, 0);
517 	input_set_abs_params(input, ABS_MT_POSITION_Y, 0, -1, 0, 0);
518 
519 	touchscreen_parse_properties(input, true, &tsdata->prop);
520 
521 	error = input_mt_init_slots(input, HY46XX_MAX_SUPPORTED_POINTS,
522 				    INPUT_MT_DIRECT);
523 	if (error) {
524 		dev_err(&client->dev, "Unable to init MT slots.\n");
525 		return error;
526 	}
527 
528 	i2c_set_clientdata(client, tsdata);
529 
530 	error = devm_request_threaded_irq(&client->dev, client->irq,
531 					  NULL, hycon_hy46xx_isr, IRQF_ONESHOT,
532 					  client->name, tsdata);
533 	if (error) {
534 		dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
535 		return error;
536 	}
537 
538 	error = devm_device_add_group(&client->dev, &hycon_hy46xx_attr_group);
539 	if (error)
540 		return error;
541 
542 	error = input_register_device(input);
543 	if (error)
544 		return error;
545 
546 	dev_dbg(&client->dev,
547 		"HYCON HY46XX initialized: IRQ %d, Reset pin %d.\n",
548 		client->irq,
549 		tsdata->reset_gpio ? desc_to_gpio(tsdata->reset_gpio) : -1);
550 
551 	return 0;
552 }
553 
554 static const struct i2c_device_id hycon_hy46xx_id[] = {
555 	{ .name = "hy4613" },
556 	{ .name = "hy4614" },
557 	{ .name = "hy4621" },
558 	{ .name = "hy4623" },
559 	{ .name = "hy4633" },
560 	{ .name = "hy4635" },
561 	{ /* sentinel */ }
562 };
563 MODULE_DEVICE_TABLE(i2c, hycon_hy46xx_id);
564 
565 static const struct of_device_id hycon_hy46xx_of_match[] = {
566 	{ .compatible = "hycon,hy4613" },
567 	{ .compatible = "hycon,hy4614" },
568 	{ .compatible = "hycon,hy4621" },
569 	{ .compatible = "hycon,hy4623" },
570 	{ .compatible = "hycon,hy4633" },
571 	{ .compatible = "hycon,hy4635" },
572 	{ /* sentinel */ }
573 };
574 MODULE_DEVICE_TABLE(of, hycon_hy46xx_of_match);
575 
576 static struct i2c_driver hycon_hy46xx_driver = {
577 	.driver = {
578 		.name = "hycon_hy46xx",
579 		.of_match_table = hycon_hy46xx_of_match,
580 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
581 	},
582 	.id_table = hycon_hy46xx_id,
583 	.probe = hycon_hy46xx_probe,
584 };
585 
586 module_i2c_driver(hycon_hy46xx_driver);
587 
588 MODULE_AUTHOR("Giulio Benetti <giulio.benetti@benettiengineering.com>");
589 MODULE_DESCRIPTION("HYCON HY46XX I2C Touchscreen Driver");
590 MODULE_LICENSE("GPL v2");
591