xref: /linux/drivers/input/touchscreen/st1232.c (revision ffd01c3bcc1af4d8c3e7949152af0d9fe3d1fda5) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * ST1232 Touchscreen Controller Driver
4  *
5  * Copyright (C) 2010 Renesas Solutions Corp.
6  *	Tony SIM <chinyeow.sim.xt@renesas.com>
7  *
8  * Using code from:
9  *  - android.git.kernel.org: projects/kernel/common.git: synaptics_i2c_rmi.c
10  *	Copyright (C) 2007 Google, Inc.
11  */
12 
13 #include <linux/delay.h>
14 #include <linux/gpio/consumer.h>
15 #include <linux/i2c.h>
16 #include <linux/input.h>
17 #include <linux/input/mt.h>
18 #include <linux/input/touch-overlay.h>
19 #include <linux/input/touchscreen.h>
20 #include <linux/interrupt.h>
21 #include <linux/module.h>
22 #include <linux/of.h>
23 #include <linux/pm_qos.h>
24 #include <linux/slab.h>
25 #include <linux/types.h>
26 #include <asm/byteorder.h>
27 
28 #define ST1232_TS_NAME	"st1232-ts"
29 #define ST1633_TS_NAME	"st1633-ts"
30 
31 #define REG_FIRMWARE_VERSION	0x00
32 #define REG_FIRMWARE_REVISION_3	0x0C
33 
34 #define REG_STATUS		0x01	/* Device Status | Error Code */
35 
36 #define STATUS_NORMAL		0x00
37 #define STATUS_INIT		0x01
38 #define STATUS_ERROR		0x02
39 #define STATUS_AUTO_TUNING	0x03
40 #define STATUS_IDLE		0x04
41 #define STATUS_POWER_DOWN	0x05
42 
43 #define ERROR_NONE		0x00
44 #define ERROR_INVALID_ADDRESS	0x10
45 #define ERROR_INVALID_VALUE	0x20
46 #define ERROR_INVALID_PLATFORM	0x30
47 
48 #define REG_XY_RESOLUTION	0x04
49 #define REG_XY_COORDINATES	0x12
50 #define ST_TS_MAX_FINGERS	10
51 
52 struct st_chip_info {
53 	bool	have_z;
54 	u16	max_area;
55 	u16	max_fingers;
56 };
57 
58 struct st1232_ts_data {
59 	struct i2c_client *client;
60 	struct input_dev *input_dev;
61 	struct touchscreen_properties prop;
62 	struct dev_pm_qos_request low_latency_req;
63 	struct gpio_desc *reset_gpio;
64 	const struct st_chip_info *chip_info;
65 	struct list_head touch_overlay_list;
66 	int read_buf_len;
67 	u8 *read_buf;
68 	u8 fw_version;
69 	u32 fw_revision;
70 };
71 
72 static ssize_t fw_version_show(struct device *dev,
73 			       struct device_attribute *attr, char *buf)
74 {
75 	struct i2c_client *client = to_i2c_client(dev);
76 	struct st1232_ts_data *st1232_ts = i2c_get_clientdata(client);
77 
78 	return sysfs_emit(buf, "%u\n", st1232_ts->fw_version);
79 }
80 
81 static ssize_t fw_revision_show(struct device *dev,
82 				struct device_attribute *attr, char *buf)
83 {
84 	struct i2c_client *client = to_i2c_client(dev);
85 	struct st1232_ts_data *st1232_ts = i2c_get_clientdata(client);
86 
87 	return sysfs_emit(buf, "%08x\n", st1232_ts->fw_revision);
88 }
89 
90 static DEVICE_ATTR_RO(fw_version);
91 static DEVICE_ATTR_RO(fw_revision);
92 
93 static struct attribute *st1232_attrs[] = {
94 	&dev_attr_fw_version.attr,
95 	&dev_attr_fw_revision.attr,
96 	NULL,
97 };
98 ATTRIBUTE_GROUPS(st1232);
99 
100 static int st1232_ts_read_data(struct st1232_ts_data *ts, u8 reg,
101 			       unsigned int n)
102 {
103 	struct i2c_client *client = ts->client;
104 	struct i2c_msg msg[] = {
105 		{
106 			.addr	= client->addr,
107 			.len	= sizeof(reg),
108 			.buf	= &reg,
109 		},
110 		{
111 			.addr	= client->addr,
112 			.flags	= I2C_M_RD | I2C_M_DMA_SAFE,
113 			.len	= n,
114 			.buf	= ts->read_buf,
115 		}
116 	};
117 	int ret;
118 
119 	ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
120 	if (ret != ARRAY_SIZE(msg))
121 		return ret < 0 ? ret : -EIO;
122 
123 	return 0;
124 }
125 
126 static int st1232_ts_wait_ready(struct st1232_ts_data *ts)
127 {
128 	unsigned int retries;
129 	int error;
130 
131 	for (retries = 100; retries; retries--) {
132 		error = st1232_ts_read_data(ts, REG_STATUS, 1);
133 		if (!error) {
134 			switch (ts->read_buf[0]) {
135 			case STATUS_NORMAL | ERROR_NONE:
136 			case STATUS_IDLE | ERROR_NONE:
137 				return 0;
138 			}
139 		}
140 
141 		usleep_range(1000, 2000);
142 	}
143 
144 	return -ENXIO;
145 }
146 
147 static int st1232_ts_read_fw_version(struct st1232_ts_data *ts,
148 				     u8 *fw_version, u32 *fw_revision)
149 {
150 	int error;
151 
152 	/* select firmware version register */
153 	error = st1232_ts_read_data(ts, REG_FIRMWARE_VERSION, 1);
154 	if (error)
155 		return error;
156 	*fw_version = ts->read_buf[0];
157 
158 	/* select firmware revision register */
159 	error = st1232_ts_read_data(ts, REG_FIRMWARE_REVISION_3, 4);
160 	if (error)
161 		return error;
162 	*fw_revision = le32_to_cpup((__le32 *)ts->read_buf);
163 
164 	return 0;
165 }
166 
167 static int st1232_ts_read_resolution(struct st1232_ts_data *ts, u16 *max_x,
168 				     u16 *max_y)
169 {
170 	u8 *buf;
171 	int error;
172 
173 	/* select resolution register */
174 	error = st1232_ts_read_data(ts, REG_XY_RESOLUTION, 3);
175 	if (error)
176 		return error;
177 
178 	buf = ts->read_buf;
179 
180 	*max_x = (((buf[0] & 0x0070) << 4) | buf[1]) - 1;
181 	*max_y = (((buf[0] & 0x0007) << 8) | buf[2]) - 1;
182 
183 	return 0;
184 }
185 
186 static int st1232_ts_parse_and_report(struct st1232_ts_data *ts)
187 {
188 	struct input_dev *input = ts->input_dev;
189 	struct input_mt_pos pos[ST_TS_MAX_FINGERS];
190 	u8 z[ST_TS_MAX_FINGERS];
191 	int slots[ST_TS_MAX_FINGERS];
192 	int n_contacts = 0;
193 	int i;
194 
195 	for (i = 0; i < ts->chip_info->max_fingers; i++) {
196 		u8 *buf = &ts->read_buf[i * 4];
197 
198 		if (buf[0] & BIT(7)) {
199 			unsigned int x = ((buf[0] & 0x70) << 4) | buf[1];
200 			unsigned int y = ((buf[0] & 0x07) << 8) | buf[2];
201 
202 			touchscreen_set_mt_pos(&pos[n_contacts],
203 					       &ts->prop, x, y);
204 
205 			/* st1232 includes a z-axis / touch strength */
206 			if (ts->chip_info->have_z)
207 				z[n_contacts] = ts->read_buf[i + 6];
208 
209 			n_contacts++;
210 		}
211 	}
212 
213 	input_mt_assign_slots(input, slots, pos, n_contacts, 0);
214 	for (i = 0; i < n_contacts; i++) {
215 		if (touch_overlay_process_contact(&ts->touch_overlay_list,
216 						  input, &pos[i], slots[i]))
217 			continue;
218 
219 		input_mt_slot(input, slots[i]);
220 		input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
221 		input_report_abs(input, ABS_MT_POSITION_X, pos[i].x);
222 		input_report_abs(input, ABS_MT_POSITION_Y, pos[i].y);
223 		if (ts->chip_info->have_z)
224 			input_report_abs(input, ABS_MT_TOUCH_MAJOR, z[i]);
225 	}
226 
227 	touch_overlay_sync_frame(&ts->touch_overlay_list, input);
228 	input_mt_sync_frame(input);
229 	input_sync(input);
230 
231 	return n_contacts;
232 }
233 
234 static irqreturn_t st1232_ts_irq_handler(int irq, void *dev_id)
235 {
236 	struct st1232_ts_data *ts = dev_id;
237 	int count;
238 	int error;
239 
240 	error = st1232_ts_read_data(ts, REG_XY_COORDINATES, ts->read_buf_len);
241 	if (error)
242 		goto out;
243 
244 	count = st1232_ts_parse_and_report(ts);
245 	if (!count) {
246 		if (ts->low_latency_req.dev) {
247 			dev_pm_qos_remove_request(&ts->low_latency_req);
248 			ts->low_latency_req.dev = NULL;
249 		}
250 	} else if (!ts->low_latency_req.dev) {
251 		/* First contact, request 100 us latency. */
252 		dev_pm_qos_add_ancestor_request(&ts->client->dev,
253 						&ts->low_latency_req,
254 						DEV_PM_QOS_RESUME_LATENCY, 100);
255 	}
256 
257 out:
258 	return IRQ_HANDLED;
259 }
260 
261 static void st1232_ts_power(struct st1232_ts_data *ts, bool poweron)
262 {
263 	if (ts->reset_gpio)
264 		gpiod_set_value_cansleep(ts->reset_gpio, !poweron);
265 }
266 
267 static void st1232_ts_power_off(void *data)
268 {
269 	st1232_ts_power(data, false);
270 }
271 
272 static const struct st_chip_info st1232_chip_info = {
273 	.have_z		= true,
274 	.max_area	= 0xff,
275 	.max_fingers	= 2,
276 };
277 
278 static const struct st_chip_info st1633_chip_info = {
279 	.have_z		= false,
280 	.max_area	= 0x00,
281 	.max_fingers	= 5,
282 };
283 
284 static int st1232_ts_probe(struct i2c_client *client)
285 {
286 	const struct i2c_device_id *id = i2c_client_get_device_id(client);
287 	const struct st_chip_info *match;
288 	struct st1232_ts_data *ts;
289 	struct input_dev *input_dev;
290 	u16 max_x, max_y;
291 	int error;
292 
293 	match = device_get_match_data(&client->dev);
294 	if (!match && id)
295 		match = (const void *)id->driver_data;
296 	if (!match) {
297 		dev_err(&client->dev, "unknown device model\n");
298 		return -ENODEV;
299 	}
300 
301 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
302 		dev_err(&client->dev, "need I2C_FUNC_I2C\n");
303 		return -EIO;
304 	}
305 
306 	if (!client->irq) {
307 		dev_err(&client->dev, "no IRQ?\n");
308 		return -EINVAL;
309 	}
310 
311 	ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
312 	if (!ts)
313 		return -ENOMEM;
314 
315 	ts->chip_info = match;
316 
317 	/* allocate a buffer according to the number of registers to read */
318 	ts->read_buf_len = ts->chip_info->max_fingers * 4;
319 	ts->read_buf = devm_kzalloc(&client->dev, ts->read_buf_len, GFP_KERNEL);
320 	if (!ts->read_buf)
321 		return -ENOMEM;
322 
323 	input_dev = devm_input_allocate_device(&client->dev);
324 	if (!input_dev)
325 		return -ENOMEM;
326 
327 	ts->client = client;
328 	ts->input_dev = input_dev;
329 
330 	ts->reset_gpio = devm_gpiod_get_optional(&client->dev, NULL,
331 						 GPIOD_OUT_HIGH);
332 	if (IS_ERR(ts->reset_gpio)) {
333 		error = PTR_ERR(ts->reset_gpio);
334 		dev_err(&client->dev, "Unable to request GPIO pin: %d.\n",
335 			error);
336 		return error;
337 	}
338 
339 	st1232_ts_power(ts, true);
340 
341 	error = devm_add_action_or_reset(&client->dev, st1232_ts_power_off, ts);
342 	if (error) {
343 		dev_err(&client->dev,
344 			"Failed to install power off action: %d\n", error);
345 		return error;
346 	}
347 
348 	input_dev->name = "st1232-touchscreen";
349 	input_dev->id.bustype = BUS_I2C;
350 
351 	/* Wait until device is ready */
352 	error = st1232_ts_wait_ready(ts);
353 	if (error)
354 		return error;
355 
356 	/* Read firmware version from the chip */
357 	error = st1232_ts_read_fw_version(ts, &ts->fw_version, &ts->fw_revision);
358 	if (error) {
359 		dev_err(&client->dev,
360 			"Failed to read firmware version: %d\n", error);
361 		return error;
362 	}
363 	dev_dbg(&client->dev, "Detected firmware version %u, rev %08x\n",
364 		ts->fw_version, ts->fw_revision);
365 
366 	if (ts->chip_info->have_z)
367 		input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0,
368 				     ts->chip_info->max_area, 0, 0);
369 
370 	/* map overlay objects if defined in the device tree */
371 	INIT_LIST_HEAD(&ts->touch_overlay_list);
372 	error = touch_overlay_map(&ts->touch_overlay_list, input_dev);
373 	if (error)
374 		return error;
375 
376 	if (touch_overlay_mapped_touchscreen(&ts->touch_overlay_list)) {
377 		/* Read resolution from the overlay touchscreen if defined */
378 		touch_overlay_get_touchscreen_abs(&ts->touch_overlay_list,
379 						  &max_x, &max_y);
380 	} else {
381 		/* Read resolution from the chip */
382 		error = st1232_ts_read_resolution(ts, &max_x, &max_y);
383 		if (error) {
384 			dev_err(&client->dev,
385 				"Failed to read resolution: %d\n", error);
386 			return error;
387 		}
388 	}
389 
390 	input_set_abs_params(input_dev, ABS_MT_POSITION_X,
391 			     0, max_x, 0, 0);
392 	input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
393 			     0, max_y, 0, 0);
394 
395 	touchscreen_parse_properties(input_dev, true, &ts->prop);
396 
397 	error = input_mt_init_slots(input_dev, ts->chip_info->max_fingers,
398 				    INPUT_MT_DIRECT | INPUT_MT_TRACK |
399 					INPUT_MT_DROP_UNUSED);
400 	if (error) {
401 		dev_err(&client->dev, "failed to initialize MT slots\n");
402 		return error;
403 	}
404 
405 	error = devm_request_threaded_irq(&client->dev, client->irq,
406 					  NULL, st1232_ts_irq_handler,
407 					  IRQF_ONESHOT,
408 					  client->name, ts);
409 	if (error) {
410 		dev_err(&client->dev, "Failed to register interrupt\n");
411 		return error;
412 	}
413 
414 	error = input_register_device(ts->input_dev);
415 	if (error) {
416 		dev_err(&client->dev, "Unable to register %s input device\n",
417 			input_dev->name);
418 		return error;
419 	}
420 
421 	i2c_set_clientdata(client, ts);
422 
423 	return 0;
424 }
425 
426 static int st1232_ts_suspend(struct device *dev)
427 {
428 	struct i2c_client *client = to_i2c_client(dev);
429 	struct st1232_ts_data *ts = i2c_get_clientdata(client);
430 
431 	disable_irq(client->irq);
432 
433 	if (!device_may_wakeup(&client->dev))
434 		st1232_ts_power(ts, false);
435 
436 	return 0;
437 }
438 
439 static int st1232_ts_resume(struct device *dev)
440 {
441 	struct i2c_client *client = to_i2c_client(dev);
442 	struct st1232_ts_data *ts = i2c_get_clientdata(client);
443 
444 	if (!device_may_wakeup(&client->dev))
445 		st1232_ts_power(ts, true);
446 
447 	enable_irq(client->irq);
448 
449 	return 0;
450 }
451 
452 static DEFINE_SIMPLE_DEV_PM_OPS(st1232_ts_pm_ops,
453 				st1232_ts_suspend, st1232_ts_resume);
454 
455 static const struct i2c_device_id st1232_ts_id[] = {
456 	{ ST1232_TS_NAME, (unsigned long)&st1232_chip_info },
457 	{ ST1633_TS_NAME, (unsigned long)&st1633_chip_info },
458 	{ }
459 };
460 MODULE_DEVICE_TABLE(i2c, st1232_ts_id);
461 
462 static const struct of_device_id st1232_ts_dt_ids[] = {
463 	{ .compatible = "sitronix,st1232", .data = &st1232_chip_info },
464 	{ .compatible = "sitronix,st1633", .data = &st1633_chip_info },
465 	{ }
466 };
467 MODULE_DEVICE_TABLE(of, st1232_ts_dt_ids);
468 
469 static struct i2c_driver st1232_ts_driver = {
470 	.probe		= st1232_ts_probe,
471 	.id_table	= st1232_ts_id,
472 	.driver = {
473 		.name	= ST1232_TS_NAME,
474 		.of_match_table = st1232_ts_dt_ids,
475 		.dev_groups	= st1232_groups,
476 		.probe_type	= PROBE_PREFER_ASYNCHRONOUS,
477 		.pm	= pm_sleep_ptr(&st1232_ts_pm_ops),
478 	},
479 };
480 
481 module_i2c_driver(st1232_ts_driver);
482 
483 MODULE_AUTHOR("Tony SIM <chinyeow.sim.xt@renesas.com>");
484 MODULE_AUTHOR("Martin Kepplinger <martin.kepplinger@ginzinger.com>");
485 MODULE_DESCRIPTION("SITRONIX ST1232 Touchscreen Controller Driver");
486 MODULE_LICENSE("GPL v2");
487