1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Driver for ChipOne icn8505 i2c touchscreen controller
4  *
5  * Copyright (c) 2015-2018 Red Hat Inc.
6  *
7  * Red Hat authors:
8  * Hans de Goede <hdegoede@redhat.com>
9  */
10 
11 #include <asm/unaligned.h>
12 #include <linux/acpi.h>
13 #include <linux/crc32.h>
14 #include <linux/delay.h>
15 #include <linux/firmware.h>
16 #include <linux/interrupt.h>
17 #include <linux/i2c.h>
18 #include <linux/input.h>
19 #include <linux/input/mt.h>
20 #include <linux/input/touchscreen.h>
21 #include <linux/module.h>
22 
23 /* Normal operation mode defines */
24 #define ICN8505_REG_ADDR_WIDTH		16
25 
26 #define ICN8505_REG_POWER		0x0004
27 #define ICN8505_REG_TOUCHDATA		0x1000
28 #define ICN8505_REG_CONFIGDATA		0x8000
29 
30 /* ICN8505_REG_POWER commands */
31 #define ICN8505_POWER_ACTIVE		0x00
32 #define ICN8505_POWER_MONITOR		0x01
33 #define ICN8505_POWER_HIBERNATE		0x02
34 /*
35  * The Android driver uses these to turn on/off the charger filter, but the
36  * filter is way too aggressive making e.g. onscreen keyboards unusable.
37  */
38 #define ICN8505_POWER_ENA_CHARGER_MODE	0x55
39 #define ICN8505_POWER_DIS_CHARGER_MODE	0x66
40 
41 #define ICN8505_MAX_TOUCHES		10
42 
43 /* Programming mode defines */
44 #define ICN8505_PROG_I2C_ADDR		0x30
45 #define ICN8505_PROG_REG_ADDR_WIDTH	24
46 
47 #define MAX_FW_UPLOAD_TRIES		3
48 
49 struct icn8505_touch {
50 	u8 slot;
51 	u8 x[2];
52 	u8 y[2];
53 	u8 pressure;	/* Seems more like finger width then pressure really */
54 	u8 event;
55 /* The difference between 2 and 3 is unclear */
56 #define ICN8505_EVENT_NO_DATA	1 /* No finger seen yet since wakeup */
57 #define ICN8505_EVENT_UPDATE1	2 /* New or updated coordinates */
58 #define ICN8505_EVENT_UPDATE2	3 /* New or updated coordinates */
59 #define ICN8505_EVENT_END	4 /* Finger lifted */
60 } __packed;
61 
62 struct icn8505_touch_data {
63 	u8 softbutton;
64 	u8 touch_count;
65 	struct icn8505_touch touches[ICN8505_MAX_TOUCHES];
66 } __packed;
67 
68 struct icn8505_data {
69 	struct i2c_client *client;
70 	struct input_dev *input;
71 	struct gpio_desc *wake_gpio;
72 	struct touchscreen_properties prop;
73 	char firmware_name[32];
74 };
75 
76 static int icn8505_read_xfer(struct i2c_client *client, u16 i2c_addr,
77 			     int reg_addr, int reg_addr_width,
78 			     void *data, int len, bool silent)
79 {
80 	u8 buf[3];
81 	int i, ret;
82 	struct i2c_msg msg[2] = {
83 		{
84 			.addr = i2c_addr,
85 			.buf = buf,
86 			.len = reg_addr_width / 8,
87 		},
88 		{
89 			.addr = i2c_addr,
90 			.flags = I2C_M_RD,
91 			.buf = data,
92 			.len = len,
93 		}
94 	};
95 
96 	for (i = 0; i < (reg_addr_width / 8); i++)
97 		buf[i] = (reg_addr >> (reg_addr_width - (i + 1) * 8)) & 0xff;
98 
99 	ret = i2c_transfer(client->adapter, msg, 2);
100 	if (ret != ARRAY_SIZE(msg)) {
101 		if (ret >= 0)
102 			ret = -EIO;
103 		if (!silent)
104 			dev_err(&client->dev,
105 				"Error reading addr %#x reg %#x: %d\n",
106 				i2c_addr, reg_addr, ret);
107 		return ret;
108 	}
109 
110 	return 0;
111 }
112 
113 static int icn8505_write_xfer(struct i2c_client *client, u16 i2c_addr,
114 			      int reg_addr, int reg_addr_width,
115 			      const void *data, int len, bool silent)
116 {
117 	u8 buf[3 + 32]; /* 3 bytes for 24 bit reg-addr + 32 bytes max len */
118 	int i, ret;
119 	struct i2c_msg msg = {
120 		.addr = i2c_addr,
121 		.buf = buf,
122 		.len = reg_addr_width / 8 + len,
123 	};
124 
125 	if (WARN_ON(len > 32))
126 		return -EINVAL;
127 
128 	for (i = 0; i < (reg_addr_width / 8); i++)
129 		buf[i] = (reg_addr >> (reg_addr_width - (i + 1) * 8)) & 0xff;
130 
131 	memcpy(buf + reg_addr_width / 8, data, len);
132 
133 	ret = i2c_transfer(client->adapter, &msg, 1);
134 	if (ret != 1) {
135 		if (ret >= 0)
136 			ret = -EIO;
137 		if (!silent)
138 			dev_err(&client->dev,
139 				"Error writing addr %#x reg %#x: %d\n",
140 				i2c_addr, reg_addr, ret);
141 		return ret;
142 	}
143 
144 	return 0;
145 }
146 
147 static int icn8505_read_data(struct icn8505_data *icn8505, int reg,
148 			     void *buf, int len)
149 {
150 	return icn8505_read_xfer(icn8505->client, icn8505->client->addr, reg,
151 				 ICN8505_REG_ADDR_WIDTH, buf, len, false);
152 }
153 
154 static int icn8505_read_reg_silent(struct icn8505_data *icn8505, int reg)
155 {
156 	u8 buf;
157 	int error;
158 
159 	error = icn8505_read_xfer(icn8505->client, icn8505->client->addr, reg,
160 				  ICN8505_REG_ADDR_WIDTH, &buf, 1, true);
161 	if (error)
162 		return error;
163 
164 	return buf;
165 }
166 
167 static int icn8505_write_reg(struct icn8505_data *icn8505, int reg, u8 val)
168 {
169 	return icn8505_write_xfer(icn8505->client, icn8505->client->addr, reg,
170 				  ICN8505_REG_ADDR_WIDTH, &val, 1, false);
171 }
172 
173 static int icn8505_read_prog_data(struct icn8505_data *icn8505, int reg,
174 				  void *buf, int len)
175 {
176 	return icn8505_read_xfer(icn8505->client, ICN8505_PROG_I2C_ADDR, reg,
177 				 ICN8505_PROG_REG_ADDR_WIDTH, buf, len, false);
178 }
179 
180 static int icn8505_write_prog_data(struct icn8505_data *icn8505, int reg,
181 				   const void *buf, int len)
182 {
183 	return icn8505_write_xfer(icn8505->client, ICN8505_PROG_I2C_ADDR, reg,
184 				  ICN8505_PROG_REG_ADDR_WIDTH, buf, len, false);
185 }
186 
187 static int icn8505_write_prog_reg(struct icn8505_data *icn8505, int reg, u8 val)
188 {
189 	return icn8505_write_xfer(icn8505->client, ICN8505_PROG_I2C_ADDR, reg,
190 				  ICN8505_PROG_REG_ADDR_WIDTH, &val, 1, false);
191 }
192 
193 /*
194  * Note this function uses a number of magic register addresses and values,
195  * there are deliberately no defines for these because the algorithm is taken
196  * from the icn85xx Android driver and I do not want to make up possibly wrong
197  * names for the addresses and/or values.
198  */
199 static int icn8505_try_fw_upload(struct icn8505_data *icn8505,
200 				 const struct firmware *fw)
201 {
202 	struct device *dev = &icn8505->client->dev;
203 	size_t offset, count;
204 	int error;
205 	u8 buf[4];
206 	u32 crc;
207 
208 	/* Put the controller in programming mode */
209 	error = icn8505_write_prog_reg(icn8505, 0xcc3355, 0x5a);
210 	if (error)
211 		return error;
212 
213 	usleep_range(2000, 5000);
214 
215 	error = icn8505_write_prog_reg(icn8505, 0x040400, 0x01);
216 	if (error)
217 		return error;
218 
219 	usleep_range(2000, 5000);
220 
221 	error = icn8505_read_prog_data(icn8505, 0x040002, buf, 1);
222 	if (error)
223 		return error;
224 
225 	if (buf[0] != 0x85) {
226 		dev_err(dev, "Failed to enter programming mode\n");
227 		return -ENODEV;
228 	}
229 
230 	usleep_range(1000, 5000);
231 
232 	/* Enable CRC mode */
233 	error = icn8505_write_prog_reg(icn8505, 0x40028, 1);
234 	if (error)
235 		return error;
236 
237 	/* Send the firmware to SRAM */
238 	for (offset = 0; offset < fw->size; offset += count) {
239 		count = min_t(size_t, fw->size - offset, 32);
240 		error = icn8505_write_prog_data(icn8505, offset,
241 					      fw->data + offset, count);
242 		if (error)
243 			return error;
244 	}
245 
246 	/* Disable CRC mode */
247 	error = icn8505_write_prog_reg(icn8505, 0x40028, 0);
248 	if (error)
249 		return error;
250 
251 	/* Get and check length and CRC */
252 	error = icn8505_read_prog_data(icn8505, 0x40034, buf, 2);
253 	if (error)
254 		return error;
255 
256 	if (get_unaligned_le16(buf) != fw->size) {
257 		dev_warn(dev, "Length mismatch after uploading fw\n");
258 		return -EIO;
259 	}
260 
261 	error = icn8505_read_prog_data(icn8505, 0x4002c, buf, 4);
262 	if (error)
263 		return error;
264 
265 	crc = crc32_be(0, fw->data, fw->size);
266 	if (get_unaligned_le32(buf) != crc) {
267 		dev_warn(dev, "CRC mismatch after uploading fw\n");
268 		return -EIO;
269 	}
270 
271 	/* Boot controller from SRAM */
272 	error = icn8505_write_prog_reg(icn8505, 0x40400, 0x03);
273 	if (error)
274 		return error;
275 
276 	usleep_range(2000, 5000);
277 	return 0;
278 }
279 
280 static int icn8505_upload_fw(struct icn8505_data *icn8505)
281 {
282 	struct device *dev = &icn8505->client->dev;
283 	const struct firmware *fw;
284 	int i, error;
285 
286 	/*
287 	 * Always load the firmware, even if we don't need it at boot, we
288 	 * we may need it at resume. Having loaded it once will make the
289 	 * firmware class code cache it at suspend/resume.
290 	 */
291 	error = request_firmware(&fw, icn8505->firmware_name, dev);
292 	if (error) {
293 		dev_err(dev, "Firmware request error %d\n", error);
294 		return error;
295 	}
296 
297 	/* Check if the controller is not already up and running */
298 	if (icn8505_read_reg_silent(icn8505, 0x000a) == 0x85)
299 		goto success;
300 
301 	for (i = 1; i <= MAX_FW_UPLOAD_TRIES; i++) {
302 		error = icn8505_try_fw_upload(icn8505, fw);
303 		if (!error)
304 			goto success;
305 
306 		dev_err(dev, "Failed to upload firmware: %d (attempt %d/%d)\n",
307 			error, i, MAX_FW_UPLOAD_TRIES);
308 		usleep_range(2000, 5000);
309 	}
310 
311 success:
312 	release_firmware(fw);
313 	return error;
314 }
315 
316 static bool icn8505_touch_active(u8 event)
317 {
318 	return event == ICN8505_EVENT_UPDATE1 ||
319 	       event == ICN8505_EVENT_UPDATE2;
320 }
321 
322 static irqreturn_t icn8505_irq(int irq, void *dev_id)
323 {
324 	struct icn8505_data *icn8505 = dev_id;
325 	struct device *dev = &icn8505->client->dev;
326 	struct icn8505_touch_data touch_data;
327 	int i, error;
328 
329 	error = icn8505_read_data(icn8505, ICN8505_REG_TOUCHDATA,
330 				  &touch_data, sizeof(touch_data));
331 	if (error) {
332 		dev_err(dev, "Error reading touch data: %d\n", error);
333 		return IRQ_HANDLED;
334 	}
335 
336 	if (touch_data.touch_count > ICN8505_MAX_TOUCHES) {
337 		dev_warn(dev, "Too many touches %d > %d\n",
338 			 touch_data.touch_count, ICN8505_MAX_TOUCHES);
339 		touch_data.touch_count = ICN8505_MAX_TOUCHES;
340 	}
341 
342 	for (i = 0; i < touch_data.touch_count; i++) {
343 		struct icn8505_touch *touch = &touch_data.touches[i];
344 		bool act = icn8505_touch_active(touch->event);
345 
346 		input_mt_slot(icn8505->input, touch->slot);
347 		input_mt_report_slot_state(icn8505->input, MT_TOOL_FINGER, act);
348 		if (!act)
349 			continue;
350 
351 		touchscreen_report_pos(icn8505->input, &icn8505->prop,
352 				       get_unaligned_le16(touch->x),
353 				       get_unaligned_le16(touch->y),
354 				       true);
355 	}
356 
357 	input_mt_sync_frame(icn8505->input);
358 	input_report_key(icn8505->input, KEY_LEFTMETA,
359 			 touch_data.softbutton == 1);
360 	input_sync(icn8505->input);
361 
362 	return IRQ_HANDLED;
363 }
364 
365 static int icn8505_probe_acpi(struct icn8505_data *icn8505, struct device *dev)
366 {
367 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
368 	const char *subsys = "unknown";
369 	struct acpi_device *adev;
370 	union acpi_object *obj;
371 	acpi_status status;
372 
373 	adev = ACPI_COMPANION(dev);
374 	if (!adev)
375 		return -ENODEV;
376 
377 	status = acpi_evaluate_object(adev->handle, "_SUB", NULL, &buffer);
378 	if (ACPI_SUCCESS(status)) {
379 		obj = buffer.pointer;
380 		if (obj->type == ACPI_TYPE_STRING)
381 			subsys = obj->string.pointer;
382 		else
383 			dev_warn(dev, "Warning ACPI _SUB did not return a string\n");
384 	} else {
385 		dev_warn(dev, "Warning ACPI _SUB failed: %#x\n", status);
386 		buffer.pointer = NULL;
387 	}
388 
389 	snprintf(icn8505->firmware_name, sizeof(icn8505->firmware_name),
390 		 "chipone/icn8505-%s.fw", subsys);
391 
392 	kfree(buffer.pointer);
393 	return 0;
394 }
395 
396 static int icn8505_probe(struct i2c_client *client)
397 {
398 	struct device *dev = &client->dev;
399 	struct icn8505_data *icn8505;
400 	struct input_dev *input;
401 	__le16 resolution[2];
402 	int error;
403 
404 	if (!client->irq) {
405 		dev_err(dev, "No irq specified\n");
406 		return -EINVAL;
407 	}
408 
409 	icn8505 = devm_kzalloc(dev, sizeof(*icn8505), GFP_KERNEL);
410 	if (!icn8505)
411 		return -ENOMEM;
412 
413 	input = devm_input_allocate_device(dev);
414 	if (!input)
415 		return -ENOMEM;
416 
417 	input->name = client->name;
418 	input->id.bustype = BUS_I2C;
419 
420 	input_set_capability(input, EV_ABS, ABS_MT_POSITION_X);
421 	input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y);
422 	input_set_capability(input, EV_KEY, KEY_LEFTMETA);
423 
424 	icn8505->client = client;
425 	icn8505->input = input;
426 	input_set_drvdata(input, icn8505);
427 
428 	error = icn8505_probe_acpi(icn8505, dev);
429 	if (error)
430 		return error;
431 
432 	error = icn8505_upload_fw(icn8505);
433 	if (error)
434 		return error;
435 
436 	error = icn8505_read_data(icn8505, ICN8505_REG_CONFIGDATA,
437 				resolution, sizeof(resolution));
438 	if (error) {
439 		dev_err(dev, "Error reading resolution: %d\n", error);
440 		return error;
441 	}
442 
443 	input_set_abs_params(input, ABS_MT_POSITION_X, 0,
444 			     le16_to_cpu(resolution[0]) - 1, 0, 0);
445 	input_set_abs_params(input, ABS_MT_POSITION_Y, 0,
446 			     le16_to_cpu(resolution[1]) - 1, 0, 0);
447 
448 	touchscreen_parse_properties(input, true, &icn8505->prop);
449 	if (!input_abs_get_max(input, ABS_MT_POSITION_X) ||
450 	    !input_abs_get_max(input, ABS_MT_POSITION_Y)) {
451 		dev_err(dev, "Error touchscreen-size-x and/or -y missing\n");
452 		return -EINVAL;
453 	}
454 
455 	error = input_mt_init_slots(input, ICN8505_MAX_TOUCHES,
456 				  INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
457 	if (error)
458 		return error;
459 
460 	error = devm_request_threaded_irq(dev, client->irq, NULL, icn8505_irq,
461 					IRQF_ONESHOT, client->name, icn8505);
462 	if (error) {
463 		dev_err(dev, "Error requesting irq: %d\n", error);
464 		return error;
465 	}
466 
467 	error = input_register_device(input);
468 	if (error)
469 		return error;
470 
471 	i2c_set_clientdata(client, icn8505);
472 	return 0;
473 }
474 
475 static int __maybe_unused icn8505_suspend(struct device *dev)
476 {
477 	struct icn8505_data *icn8505 = i2c_get_clientdata(to_i2c_client(dev));
478 
479 	disable_irq(icn8505->client->irq);
480 
481 	icn8505_write_reg(icn8505, ICN8505_REG_POWER, ICN8505_POWER_HIBERNATE);
482 
483 	return 0;
484 }
485 
486 static int __maybe_unused icn8505_resume(struct device *dev)
487 {
488 	struct icn8505_data *icn8505 = i2c_get_clientdata(to_i2c_client(dev));
489 	int error;
490 
491 	error = icn8505_upload_fw(icn8505);
492 	if (error)
493 		return error;
494 
495 	enable_irq(icn8505->client->irq);
496 	return 0;
497 }
498 
499 static SIMPLE_DEV_PM_OPS(icn8505_pm_ops, icn8505_suspend, icn8505_resume);
500 
501 static const struct acpi_device_id icn8505_acpi_match[] = {
502 	{ "CHPN0001" },
503 	{ }
504 };
505 MODULE_DEVICE_TABLE(acpi, icn8505_acpi_match);
506 
507 static struct i2c_driver icn8505_driver = {
508 	.driver = {
509 		.name	= "chipone_icn8505",
510 		.pm	= &icn8505_pm_ops,
511 		.acpi_match_table = icn8505_acpi_match,
512 	},
513 	.probe_new = icn8505_probe,
514 };
515 
516 module_i2c_driver(icn8505_driver);
517 
518 MODULE_DESCRIPTION("ChipOne icn8505 I2C Touchscreen Driver");
519 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
520 MODULE_LICENSE("GPL");
521