1 // SPDX-License-Identifier: GPL-2.0-only
2 
3 #include <linux/delay.h>
4 #include <linux/i2c.h>
5 #include <linux/input.h>
6 #include <linux/input/mt.h>
7 #include <linux/input/touchscreen.h>
8 #include <linux/interrupt.h>
9 #include <linux/irq.h>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/of.h>
13 #include <linux/regulator/consumer.h>
14 #include <linux/slab.h>
15 
16 /* Register Map */
17 
18 #define BT541_SWRESET_CMD			0x0000
19 #define BT541_WAKEUP_CMD			0x0001
20 
21 #define BT541_IDLE_CMD				0x0004
22 #define BT541_SLEEP_CMD				0x0005
23 
24 #define BT541_CLEAR_INT_STATUS_CMD		0x0003
25 #define BT541_CALIBRATE_CMD			0x0006
26 #define BT541_SAVE_STATUS_CMD			0x0007
27 #define BT541_SAVE_CALIBRATION_CMD		0x0008
28 #define BT541_RECALL_FACTORY_CMD		0x000f
29 
30 #define BT541_THRESHOLD				0x0020
31 
32 #define BT541_LARGE_PALM_REJECT_AREA_TH		0x003F
33 
34 #define BT541_DEBUG_REG				0x0115 /* 0~7 */
35 
36 #define BT541_TOUCH_MODE			0x0010
37 #define BT541_CHIP_REVISION			0x0011
38 #define BT541_FIRMWARE_VERSION			0x0012
39 
40 #define ZINITIX_USB_DETECT			0x116
41 
42 #define BT541_MINOR_FW_VERSION			0x0121
43 
44 #define BT541_VENDOR_ID				0x001C
45 #define BT541_HW_ID				0x0014
46 
47 #define BT541_DATA_VERSION_REG			0x0013
48 #define BT541_SUPPORTED_FINGER_NUM		0x0015
49 #define BT541_EEPROM_INFO			0x0018
50 #define BT541_INITIAL_TOUCH_MODE		0x0019
51 
52 #define BT541_TOTAL_NUMBER_OF_X			0x0060
53 #define BT541_TOTAL_NUMBER_OF_Y			0x0061
54 
55 #define BT541_DELAY_RAW_FOR_HOST		0x007f
56 
57 #define BT541_BUTTON_SUPPORTED_NUM		0x00B0
58 #define BT541_BUTTON_SENSITIVITY		0x00B2
59 #define BT541_DUMMY_BUTTON_SENSITIVITY		0X00C8
60 
61 #define BT541_X_RESOLUTION			0x00C0
62 #define BT541_Y_RESOLUTION			0x00C1
63 
64 #define BT541_POINT_STATUS_REG			0x0080
65 #define BT541_ICON_STATUS_REG			0x00AA
66 
67 #define BT541_POINT_COORD_REG			(BT541_POINT_STATUS_REG + 2)
68 
69 #define BT541_AFE_FREQUENCY			0x0100
70 #define BT541_DND_N_COUNT			0x0122
71 #define BT541_DND_U_COUNT			0x0135
72 
73 #define BT541_RAWDATA_REG			0x0200
74 
75 #define BT541_EEPROM_INFO_REG			0x0018
76 
77 #define BT541_INT_ENABLE_FLAG			0x00f0
78 #define BT541_PERIODICAL_INTERRUPT_INTERVAL	0x00f1
79 
80 #define BT541_BTN_WIDTH				0x016d
81 
82 #define BT541_CHECKSUM_RESULT			0x012c
83 
84 #define BT541_INIT_FLASH			0x01d0
85 #define BT541_WRITE_FLASH			0x01d1
86 #define BT541_READ_FLASH			0x01d2
87 
88 #define ZINITIX_INTERNAL_FLAG_02		0x011e
89 #define ZINITIX_INTERNAL_FLAG_03		0x011f
90 
91 #define ZINITIX_I2C_CHECKSUM_WCNT		0x016a
92 #define ZINITIX_I2C_CHECKSUM_RESULT		0x016c
93 
94 /* Interrupt & status register flags */
95 
96 #define BIT_PT_CNT_CHANGE			BIT(0)
97 #define BIT_DOWN				BIT(1)
98 #define BIT_MOVE				BIT(2)
99 #define BIT_UP					BIT(3)
100 #define BIT_PALM				BIT(4)
101 #define BIT_PALM_REJECT				BIT(5)
102 #define BIT_RESERVED_0				BIT(6)
103 #define BIT_RESERVED_1				BIT(7)
104 #define BIT_WEIGHT_CHANGE			BIT(8)
105 #define BIT_PT_NO_CHANGE			BIT(9)
106 #define BIT_REJECT				BIT(10)
107 #define BIT_PT_EXIST				BIT(11)
108 #define BIT_RESERVED_2				BIT(12)
109 #define BIT_ERROR				BIT(13)
110 #define BIT_DEBUG				BIT(14)
111 #define BIT_ICON_EVENT				BIT(15)
112 
113 #define SUB_BIT_EXIST				BIT(0)
114 #define SUB_BIT_DOWN				BIT(1)
115 #define SUB_BIT_MOVE				BIT(2)
116 #define SUB_BIT_UP				BIT(3)
117 #define SUB_BIT_UPDATE				BIT(4)
118 #define SUB_BIT_WAIT				BIT(5)
119 
120 #define DEFAULT_TOUCH_POINT_MODE		2
121 #define MAX_SUPPORTED_FINGER_NUM		5
122 
123 #define CHIP_ON_DELAY				15 // ms
124 #define FIRMWARE_ON_DELAY			40 // ms
125 
126 struct point_coord {
127 	__le16	x;
128 	__le16	y;
129 	u8	width;
130 	u8	sub_status;
131 	// currently unused, but needed as padding:
132 	u8	minor_width;
133 	u8	angle;
134 };
135 
136 struct touch_event {
137 	__le16	status;
138 	u8	finger_cnt;
139 	u8	time_stamp;
140 	struct point_coord point_coord[MAX_SUPPORTED_FINGER_NUM];
141 };
142 
143 struct bt541_ts_data {
144 	struct i2c_client *client;
145 	struct input_dev *input_dev;
146 	struct touchscreen_properties prop;
147 	struct regulator_bulk_data supplies[2];
148 	u32 zinitix_mode;
149 };
150 
151 static int zinitix_read_data(struct i2c_client *client,
152 			     u16 reg, void *values, size_t length)
153 {
154 	__le16 reg_le = cpu_to_le16(reg);
155 	int ret;
156 
157 	/* A single i2c_transfer() transaction does not work here. */
158 	ret = i2c_master_send(client, (u8 *)&reg_le, sizeof(reg_le));
159 	if (ret != sizeof(reg_le))
160 		return ret < 0 ? ret : -EIO;
161 
162 	ret = i2c_master_recv(client, (u8 *)values, length);
163 	if (ret != length)
164 		return ret < 0 ? ret : -EIO;
165 
166 	return 0;
167 }
168 
169 static int zinitix_write_u16(struct i2c_client *client, u16 reg, u16 value)
170 {
171 	__le16 packet[2] = {cpu_to_le16(reg), cpu_to_le16(value)};
172 	int ret;
173 
174 	ret = i2c_master_send(client, (u8 *)packet, sizeof(packet));
175 	if (ret != sizeof(packet))
176 		return ret < 0 ? ret : -EIO;
177 
178 	return 0;
179 }
180 
181 static int zinitix_write_cmd(struct i2c_client *client, u16 reg)
182 {
183 	__le16 reg_le = cpu_to_le16(reg);
184 	int ret;
185 
186 	ret = i2c_master_send(client, (u8 *)&reg_le, sizeof(reg_le));
187 	if (ret != sizeof(reg_le))
188 		return ret < 0 ? ret : -EIO;
189 
190 	return 0;
191 }
192 
193 static int zinitix_init_touch(struct bt541_ts_data *bt541)
194 {
195 	struct i2c_client *client = bt541->client;
196 	int i;
197 	int error;
198 
199 	error = zinitix_write_cmd(client, BT541_SWRESET_CMD);
200 	if (error) {
201 		dev_err(&client->dev, "Failed to write reset command\n");
202 		return error;
203 	}
204 
205 	error = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG, 0x0);
206 	if (error) {
207 		dev_err(&client->dev,
208 			"Failed to reset interrupt enable flag\n");
209 		return error;
210 	}
211 
212 	/* initialize */
213 	error = zinitix_write_u16(client, BT541_X_RESOLUTION,
214 				  bt541->prop.max_x);
215 	if (error)
216 		return error;
217 
218 	error = zinitix_write_u16(client, BT541_Y_RESOLUTION,
219 				  bt541->prop.max_y);
220 	if (error)
221 		return error;
222 
223 	error = zinitix_write_u16(client, BT541_SUPPORTED_FINGER_NUM,
224 				  MAX_SUPPORTED_FINGER_NUM);
225 	if (error)
226 		return error;
227 
228 	error = zinitix_write_u16(client, BT541_INITIAL_TOUCH_MODE,
229 				  bt541->zinitix_mode);
230 	if (error)
231 		return error;
232 
233 	error = zinitix_write_u16(client, BT541_TOUCH_MODE,
234 				  bt541->zinitix_mode);
235 	if (error)
236 		return error;
237 
238 	error = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG,
239 				  BIT_PT_CNT_CHANGE | BIT_DOWN | BIT_MOVE |
240 					BIT_UP);
241 	if (error)
242 		return error;
243 
244 	/* clear queue */
245 	for (i = 0; i < 10; i++) {
246 		zinitix_write_cmd(client, BT541_CLEAR_INT_STATUS_CMD);
247 		udelay(10);
248 	}
249 
250 	return 0;
251 }
252 
253 static int zinitix_init_regulators(struct bt541_ts_data *bt541)
254 {
255 	struct i2c_client *client = bt541->client;
256 	int error;
257 
258 	bt541->supplies[0].supply = "vdd";
259 	bt541->supplies[1].supply = "vddo";
260 	error = devm_regulator_bulk_get(&client->dev,
261 					ARRAY_SIZE(bt541->supplies),
262 					bt541->supplies);
263 	if (error < 0) {
264 		dev_err(&client->dev, "Failed to get regulators: %d\n", error);
265 		return error;
266 	}
267 
268 	return 0;
269 }
270 
271 static int zinitix_send_power_on_sequence(struct bt541_ts_data *bt541)
272 {
273 	int error;
274 	struct i2c_client *client = bt541->client;
275 
276 	error = zinitix_write_u16(client, 0xc000, 0x0001);
277 	if (error) {
278 		dev_err(&client->dev,
279 			"Failed to send power sequence(vendor cmd enable)\n");
280 		return error;
281 	}
282 	udelay(10);
283 
284 	error = zinitix_write_cmd(client, 0xc004);
285 	if (error) {
286 		dev_err(&client->dev,
287 			"Failed to send power sequence (intn clear)\n");
288 		return error;
289 	}
290 	udelay(10);
291 
292 	error = zinitix_write_u16(client, 0xc002, 0x0001);
293 	if (error) {
294 		dev_err(&client->dev,
295 			"Failed to send power sequence (nvm init)\n");
296 		return error;
297 	}
298 	mdelay(2);
299 
300 	error = zinitix_write_u16(client, 0xc001, 0x0001);
301 	if (error) {
302 		dev_err(&client->dev,
303 			"Failed to send power sequence (program start)\n");
304 		return error;
305 	}
306 	msleep(FIRMWARE_ON_DELAY);
307 
308 	return 0;
309 }
310 
311 static void zinitix_report_finger(struct bt541_ts_data *bt541, int slot,
312 				  const struct point_coord *p)
313 {
314 	input_mt_slot(bt541->input_dev, slot);
315 	input_mt_report_slot_state(bt541->input_dev, MT_TOOL_FINGER, true);
316 	touchscreen_report_pos(bt541->input_dev, &bt541->prop,
317 			       le16_to_cpu(p->x), le16_to_cpu(p->y), true);
318 	input_report_abs(bt541->input_dev, ABS_MT_TOUCH_MAJOR, p->width);
319 }
320 
321 static irqreturn_t zinitix_ts_irq_handler(int irq, void *bt541_handler)
322 {
323 	struct bt541_ts_data *bt541 = bt541_handler;
324 	struct i2c_client *client = bt541->client;
325 	struct touch_event touch_event;
326 	int error;
327 	int i;
328 
329 	memset(&touch_event, 0, sizeof(struct touch_event));
330 
331 	error = zinitix_read_data(bt541->client, BT541_POINT_STATUS_REG,
332 				  &touch_event, sizeof(struct touch_event));
333 	if (error) {
334 		dev_err(&client->dev, "Failed to read in touchpoint struct\n");
335 		goto out;
336 	}
337 
338 	for (i = 0; i < MAX_SUPPORTED_FINGER_NUM; i++)
339 		if (touch_event.point_coord[i].sub_status & SUB_BIT_EXIST)
340 			zinitix_report_finger(bt541, i,
341 					      &touch_event.point_coord[i]);
342 
343 	input_mt_sync_frame(bt541->input_dev);
344 	input_sync(bt541->input_dev);
345 
346 out:
347 	zinitix_write_cmd(bt541->client, BT541_CLEAR_INT_STATUS_CMD);
348 	return IRQ_HANDLED;
349 }
350 
351 static int zinitix_start(struct bt541_ts_data *bt541)
352 {
353 	int error;
354 
355 	error = regulator_bulk_enable(ARRAY_SIZE(bt541->supplies),
356 				      bt541->supplies);
357 	if (error) {
358 		dev_err(&bt541->client->dev,
359 			"Failed to enable regulators: %d\n", error);
360 		return error;
361 	}
362 
363 	msleep(CHIP_ON_DELAY);
364 
365 	error = zinitix_send_power_on_sequence(bt541);
366 	if (error) {
367 		dev_err(&bt541->client->dev,
368 			"Error while sending power-on sequence: %d\n", error);
369 		return error;
370 	}
371 
372 	error = zinitix_init_touch(bt541);
373 	if (error) {
374 		dev_err(&bt541->client->dev,
375 			"Error while configuring touch IC\n");
376 		return error;
377 	}
378 
379 	enable_irq(bt541->client->irq);
380 
381 	return 0;
382 }
383 
384 static int zinitix_stop(struct bt541_ts_data *bt541)
385 {
386 	int error;
387 
388 	disable_irq(bt541->client->irq);
389 
390 	error = regulator_bulk_disable(ARRAY_SIZE(bt541->supplies),
391 				       bt541->supplies);
392 	if (error) {
393 		dev_err(&bt541->client->dev,
394 			"Failed to disable regulators: %d\n", error);
395 		return error;
396 	}
397 
398 	return 0;
399 }
400 
401 static int zinitix_input_open(struct input_dev *dev)
402 {
403 	struct bt541_ts_data *bt541 = input_get_drvdata(dev);
404 
405 	return zinitix_start(bt541);
406 }
407 
408 static void zinitix_input_close(struct input_dev *dev)
409 {
410 	struct bt541_ts_data *bt541 = input_get_drvdata(dev);
411 
412 	zinitix_stop(bt541);
413 }
414 
415 static int zinitix_init_input_dev(struct bt541_ts_data *bt541)
416 {
417 	struct input_dev *input_dev;
418 	int error;
419 
420 	input_dev = devm_input_allocate_device(&bt541->client->dev);
421 	if (!input_dev) {
422 		dev_err(&bt541->client->dev,
423 			"Failed to allocate input device.");
424 		return -ENOMEM;
425 	}
426 
427 	input_set_drvdata(input_dev, bt541);
428 	bt541->input_dev = input_dev;
429 
430 	input_dev->name = "Zinitix Capacitive TouchScreen";
431 	input_dev->phys = "input/ts";
432 	input_dev->id.bustype = BUS_I2C;
433 	input_dev->open = zinitix_input_open;
434 	input_dev->close = zinitix_input_close;
435 
436 	input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
437 	input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
438 	input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
439 	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
440 
441 	touchscreen_parse_properties(input_dev, true, &bt541->prop);
442 	if (!bt541->prop.max_x || !bt541->prop.max_y) {
443 		dev_err(&bt541->client->dev,
444 			"Touchscreen-size-x and/or touchscreen-size-y not set in dts\n");
445 		return -EINVAL;
446 	}
447 
448 	error = input_mt_init_slots(input_dev, MAX_SUPPORTED_FINGER_NUM,
449 				    INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
450 	if (error) {
451 		dev_err(&bt541->client->dev,
452 			"Failed to initialize MT slots: %d", error);
453 		return error;
454 	}
455 
456 	error = input_register_device(input_dev);
457 	if (error) {
458 		dev_err(&bt541->client->dev,
459 			"Failed to register input device: %d", error);
460 		return error;
461 	}
462 
463 	return 0;
464 }
465 
466 static int zinitix_ts_probe(struct i2c_client *client)
467 {
468 	struct bt541_ts_data *bt541;
469 	int error;
470 
471 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
472 		dev_err(&client->dev,
473 			"Failed to assert adapter's support for plain I2C.\n");
474 		return -ENXIO;
475 	}
476 
477 	bt541 = devm_kzalloc(&client->dev, sizeof(*bt541), GFP_KERNEL);
478 	if (!bt541)
479 		return -ENOMEM;
480 
481 	bt541->client = client;
482 	i2c_set_clientdata(client, bt541);
483 
484 	error = zinitix_init_regulators(bt541);
485 	if (error) {
486 		dev_err(&client->dev,
487 			"Failed to initialize regulators: %d\n", error);
488 		return error;
489 	}
490 
491 	error = zinitix_init_input_dev(bt541);
492 	if (error) {
493 		dev_err(&client->dev,
494 			"Failed to initialize input device: %d\n", error);
495 		return error;
496 	}
497 
498 	error = device_property_read_u32(&client->dev, "zinitix,mode",
499 					 &bt541->zinitix_mode);
500 	if (error < 0) {
501 		/* fall back to mode 2 */
502 		bt541->zinitix_mode = DEFAULT_TOUCH_POINT_MODE;
503 	}
504 
505 	if (bt541->zinitix_mode != 2) {
506 		/*
507 		 * If there are devices that don't support mode 2, support
508 		 * for other modes (0, 1) will be needed.
509 		 */
510 		dev_err(&client->dev,
511 			"Malformed zinitix,mode property, must be 2 (supplied: %d)\n",
512 			bt541->zinitix_mode);
513 		return -EINVAL;
514 	}
515 
516 	error = devm_request_threaded_irq(&client->dev, client->irq,
517 					  NULL, zinitix_ts_irq_handler,
518 					  IRQF_ONESHOT | IRQF_NO_AUTOEN,
519 					  client->name, bt541);
520 	if (error) {
521 		dev_err(&client->dev, "Failed to request IRQ: %d\n", error);
522 		return error;
523 	}
524 
525 	return 0;
526 }
527 
528 static int __maybe_unused zinitix_suspend(struct device *dev)
529 {
530 	struct i2c_client *client = to_i2c_client(dev);
531 	struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
532 
533 	mutex_lock(&bt541->input_dev->mutex);
534 
535 	if (input_device_enabled(bt541->input_dev))
536 		zinitix_stop(bt541);
537 
538 	mutex_unlock(&bt541->input_dev->mutex);
539 
540 	return 0;
541 }
542 
543 static int __maybe_unused zinitix_resume(struct device *dev)
544 {
545 	struct i2c_client *client = to_i2c_client(dev);
546 	struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
547 	int ret = 0;
548 
549 	mutex_lock(&bt541->input_dev->mutex);
550 
551 	if (input_device_enabled(bt541->input_dev))
552 		ret = zinitix_start(bt541);
553 
554 	mutex_unlock(&bt541->input_dev->mutex);
555 
556 	return ret;
557 }
558 
559 static SIMPLE_DEV_PM_OPS(zinitix_pm_ops, zinitix_suspend, zinitix_resume);
560 
561 #ifdef CONFIG_OF
562 static const struct of_device_id zinitix_of_match[] = {
563 	{ .compatible = "zinitix,bt541" },
564 	{ }
565 };
566 MODULE_DEVICE_TABLE(of, zinitix_of_match);
567 #endif
568 
569 static struct i2c_driver zinitix_ts_driver = {
570 	.probe_new = zinitix_ts_probe,
571 	.driver = {
572 		.name = "Zinitix-TS",
573 		.pm = &zinitix_pm_ops,
574 		.of_match_table = of_match_ptr(zinitix_of_match),
575 	},
576 };
577 module_i2c_driver(zinitix_ts_driver);
578 
579 MODULE_AUTHOR("Michael Srba <Michael.Srba@seznam.cz>");
580 MODULE_DESCRIPTION("Zinitix touchscreen driver");
581 MODULE_LICENSE("GPL v2");
582