1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Driver for Cypress CY8CTMA140 (TMA140) touchscreen
4  * (C) 2020 Linus Walleij <linus.walleij@linaro.org>
5  * (C) 2007 Cypress
6  * (C) 2007 Google, Inc.
7  *
8  * Inspired by the tma140_skomer.c driver in the Samsung GT-S7710 code
9  * drop. The GT-S7710 is codenamed "Skomer", the code also indicates
10  * that the same touchscreen was used in a product called "Lucas".
11  *
12  * The code drop for GT-S7710 also contains a firmware downloader and
13  * 15 (!) versions of the firmware drop from Cypress. But here we assume
14  * the firmware got downloaded to the touchscreen flash successfully and
15  * just use it to read the fingers. The shipped vendor driver does the
16  * same.
17  */
18 
19 #include <asm/unaligned.h>
20 #include <linux/module.h>
21 #include <linux/kernel.h>
22 #include <linux/input.h>
23 #include <linux/input/touchscreen.h>
24 #include <linux/input/mt.h>
25 #include <linux/slab.h>
26 #include <linux/interrupt.h>
27 #include <linux/io.h>
28 #include <linux/i2c.h>
29 #include <linux/regulator/consumer.h>
30 #include <linux/delay.h>
31 
32 #define CY8CTMA140_NAME			"cy8ctma140"
33 
34 #define CY8CTMA140_MAX_FINGERS		4
35 
36 #define CY8CTMA140_GET_FINGERS		0x00
37 #define CY8CTMA140_GET_FW_INFO		0x19
38 
39 /* This message also fits some bytes for touchkeys, if used */
40 #define CY8CTMA140_PACKET_SIZE		31
41 
42 #define CY8CTMA140_INVALID_BUFFER_BIT	5
43 
44 struct cy8ctma140 {
45 	struct input_dev *input;
46 	struct touchscreen_properties props;
47 	struct device *dev;
48 	struct i2c_client *client;
49 	struct regulator_bulk_data regulators[2];
50 	u8 prev_fingers;
51 	u8 prev_f1id;
52 	u8 prev_f2id;
53 };
54 
55 static void cy8ctma140_report(struct cy8ctma140 *ts, u8 *data, int n_fingers)
56 {
57 	static const u8 contact_offsets[] = { 0x03, 0x09, 0x10, 0x16 };
58 	u8 *buf;
59 	u16 x, y;
60 	u8 w;
61 	u8 id;
62 	int slot;
63 	int i;
64 
65 	for (i = 0; i < n_fingers; i++) {
66 		buf = &data[contact_offsets[i]];
67 
68 		/*
69 		 * Odd contacts have contact ID in the lower nibble of
70 		 * the preceding byte, whereas even contacts have it in
71 		 * the upper nibble of the following byte.
72 		 */
73 		id = i % 2 ? buf[-1] & 0x0f : buf[5] >> 4;
74 		slot = input_mt_get_slot_by_key(ts->input, id);
75 		if (slot < 0)
76 			continue;
77 
78 		x = get_unaligned_be16(buf);
79 		y = get_unaligned_be16(buf + 2);
80 		w = buf[4];
81 
82 		dev_dbg(ts->dev, "finger %d: ID %02x (%d, %d) w: %d\n",
83 			slot, id, x, y, w);
84 
85 		input_mt_slot(ts->input, slot);
86 		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
87 		touchscreen_report_pos(ts->input, &ts->props, x, y, true);
88 		input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, w);
89 	}
90 
91 	input_mt_sync_frame(ts->input);
92 	input_sync(ts->input);
93 }
94 
95 static irqreturn_t cy8ctma140_irq_thread(int irq, void *d)
96 {
97 	struct cy8ctma140 *ts = d;
98 	u8 cmdbuf[] = { CY8CTMA140_GET_FINGERS };
99 	u8 buf[CY8CTMA140_PACKET_SIZE];
100 	struct i2c_msg msg[] = {
101 		{
102 			.addr = ts->client->addr,
103 			.flags = 0,
104 			.len = sizeof(cmdbuf),
105 			.buf = cmdbuf,
106 		}, {
107 			.addr = ts->client->addr,
108 			.flags = I2C_M_RD,
109 			.len = sizeof(buf),
110 			.buf = buf,
111 		},
112 	};
113 	u8 n_fingers;
114 	int ret;
115 
116 	ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg));
117 	if (ret != ARRAY_SIZE(msg)) {
118 		if (ret < 0)
119 			dev_err(ts->dev, "error reading message: %d\n", ret);
120 		else
121 			dev_err(ts->dev, "wrong number of messages\n");
122 		goto out;
123 	}
124 
125 	if (buf[1] & BIT(CY8CTMA140_INVALID_BUFFER_BIT)) {
126 		dev_dbg(ts->dev, "invalid event\n");
127 		goto out;
128 	}
129 
130 	n_fingers = buf[2] & 0x0f;
131 	if (n_fingers > CY8CTMA140_MAX_FINGERS) {
132 		dev_err(ts->dev, "unexpected number of fingers: %d\n",
133 			n_fingers);
134 		goto out;
135 	}
136 
137 	cy8ctma140_report(ts, buf, n_fingers);
138 
139 out:
140 	return IRQ_HANDLED;
141 }
142 
143 static int cy8ctma140_init(struct cy8ctma140 *ts)
144 {
145 	u8 addr[1];
146 	u8 buf[5];
147 	int ret;
148 
149 	addr[0] = CY8CTMA140_GET_FW_INFO;
150 	ret = i2c_master_send(ts->client, addr, 1);
151 	if (ret < 0) {
152 		dev_err(ts->dev, "error sending FW info message\n");
153 		return ret;
154 	}
155 	ret = i2c_master_recv(ts->client, buf, 5);
156 	if (ret < 0) {
157 		dev_err(ts->dev, "error receiving FW info message\n");
158 		return ret;
159 	}
160 	if (ret != 5) {
161 		dev_err(ts->dev, "got only %d bytes\n", ret);
162 		return -EIO;
163 	}
164 
165 	dev_dbg(ts->dev, "vendor %c%c, HW ID %.2d, FW ver %.4d\n",
166 		buf[0], buf[1], buf[3], buf[4]);
167 
168 	return 0;
169 }
170 
171 static int cy8ctma140_power_up(struct cy8ctma140 *ts)
172 {
173 	int error;
174 
175 	error = regulator_bulk_enable(ARRAY_SIZE(ts->regulators),
176 				      ts->regulators);
177 	if (error) {
178 		dev_err(ts->dev, "failed to enable regulators\n");
179 		return error;
180 	}
181 
182 	msleep(250);
183 
184 	return 0;
185 }
186 
187 static void cy8ctma140_power_down(struct cy8ctma140 *ts)
188 {
189 	regulator_bulk_disable(ARRAY_SIZE(ts->regulators),
190 			       ts->regulators);
191 }
192 
193 /* Called from the registered devm action */
194 static void cy8ctma140_power_off_action(void *d)
195 {
196 	struct cy8ctma140 *ts = d;
197 
198 	cy8ctma140_power_down(ts);
199 }
200 
201 static int cy8ctma140_probe(struct i2c_client *client)
202 {
203 	struct cy8ctma140 *ts;
204 	struct input_dev *input;
205 	struct device *dev = &client->dev;
206 	int error;
207 
208 	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
209 	if (!ts)
210 		return -ENOMEM;
211 
212 	input = devm_input_allocate_device(dev);
213 	if (!input)
214 		return -ENOMEM;
215 
216 	ts->dev = dev;
217 	ts->client = client;
218 	ts->input = input;
219 
220 	input_set_capability(input, EV_ABS, ABS_MT_POSITION_X);
221 	input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y);
222 	/* One byte for width 0..255 so this is the limit */
223 	input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
224 	/*
225 	 * This sets up event max/min capabilities and fuzz.
226 	 * Some DT properties are compulsory so we do not need
227 	 * to provide defaults for X/Y max or pressure max.
228 	 *
229 	 * We just initialize a very simple MT touchscreen here,
230 	 * some devices use the capability of this touchscreen to
231 	 * provide touchkeys, and in that case this needs to be
232 	 * extended to handle touchkey input.
233 	 *
234 	 * The firmware takes care of finger tracking and dropping
235 	 * invalid ranges.
236 	 */
237 	touchscreen_parse_properties(input, true, &ts->props);
238 	input_abs_set_fuzz(input, ABS_MT_POSITION_X, 0);
239 	input_abs_set_fuzz(input, ABS_MT_POSITION_Y, 0);
240 
241 	error = input_mt_init_slots(input, CY8CTMA140_MAX_FINGERS,
242 				  INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
243 	if (error)
244 		return error;
245 
246 	input->name = CY8CTMA140_NAME;
247 	input->id.bustype = BUS_I2C;
248 	input_set_drvdata(input, ts);
249 
250 	/*
251 	 * VCPIN is the analog voltage supply
252 	 * VDD is the digital voltage supply
253 	 * since the voltage range of VDD overlaps that of VCPIN,
254 	 * many designs to just supply both with a single voltage
255 	 * source of ~3.3 V.
256 	 */
257 	ts->regulators[0].supply = "vcpin";
258 	ts->regulators[1].supply = "vdd";
259 	error = devm_regulator_bulk_get(dev, ARRAY_SIZE(ts->regulators),
260 				      ts->regulators);
261 	if (error)
262 		return dev_err_probe(dev, error, "Failed to get regulators\n");
263 
264 	error = cy8ctma140_power_up(ts);
265 	if (error)
266 		return error;
267 
268 	error = devm_add_action_or_reset(dev, cy8ctma140_power_off_action, ts);
269 	if (error) {
270 		dev_err(dev, "failed to install power off handler\n");
271 		return error;
272 	}
273 
274 	error = devm_request_threaded_irq(dev, client->irq,
275 					  NULL, cy8ctma140_irq_thread,
276 					  IRQF_ONESHOT, CY8CTMA140_NAME, ts);
277 	if (error) {
278 		dev_err(dev, "irq %d busy? error %d\n", client->irq, error);
279 		return error;
280 	}
281 
282 	error = cy8ctma140_init(ts);
283 	if (error)
284 		return error;
285 
286 	error = input_register_device(input);
287 	if (error)
288 		return error;
289 
290 	i2c_set_clientdata(client, ts);
291 
292 	return 0;
293 }
294 
295 static int cy8ctma140_suspend(struct device *dev)
296 {
297 	struct i2c_client *client = to_i2c_client(dev);
298 	struct cy8ctma140 *ts = i2c_get_clientdata(client);
299 
300 	if (!device_may_wakeup(&client->dev))
301 		cy8ctma140_power_down(ts);
302 
303 	return 0;
304 }
305 
306 static int cy8ctma140_resume(struct device *dev)
307 {
308 	struct i2c_client *client = to_i2c_client(dev);
309 	struct cy8ctma140 *ts = i2c_get_clientdata(client);
310 	int error;
311 
312 	if (!device_may_wakeup(&client->dev)) {
313 		error = cy8ctma140_power_up(ts);
314 		if (error)
315 			return error;
316 	}
317 
318 	return 0;
319 }
320 
321 static DEFINE_SIMPLE_DEV_PM_OPS(cy8ctma140_pm,
322 				cy8ctma140_suspend, cy8ctma140_resume);
323 
324 static const struct i2c_device_id cy8ctma140_idtable[] = {
325 	{ CY8CTMA140_NAME, 0 },
326 	{ /* sentinel */ }
327 };
328 MODULE_DEVICE_TABLE(i2c, cy8ctma140_idtable);
329 
330 static const struct of_device_id cy8ctma140_of_match[] = {
331 	{ .compatible = "cypress,cy8ctma140", },
332 	{ /* sentinel */ }
333 };
334 MODULE_DEVICE_TABLE(of, cy8ctma140_of_match);
335 
336 static struct i2c_driver cy8ctma140_driver = {
337 	.driver		= {
338 		.name	= CY8CTMA140_NAME,
339 		.pm	= pm_sleep_ptr(&cy8ctma140_pm),
340 		.of_match_table = cy8ctma140_of_match,
341 	},
342 	.id_table	= cy8ctma140_idtable,
343 	.probe		= cy8ctma140_probe,
344 };
345 module_i2c_driver(cy8ctma140_driver);
346 
347 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
348 MODULE_DESCRIPTION("CY8CTMA140 TouchScreen Driver");
349 MODULE_LICENSE("GPL v2");
350