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(dev: ts->input, key: id); |
75 | if (slot < 0) |
76 | continue; |
77 | |
78 | x = get_unaligned_be16(p: buf); |
79 | y = get_unaligned_be16(p: 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(dev: ts->input, slot); |
86 | input_mt_report_slot_state(dev: ts->input, MT_TOOL_FINGER, active: true); |
87 | touchscreen_report_pos(input: ts->input, prop: &ts->props, x, y, multitouch: true); |
88 | input_report_abs(dev: ts->input, ABS_MT_TOUCH_MAJOR, value: w); |
89 | } |
90 | |
91 | input_mt_sync_frame(dev: ts->input); |
92 | input_sync(dev: 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(adap: ts->client->adapter, msgs: 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, data: 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(client: ts->client, buf: addr, count: 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(client: ts->client, buf, count: 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 | consumers: ts->regulators); |
177 | if (error) { |
178 | dev_err(ts->dev, "failed to enable regulators\n" ); |
179 | return error; |
180 | } |
181 | |
182 | msleep(msecs: 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 | consumers: 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, size: 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(dev: input, EV_ABS, ABS_MT_POSITION_X); |
221 | input_set_capability(dev: input, EV_ABS, ABS_MT_POSITION_Y); |
222 | /* One byte for width 0..255 so this is the limit */ |
223 | input_set_abs_params(dev: input, ABS_MT_TOUCH_MAJOR, min: 0, max: 255, fuzz: 0, flat: 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, multitouch: true, prop: &ts->props); |
238 | input_abs_set_fuzz(dev: input, ABS_MT_POSITION_X, val: 0); |
239 | input_abs_set_fuzz(dev: input, ABS_MT_POSITION_Y, val: 0); |
240 | |
241 | error = input_mt_init_slots(dev: 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(dev: input, data: 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 | consumers: ts->regulators); |
261 | if (error) |
262 | return dev_err_probe(dev, err: error, fmt: "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, irq: client->irq, |
275 | NULL, thread_fn: cy8ctma140_irq_thread, |
276 | IRQF_ONESHOT, CY8CTMA140_NAME, dev_id: 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, data: 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(dev: &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(dev: &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 | |