1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) 2012-2013 MundoReader S.L. |
4 | * Author: Heiko Stuebner <heiko@sntech.de> |
5 | * |
6 | * based in parts on Nook zforce driver |
7 | * |
8 | * Copyright (C) 2010 Barnes & Noble, Inc. |
9 | * Author: Pieter Truter<ptruter@intrinsyc.com> |
10 | */ |
11 | |
12 | #include <linux/module.h> |
13 | #include <linux/hrtimer.h> |
14 | #include <linux/slab.h> |
15 | #include <linux/input.h> |
16 | #include <linux/interrupt.h> |
17 | #include <linux/i2c.h> |
18 | #include <linux/delay.h> |
19 | #include <linux/gpio/consumer.h> |
20 | #include <linux/device.h> |
21 | #include <linux/sysfs.h> |
22 | #include <linux/input/mt.h> |
23 | #include <linux/input/touchscreen.h> |
24 | #include <linux/platform_data/zforce_ts.h> |
25 | #include <linux/regulator/consumer.h> |
26 | #include <linux/of.h> |
27 | |
28 | #define WAIT_TIMEOUT msecs_to_jiffies(1000) |
29 | |
30 | #define FRAME_START 0xee |
31 | #define FRAME_MAXSIZE 257 |
32 | |
33 | /* Offsets of the different parts of the payload the controller sends */ |
34 | #define 0 |
35 | #define PAYLOAD_LENGTH 1 |
36 | #define PAYLOAD_BODY 2 |
37 | |
38 | /* Response offsets */ |
39 | #define RESPONSE_ID 0 |
40 | #define RESPONSE_DATA 1 |
41 | |
42 | /* Commands */ |
43 | #define COMMAND_DEACTIVATE 0x00 |
44 | #define COMMAND_INITIALIZE 0x01 |
45 | #define COMMAND_RESOLUTION 0x02 |
46 | #define COMMAND_SETCONFIG 0x03 |
47 | #define COMMAND_DATAREQUEST 0x04 |
48 | #define COMMAND_SCANFREQ 0x08 |
49 | #define COMMAND_STATUS 0X1e |
50 | |
51 | /* |
52 | * Responses the controller sends as a result of |
53 | * command requests |
54 | */ |
55 | #define RESPONSE_DEACTIVATE 0x00 |
56 | #define RESPONSE_INITIALIZE 0x01 |
57 | #define RESPONSE_RESOLUTION 0x02 |
58 | #define RESPONSE_SETCONFIG 0x03 |
59 | #define RESPONSE_SCANFREQ 0x08 |
60 | #define RESPONSE_STATUS 0X1e |
61 | |
62 | /* |
63 | * Notifications are sent by the touch controller without |
64 | * being requested by the driver and include for example |
65 | * touch indications |
66 | */ |
67 | #define NOTIFICATION_TOUCH 0x04 |
68 | #define NOTIFICATION_BOOTCOMPLETE 0x07 |
69 | #define NOTIFICATION_OVERRUN 0x25 |
70 | #define NOTIFICATION_PROXIMITY 0x26 |
71 | #define NOTIFICATION_INVALID_COMMAND 0xfe |
72 | |
73 | #define ZFORCE_REPORT_POINTS 2 |
74 | #define ZFORCE_MAX_AREA 0xff |
75 | |
76 | #define STATE_DOWN 0 |
77 | #define STATE_MOVE 1 |
78 | #define STATE_UP 2 |
79 | |
80 | #define SETCONFIG_DUALTOUCH (1 << 0) |
81 | |
82 | struct zforce_point { |
83 | int coord_x; |
84 | int coord_y; |
85 | int state; |
86 | int id; |
87 | int area_major; |
88 | int area_minor; |
89 | int orientation; |
90 | int pressure; |
91 | int prblty; |
92 | }; |
93 | |
94 | /* |
95 | * @client the i2c_client |
96 | * @input the input device |
97 | * @suspending in the process of going to suspend (don't emit wakeup |
98 | * events for commands executed to suspend the device) |
99 | * @suspended device suspended |
100 | * @access_mutex serialize i2c-access, to keep multipart reads together |
101 | * @command_done completion to wait for the command result |
102 | * @command_mutex serialize commands sent to the ic |
103 | * @command_waiting the id of the command that is currently waiting |
104 | * for a result |
105 | * @command_result returned result of the command |
106 | */ |
107 | struct zforce_ts { |
108 | struct i2c_client *client; |
109 | struct input_dev *input; |
110 | struct touchscreen_properties prop; |
111 | const struct zforce_ts_platdata *pdata; |
112 | char phys[32]; |
113 | |
114 | struct regulator *reg_vdd; |
115 | |
116 | struct gpio_desc *gpio_int; |
117 | struct gpio_desc *gpio_rst; |
118 | |
119 | bool suspending; |
120 | bool suspended; |
121 | bool boot_complete; |
122 | |
123 | /* Firmware version information */ |
124 | u16 version_major; |
125 | u16 version_minor; |
126 | u16 version_build; |
127 | u16 version_rev; |
128 | |
129 | struct mutex access_mutex; |
130 | |
131 | struct completion command_done; |
132 | struct mutex command_mutex; |
133 | int command_waiting; |
134 | int command_result; |
135 | }; |
136 | |
137 | static int zforce_command(struct zforce_ts *ts, u8 cmd) |
138 | { |
139 | struct i2c_client *client = ts->client; |
140 | char buf[3]; |
141 | int ret; |
142 | |
143 | dev_dbg(&client->dev, "%s: 0x%x\n" , __func__, cmd); |
144 | |
145 | buf[0] = FRAME_START; |
146 | buf[1] = 1; /* data size, command only */ |
147 | buf[2] = cmd; |
148 | |
149 | mutex_lock(&ts->access_mutex); |
150 | ret = i2c_master_send(client, buf: &buf[0], ARRAY_SIZE(buf)); |
151 | mutex_unlock(lock: &ts->access_mutex); |
152 | if (ret < 0) { |
153 | dev_err(&client->dev, "i2c send data request error: %d\n" , ret); |
154 | return ret; |
155 | } |
156 | |
157 | return 0; |
158 | } |
159 | |
160 | static void zforce_reset_assert(struct zforce_ts *ts) |
161 | { |
162 | gpiod_set_value_cansleep(desc: ts->gpio_rst, value: 1); |
163 | } |
164 | |
165 | static void zforce_reset_deassert(struct zforce_ts *ts) |
166 | { |
167 | gpiod_set_value_cansleep(desc: ts->gpio_rst, value: 0); |
168 | } |
169 | |
170 | static int zforce_send_wait(struct zforce_ts *ts, const char *buf, int len) |
171 | { |
172 | struct i2c_client *client = ts->client; |
173 | int ret; |
174 | |
175 | ret = mutex_trylock(lock: &ts->command_mutex); |
176 | if (!ret) { |
177 | dev_err(&client->dev, "already waiting for a command\n" ); |
178 | return -EBUSY; |
179 | } |
180 | |
181 | dev_dbg(&client->dev, "sending %d bytes for command 0x%x\n" , |
182 | buf[1], buf[2]); |
183 | |
184 | ts->command_waiting = buf[2]; |
185 | |
186 | mutex_lock(&ts->access_mutex); |
187 | ret = i2c_master_send(client, buf, count: len); |
188 | mutex_unlock(lock: &ts->access_mutex); |
189 | if (ret < 0) { |
190 | dev_err(&client->dev, "i2c send data request error: %d\n" , ret); |
191 | goto unlock; |
192 | } |
193 | |
194 | dev_dbg(&client->dev, "waiting for result for command 0x%x\n" , buf[2]); |
195 | |
196 | if (wait_for_completion_timeout(x: &ts->command_done, WAIT_TIMEOUT) == 0) { |
197 | ret = -ETIME; |
198 | goto unlock; |
199 | } |
200 | |
201 | ret = ts->command_result; |
202 | |
203 | unlock: |
204 | mutex_unlock(lock: &ts->command_mutex); |
205 | return ret; |
206 | } |
207 | |
208 | static int zforce_command_wait(struct zforce_ts *ts, u8 cmd) |
209 | { |
210 | struct i2c_client *client = ts->client; |
211 | char buf[3]; |
212 | int ret; |
213 | |
214 | dev_dbg(&client->dev, "%s: 0x%x\n" , __func__, cmd); |
215 | |
216 | buf[0] = FRAME_START; |
217 | buf[1] = 1; /* data size, command only */ |
218 | buf[2] = cmd; |
219 | |
220 | ret = zforce_send_wait(ts, buf: &buf[0], ARRAY_SIZE(buf)); |
221 | if (ret < 0) { |
222 | dev_err(&client->dev, "i2c send data request error: %d\n" , ret); |
223 | return ret; |
224 | } |
225 | |
226 | return 0; |
227 | } |
228 | |
229 | static int zforce_resolution(struct zforce_ts *ts, u16 x, u16 y) |
230 | { |
231 | struct i2c_client *client = ts->client; |
232 | char buf[7] = { FRAME_START, 5, COMMAND_RESOLUTION, |
233 | (x & 0xff), ((x >> 8) & 0xff), |
234 | (y & 0xff), ((y >> 8) & 0xff) }; |
235 | |
236 | dev_dbg(&client->dev, "set resolution to (%d,%d)\n" , x, y); |
237 | |
238 | return zforce_send_wait(ts, buf: &buf[0], ARRAY_SIZE(buf)); |
239 | } |
240 | |
241 | static int zforce_scan_frequency(struct zforce_ts *ts, u16 idle, u16 finger, |
242 | u16 stylus) |
243 | { |
244 | struct i2c_client *client = ts->client; |
245 | char buf[9] = { FRAME_START, 7, COMMAND_SCANFREQ, |
246 | (idle & 0xff), ((idle >> 8) & 0xff), |
247 | (finger & 0xff), ((finger >> 8) & 0xff), |
248 | (stylus & 0xff), ((stylus >> 8) & 0xff) }; |
249 | |
250 | dev_dbg(&client->dev, |
251 | "set scan frequency to (idle: %d, finger: %d, stylus: %d)\n" , |
252 | idle, finger, stylus); |
253 | |
254 | return zforce_send_wait(ts, buf: &buf[0], ARRAY_SIZE(buf)); |
255 | } |
256 | |
257 | static int zforce_setconfig(struct zforce_ts *ts, char b1) |
258 | { |
259 | struct i2c_client *client = ts->client; |
260 | char buf[7] = { FRAME_START, 5, COMMAND_SETCONFIG, |
261 | b1, 0, 0, 0 }; |
262 | |
263 | dev_dbg(&client->dev, "set config to (%d)\n" , b1); |
264 | |
265 | return zforce_send_wait(ts, buf: &buf[0], ARRAY_SIZE(buf)); |
266 | } |
267 | |
268 | static int zforce_start(struct zforce_ts *ts) |
269 | { |
270 | struct i2c_client *client = ts->client; |
271 | int ret; |
272 | |
273 | dev_dbg(&client->dev, "starting device\n" ); |
274 | |
275 | ret = zforce_command_wait(ts, COMMAND_INITIALIZE); |
276 | if (ret) { |
277 | dev_err(&client->dev, "Unable to initialize, %d\n" , ret); |
278 | return ret; |
279 | } |
280 | |
281 | ret = zforce_resolution(ts, x: ts->prop.max_x, y: ts->prop.max_y); |
282 | if (ret) { |
283 | dev_err(&client->dev, "Unable to set resolution, %d\n" , ret); |
284 | goto error; |
285 | } |
286 | |
287 | ret = zforce_scan_frequency(ts, idle: 10, finger: 50, stylus: 50); |
288 | if (ret) { |
289 | dev_err(&client->dev, "Unable to set scan frequency, %d\n" , |
290 | ret); |
291 | goto error; |
292 | } |
293 | |
294 | ret = zforce_setconfig(ts, SETCONFIG_DUALTOUCH); |
295 | if (ret) { |
296 | dev_err(&client->dev, "Unable to set config\n" ); |
297 | goto error; |
298 | } |
299 | |
300 | /* start sending touch events */ |
301 | ret = zforce_command(ts, COMMAND_DATAREQUEST); |
302 | if (ret) { |
303 | dev_err(&client->dev, "Unable to request data\n" ); |
304 | goto error; |
305 | } |
306 | |
307 | /* |
308 | * Per NN, initial cal. take max. of 200msec. |
309 | * Allow time to complete this calibration |
310 | */ |
311 | msleep(msecs: 200); |
312 | |
313 | return 0; |
314 | |
315 | error: |
316 | zforce_command_wait(ts, COMMAND_DEACTIVATE); |
317 | return ret; |
318 | } |
319 | |
320 | static int zforce_stop(struct zforce_ts *ts) |
321 | { |
322 | struct i2c_client *client = ts->client; |
323 | int ret; |
324 | |
325 | dev_dbg(&client->dev, "stopping device\n" ); |
326 | |
327 | /* Deactivates touch sensing and puts the device into sleep. */ |
328 | ret = zforce_command_wait(ts, COMMAND_DEACTIVATE); |
329 | if (ret != 0) { |
330 | dev_err(&client->dev, "could not deactivate device, %d\n" , |
331 | ret); |
332 | return ret; |
333 | } |
334 | |
335 | return 0; |
336 | } |
337 | |
338 | static int zforce_touch_event(struct zforce_ts *ts, u8 *payload) |
339 | { |
340 | struct i2c_client *client = ts->client; |
341 | struct zforce_point point; |
342 | int count, i, num = 0; |
343 | |
344 | count = payload[0]; |
345 | if (count > ZFORCE_REPORT_POINTS) { |
346 | dev_warn(&client->dev, |
347 | "too many coordinates %d, expected max %d\n" , |
348 | count, ZFORCE_REPORT_POINTS); |
349 | count = ZFORCE_REPORT_POINTS; |
350 | } |
351 | |
352 | for (i = 0; i < count; i++) { |
353 | point.coord_x = |
354 | payload[9 * i + 2] << 8 | payload[9 * i + 1]; |
355 | point.coord_y = |
356 | payload[9 * i + 4] << 8 | payload[9 * i + 3]; |
357 | |
358 | if (point.coord_x > ts->prop.max_x || |
359 | point.coord_y > ts->prop.max_y) { |
360 | dev_warn(&client->dev, "coordinates (%d,%d) invalid\n" , |
361 | point.coord_x, point.coord_y); |
362 | point.coord_x = point.coord_y = 0; |
363 | } |
364 | |
365 | point.state = payload[9 * i + 5] & 0x0f; |
366 | point.id = (payload[9 * i + 5] & 0xf0) >> 4; |
367 | |
368 | /* determine touch major, minor and orientation */ |
369 | point.area_major = max(payload[9 * i + 6], |
370 | payload[9 * i + 7]); |
371 | point.area_minor = min(payload[9 * i + 6], |
372 | payload[9 * i + 7]); |
373 | point.orientation = payload[9 * i + 6] > payload[9 * i + 7]; |
374 | |
375 | point.pressure = payload[9 * i + 8]; |
376 | point.prblty = payload[9 * i + 9]; |
377 | |
378 | dev_dbg(&client->dev, |
379 | "point %d/%d: state %d, id %d, pressure %d, prblty %d, x %d, y %d, amajor %d, aminor %d, ori %d\n" , |
380 | i, count, point.state, point.id, |
381 | point.pressure, point.prblty, |
382 | point.coord_x, point.coord_y, |
383 | point.area_major, point.area_minor, |
384 | point.orientation); |
385 | |
386 | /* the zforce id starts with "1", so needs to be decreased */ |
387 | input_mt_slot(dev: ts->input, slot: point.id - 1); |
388 | |
389 | input_mt_report_slot_state(dev: ts->input, MT_TOOL_FINGER, |
390 | active: point.state != STATE_UP); |
391 | |
392 | if (point.state != STATE_UP) { |
393 | touchscreen_report_pos(input: ts->input, prop: &ts->prop, |
394 | x: point.coord_x, y: point.coord_y, |
395 | multitouch: true); |
396 | input_report_abs(dev: ts->input, ABS_MT_TOUCH_MAJOR, |
397 | value: point.area_major); |
398 | input_report_abs(dev: ts->input, ABS_MT_TOUCH_MINOR, |
399 | value: point.area_minor); |
400 | input_report_abs(dev: ts->input, ABS_MT_ORIENTATION, |
401 | value: point.orientation); |
402 | num++; |
403 | } |
404 | } |
405 | |
406 | input_mt_sync_frame(dev: ts->input); |
407 | |
408 | input_mt_report_finger_count(dev: ts->input, count: num); |
409 | |
410 | input_sync(dev: ts->input); |
411 | |
412 | return 0; |
413 | } |
414 | |
415 | static int zforce_read_packet(struct zforce_ts *ts, u8 *buf) |
416 | { |
417 | struct i2c_client *client = ts->client; |
418 | int ret; |
419 | |
420 | mutex_lock(&ts->access_mutex); |
421 | |
422 | /* read 2 byte message header */ |
423 | ret = i2c_master_recv(client, buf, count: 2); |
424 | if (ret < 0) { |
425 | dev_err(&client->dev, "error reading header: %d\n" , ret); |
426 | goto unlock; |
427 | } |
428 | |
429 | if (buf[PAYLOAD_HEADER] != FRAME_START) { |
430 | dev_err(&client->dev, "invalid frame start: %d\n" , buf[0]); |
431 | ret = -EIO; |
432 | goto unlock; |
433 | } |
434 | |
435 | if (buf[PAYLOAD_LENGTH] == 0) { |
436 | dev_err(&client->dev, "invalid payload length: %d\n" , |
437 | buf[PAYLOAD_LENGTH]); |
438 | ret = -EIO; |
439 | goto unlock; |
440 | } |
441 | |
442 | /* read the message */ |
443 | ret = i2c_master_recv(client, buf: &buf[PAYLOAD_BODY], count: buf[PAYLOAD_LENGTH]); |
444 | if (ret < 0) { |
445 | dev_err(&client->dev, "error reading payload: %d\n" , ret); |
446 | goto unlock; |
447 | } |
448 | |
449 | dev_dbg(&client->dev, "read %d bytes for response command 0x%x\n" , |
450 | buf[PAYLOAD_LENGTH], buf[PAYLOAD_BODY]); |
451 | |
452 | unlock: |
453 | mutex_unlock(lock: &ts->access_mutex); |
454 | return ret; |
455 | } |
456 | |
457 | static void zforce_complete(struct zforce_ts *ts, int cmd, int result) |
458 | { |
459 | struct i2c_client *client = ts->client; |
460 | |
461 | if (ts->command_waiting == cmd) { |
462 | dev_dbg(&client->dev, "completing command 0x%x\n" , cmd); |
463 | ts->command_result = result; |
464 | complete(&ts->command_done); |
465 | } else { |
466 | dev_dbg(&client->dev, "command %d not for us\n" , cmd); |
467 | } |
468 | } |
469 | |
470 | static irqreturn_t zforce_irq(int irq, void *dev_id) |
471 | { |
472 | struct zforce_ts *ts = dev_id; |
473 | struct i2c_client *client = ts->client; |
474 | |
475 | if (ts->suspended && device_may_wakeup(dev: &client->dev)) |
476 | pm_wakeup_event(dev: &client->dev, msec: 500); |
477 | |
478 | return IRQ_WAKE_THREAD; |
479 | } |
480 | |
481 | static irqreturn_t zforce_irq_thread(int irq, void *dev_id) |
482 | { |
483 | struct zforce_ts *ts = dev_id; |
484 | struct i2c_client *client = ts->client; |
485 | int ret; |
486 | u8 payload_buffer[FRAME_MAXSIZE]; |
487 | u8 *payload; |
488 | |
489 | /* |
490 | * When still suspended, return. |
491 | * Due to the level-interrupt we will get re-triggered later. |
492 | */ |
493 | if (ts->suspended) { |
494 | msleep(msecs: 20); |
495 | return IRQ_HANDLED; |
496 | } |
497 | |
498 | dev_dbg(&client->dev, "handling interrupt\n" ); |
499 | |
500 | /* Don't emit wakeup events from commands run by zforce_suspend */ |
501 | if (!ts->suspending && device_may_wakeup(dev: &client->dev)) |
502 | pm_stay_awake(dev: &client->dev); |
503 | |
504 | /* |
505 | * Run at least once and exit the loop if |
506 | * - the optional interrupt GPIO isn't specified |
507 | * (there is only one packet read per ISR invocation, then) |
508 | * or |
509 | * - the GPIO isn't active any more |
510 | * (packet read until the level GPIO indicates that there is |
511 | * no IRQ any more) |
512 | */ |
513 | do { |
514 | ret = zforce_read_packet(ts, buf: payload_buffer); |
515 | if (ret < 0) { |
516 | dev_err(&client->dev, |
517 | "could not read packet, ret: %d\n" , ret); |
518 | break; |
519 | } |
520 | |
521 | payload = &payload_buffer[PAYLOAD_BODY]; |
522 | |
523 | switch (payload[RESPONSE_ID]) { |
524 | case NOTIFICATION_TOUCH: |
525 | /* |
526 | * Always report touch-events received while |
527 | * suspending, when being a wakeup source |
528 | */ |
529 | if (ts->suspending && device_may_wakeup(dev: &client->dev)) |
530 | pm_wakeup_event(dev: &client->dev, msec: 500); |
531 | zforce_touch_event(ts, payload: &payload[RESPONSE_DATA]); |
532 | break; |
533 | |
534 | case NOTIFICATION_BOOTCOMPLETE: |
535 | ts->boot_complete = payload[RESPONSE_DATA]; |
536 | zforce_complete(ts, cmd: payload[RESPONSE_ID], result: 0); |
537 | break; |
538 | |
539 | case RESPONSE_INITIALIZE: |
540 | case RESPONSE_DEACTIVATE: |
541 | case RESPONSE_SETCONFIG: |
542 | case RESPONSE_RESOLUTION: |
543 | case RESPONSE_SCANFREQ: |
544 | zforce_complete(ts, cmd: payload[RESPONSE_ID], |
545 | result: payload[RESPONSE_DATA]); |
546 | break; |
547 | |
548 | case RESPONSE_STATUS: |
549 | /* |
550 | * Version Payload Results |
551 | * [2:major] [2:minor] [2:build] [2:rev] |
552 | */ |
553 | ts->version_major = (payload[RESPONSE_DATA + 1] << 8) | |
554 | payload[RESPONSE_DATA]; |
555 | ts->version_minor = (payload[RESPONSE_DATA + 3] << 8) | |
556 | payload[RESPONSE_DATA + 2]; |
557 | ts->version_build = (payload[RESPONSE_DATA + 5] << 8) | |
558 | payload[RESPONSE_DATA + 4]; |
559 | ts->version_rev = (payload[RESPONSE_DATA + 7] << 8) | |
560 | payload[RESPONSE_DATA + 6]; |
561 | dev_dbg(&ts->client->dev, |
562 | "Firmware Version %04x:%04x %04x:%04x\n" , |
563 | ts->version_major, ts->version_minor, |
564 | ts->version_build, ts->version_rev); |
565 | |
566 | zforce_complete(ts, cmd: payload[RESPONSE_ID], result: 0); |
567 | break; |
568 | |
569 | case NOTIFICATION_INVALID_COMMAND: |
570 | dev_err(&ts->client->dev, "invalid command: 0x%x\n" , |
571 | payload[RESPONSE_DATA]); |
572 | break; |
573 | |
574 | default: |
575 | dev_err(&ts->client->dev, |
576 | "unrecognized response id: 0x%x\n" , |
577 | payload[RESPONSE_ID]); |
578 | break; |
579 | } |
580 | } while (gpiod_get_value_cansleep(desc: ts->gpio_int)); |
581 | |
582 | if (!ts->suspending && device_may_wakeup(dev: &client->dev)) |
583 | pm_relax(dev: &client->dev); |
584 | |
585 | dev_dbg(&client->dev, "finished interrupt\n" ); |
586 | |
587 | return IRQ_HANDLED; |
588 | } |
589 | |
590 | static int zforce_input_open(struct input_dev *dev) |
591 | { |
592 | struct zforce_ts *ts = input_get_drvdata(dev); |
593 | |
594 | return zforce_start(ts); |
595 | } |
596 | |
597 | static void zforce_input_close(struct input_dev *dev) |
598 | { |
599 | struct zforce_ts *ts = input_get_drvdata(dev); |
600 | struct i2c_client *client = ts->client; |
601 | int ret; |
602 | |
603 | ret = zforce_stop(ts); |
604 | if (ret) |
605 | dev_warn(&client->dev, "stopping zforce failed\n" ); |
606 | |
607 | return; |
608 | } |
609 | |
610 | static int zforce_suspend(struct device *dev) |
611 | { |
612 | struct i2c_client *client = to_i2c_client(dev); |
613 | struct zforce_ts *ts = i2c_get_clientdata(client); |
614 | struct input_dev *input = ts->input; |
615 | int ret = 0; |
616 | |
617 | mutex_lock(&input->mutex); |
618 | ts->suspending = true; |
619 | |
620 | /* |
621 | * When configured as a wakeup source device should always wake |
622 | * the system, therefore start device if necessary. |
623 | */ |
624 | if (device_may_wakeup(dev: &client->dev)) { |
625 | dev_dbg(&client->dev, "suspend while being a wakeup source\n" ); |
626 | |
627 | /* Need to start device, if not open, to be a wakeup source. */ |
628 | if (!input_device_enabled(dev: input)) { |
629 | ret = zforce_start(ts); |
630 | if (ret) |
631 | goto unlock; |
632 | } |
633 | |
634 | enable_irq_wake(irq: client->irq); |
635 | } else if (input_device_enabled(dev: input)) { |
636 | dev_dbg(&client->dev, |
637 | "suspend without being a wakeup source\n" ); |
638 | |
639 | ret = zforce_stop(ts); |
640 | if (ret) |
641 | goto unlock; |
642 | |
643 | disable_irq(irq: client->irq); |
644 | } |
645 | |
646 | ts->suspended = true; |
647 | |
648 | unlock: |
649 | ts->suspending = false; |
650 | mutex_unlock(lock: &input->mutex); |
651 | |
652 | return ret; |
653 | } |
654 | |
655 | static int zforce_resume(struct device *dev) |
656 | { |
657 | struct i2c_client *client = to_i2c_client(dev); |
658 | struct zforce_ts *ts = i2c_get_clientdata(client); |
659 | struct input_dev *input = ts->input; |
660 | int ret = 0; |
661 | |
662 | mutex_lock(&input->mutex); |
663 | |
664 | ts->suspended = false; |
665 | |
666 | if (device_may_wakeup(dev: &client->dev)) { |
667 | dev_dbg(&client->dev, "resume from being a wakeup source\n" ); |
668 | |
669 | disable_irq_wake(irq: client->irq); |
670 | |
671 | /* need to stop device if it was not open on suspend */ |
672 | if (!input_device_enabled(dev: input)) { |
673 | ret = zforce_stop(ts); |
674 | if (ret) |
675 | goto unlock; |
676 | } |
677 | } else if (input_device_enabled(dev: input)) { |
678 | dev_dbg(&client->dev, "resume without being a wakeup source\n" ); |
679 | |
680 | enable_irq(irq: client->irq); |
681 | |
682 | ret = zforce_start(ts); |
683 | if (ret < 0) |
684 | goto unlock; |
685 | } |
686 | |
687 | unlock: |
688 | mutex_unlock(lock: &input->mutex); |
689 | |
690 | return ret; |
691 | } |
692 | |
693 | static DEFINE_SIMPLE_DEV_PM_OPS(zforce_pm_ops, zforce_suspend, zforce_resume); |
694 | |
695 | static void zforce_reset(void *data) |
696 | { |
697 | struct zforce_ts *ts = data; |
698 | |
699 | zforce_reset_assert(ts); |
700 | |
701 | udelay(10); |
702 | |
703 | if (!IS_ERR(ptr: ts->reg_vdd)) |
704 | regulator_disable(regulator: ts->reg_vdd); |
705 | } |
706 | |
707 | static struct zforce_ts_platdata *zforce_parse_dt(struct device *dev) |
708 | { |
709 | struct zforce_ts_platdata *pdata; |
710 | struct device_node *np = dev->of_node; |
711 | |
712 | if (!np) |
713 | return ERR_PTR(error: -ENOENT); |
714 | |
715 | pdata = devm_kzalloc(dev, size: sizeof(*pdata), GFP_KERNEL); |
716 | if (!pdata) { |
717 | dev_err(dev, "failed to allocate platform data\n" ); |
718 | return ERR_PTR(error: -ENOMEM); |
719 | } |
720 | |
721 | of_property_read_u32(np, propname: "x-size" , out_value: &pdata->x_max); |
722 | of_property_read_u32(np, propname: "y-size" , out_value: &pdata->y_max); |
723 | |
724 | return pdata; |
725 | } |
726 | |
727 | static int zforce_probe(struct i2c_client *client) |
728 | { |
729 | const struct zforce_ts_platdata *pdata = dev_get_platdata(dev: &client->dev); |
730 | struct zforce_ts *ts; |
731 | struct input_dev *input_dev; |
732 | int ret; |
733 | |
734 | if (!pdata) { |
735 | pdata = zforce_parse_dt(dev: &client->dev); |
736 | if (IS_ERR(ptr: pdata)) |
737 | return PTR_ERR(ptr: pdata); |
738 | } |
739 | |
740 | ts = devm_kzalloc(dev: &client->dev, size: sizeof(struct zforce_ts), GFP_KERNEL); |
741 | if (!ts) |
742 | return -ENOMEM; |
743 | |
744 | ts->gpio_rst = devm_gpiod_get_optional(dev: &client->dev, con_id: "reset" , |
745 | flags: GPIOD_OUT_HIGH); |
746 | if (IS_ERR(ptr: ts->gpio_rst)) { |
747 | ret = PTR_ERR(ptr: ts->gpio_rst); |
748 | dev_err(&client->dev, |
749 | "failed to request reset GPIO: %d\n" , ret); |
750 | return ret; |
751 | } |
752 | |
753 | if (ts->gpio_rst) { |
754 | ts->gpio_int = devm_gpiod_get_optional(dev: &client->dev, con_id: "irq" , |
755 | flags: GPIOD_IN); |
756 | if (IS_ERR(ptr: ts->gpio_int)) { |
757 | ret = PTR_ERR(ptr: ts->gpio_int); |
758 | dev_err(&client->dev, |
759 | "failed to request interrupt GPIO: %d\n" , ret); |
760 | return ret; |
761 | } |
762 | } else { |
763 | /* |
764 | * Deprecated GPIO handling for compatibility |
765 | * with legacy binding. |
766 | */ |
767 | |
768 | /* INT GPIO */ |
769 | ts->gpio_int = devm_gpiod_get_index(dev: &client->dev, NULL, idx: 0, |
770 | flags: GPIOD_IN); |
771 | if (IS_ERR(ptr: ts->gpio_int)) { |
772 | ret = PTR_ERR(ptr: ts->gpio_int); |
773 | dev_err(&client->dev, |
774 | "failed to request interrupt GPIO: %d\n" , ret); |
775 | return ret; |
776 | } |
777 | |
778 | /* RST GPIO */ |
779 | ts->gpio_rst = devm_gpiod_get_index(dev: &client->dev, NULL, idx: 1, |
780 | flags: GPIOD_OUT_HIGH); |
781 | if (IS_ERR(ptr: ts->gpio_rst)) { |
782 | ret = PTR_ERR(ptr: ts->gpio_rst); |
783 | dev_err(&client->dev, |
784 | "failed to request reset GPIO: %d\n" , ret); |
785 | return ret; |
786 | } |
787 | } |
788 | |
789 | ts->reg_vdd = devm_regulator_get_optional(dev: &client->dev, id: "vdd" ); |
790 | if (IS_ERR(ptr: ts->reg_vdd)) { |
791 | ret = PTR_ERR(ptr: ts->reg_vdd); |
792 | if (ret == -EPROBE_DEFER) |
793 | return ret; |
794 | } else { |
795 | ret = regulator_enable(regulator: ts->reg_vdd); |
796 | if (ret) |
797 | return ret; |
798 | |
799 | /* |
800 | * according to datasheet add 100us grace time after regular |
801 | * regulator enable delay. |
802 | */ |
803 | udelay(100); |
804 | } |
805 | |
806 | ret = devm_add_action(&client->dev, zforce_reset, ts); |
807 | if (ret) { |
808 | dev_err(&client->dev, "failed to register reset action, %d\n" , |
809 | ret); |
810 | |
811 | /* hereafter the regulator will be disabled by the action */ |
812 | if (!IS_ERR(ptr: ts->reg_vdd)) |
813 | regulator_disable(regulator: ts->reg_vdd); |
814 | |
815 | return ret; |
816 | } |
817 | |
818 | snprintf(buf: ts->phys, size: sizeof(ts->phys), |
819 | fmt: "%s/input0" , dev_name(dev: &client->dev)); |
820 | |
821 | input_dev = devm_input_allocate_device(&client->dev); |
822 | if (!input_dev) { |
823 | dev_err(&client->dev, "could not allocate input device\n" ); |
824 | return -ENOMEM; |
825 | } |
826 | |
827 | mutex_init(&ts->access_mutex); |
828 | mutex_init(&ts->command_mutex); |
829 | |
830 | ts->pdata = pdata; |
831 | ts->client = client; |
832 | ts->input = input_dev; |
833 | |
834 | input_dev->name = "Neonode zForce touchscreen" ; |
835 | input_dev->phys = ts->phys; |
836 | input_dev->id.bustype = BUS_I2C; |
837 | |
838 | input_dev->open = zforce_input_open; |
839 | input_dev->close = zforce_input_close; |
840 | |
841 | __set_bit(EV_KEY, input_dev->evbit); |
842 | __set_bit(EV_SYN, input_dev->evbit); |
843 | __set_bit(EV_ABS, input_dev->evbit); |
844 | |
845 | /* For multi touch */ |
846 | input_set_abs_params(dev: input_dev, ABS_MT_POSITION_X, min: 0, |
847 | max: pdata->x_max, fuzz: 0, flat: 0); |
848 | input_set_abs_params(dev: input_dev, ABS_MT_POSITION_Y, min: 0, |
849 | max: pdata->y_max, fuzz: 0, flat: 0); |
850 | |
851 | touchscreen_parse_properties(input: input_dev, multitouch: true, prop: &ts->prop); |
852 | if (ts->prop.max_x == 0 || ts->prop.max_y == 0) { |
853 | dev_err(&client->dev, "no size specified\n" ); |
854 | return -EINVAL; |
855 | } |
856 | |
857 | input_set_abs_params(dev: input_dev, ABS_MT_TOUCH_MAJOR, min: 0, |
858 | ZFORCE_MAX_AREA, fuzz: 0, flat: 0); |
859 | input_set_abs_params(dev: input_dev, ABS_MT_TOUCH_MINOR, min: 0, |
860 | ZFORCE_MAX_AREA, fuzz: 0, flat: 0); |
861 | input_set_abs_params(dev: input_dev, ABS_MT_ORIENTATION, min: 0, max: 1, fuzz: 0, flat: 0); |
862 | input_mt_init_slots(dev: input_dev, ZFORCE_REPORT_POINTS, INPUT_MT_DIRECT); |
863 | |
864 | input_set_drvdata(dev: ts->input, data: ts); |
865 | |
866 | init_completion(x: &ts->command_done); |
867 | |
868 | /* |
869 | * The zforce pulls the interrupt low when it has data ready. |
870 | * After it is triggered the isr thread runs until all the available |
871 | * packets have been read and the interrupt is high again. |
872 | * Therefore we can trigger the interrupt anytime it is low and do |
873 | * not need to limit it to the interrupt edge. |
874 | */ |
875 | ret = devm_request_threaded_irq(dev: &client->dev, irq: client->irq, |
876 | handler: zforce_irq, thread_fn: zforce_irq_thread, |
877 | IRQF_TRIGGER_LOW | IRQF_ONESHOT, |
878 | devname: input_dev->name, dev_id: ts); |
879 | if (ret) { |
880 | dev_err(&client->dev, "irq %d request failed\n" , client->irq); |
881 | return ret; |
882 | } |
883 | |
884 | i2c_set_clientdata(client, data: ts); |
885 | |
886 | /* let the controller boot */ |
887 | zforce_reset_deassert(ts); |
888 | |
889 | ts->command_waiting = NOTIFICATION_BOOTCOMPLETE; |
890 | if (wait_for_completion_timeout(x: &ts->command_done, WAIT_TIMEOUT) == 0) |
891 | dev_warn(&client->dev, "bootcomplete timed out\n" ); |
892 | |
893 | /* need to start device to get version information */ |
894 | ret = zforce_command_wait(ts, COMMAND_INITIALIZE); |
895 | if (ret) { |
896 | dev_err(&client->dev, "unable to initialize, %d\n" , ret); |
897 | return ret; |
898 | } |
899 | |
900 | /* this gets the firmware version among other information */ |
901 | ret = zforce_command_wait(ts, COMMAND_STATUS); |
902 | if (ret < 0) { |
903 | dev_err(&client->dev, "couldn't get status, %d\n" , ret); |
904 | zforce_stop(ts); |
905 | return ret; |
906 | } |
907 | |
908 | /* stop device and put it into sleep until it is opened */ |
909 | ret = zforce_stop(ts); |
910 | if (ret < 0) |
911 | return ret; |
912 | |
913 | device_set_wakeup_capable(dev: &client->dev, capable: true); |
914 | |
915 | ret = input_register_device(input_dev); |
916 | if (ret) { |
917 | dev_err(&client->dev, "could not register input device, %d\n" , |
918 | ret); |
919 | return ret; |
920 | } |
921 | |
922 | return 0; |
923 | } |
924 | |
925 | static struct i2c_device_id zforce_idtable[] = { |
926 | { "zforce-ts" , 0 }, |
927 | { } |
928 | }; |
929 | MODULE_DEVICE_TABLE(i2c, zforce_idtable); |
930 | |
931 | #ifdef CONFIG_OF |
932 | static const struct of_device_id zforce_dt_idtable[] = { |
933 | { .compatible = "neonode,zforce" }, |
934 | {}, |
935 | }; |
936 | MODULE_DEVICE_TABLE(of, zforce_dt_idtable); |
937 | #endif |
938 | |
939 | static struct i2c_driver zforce_driver = { |
940 | .driver = { |
941 | .name = "zforce-ts" , |
942 | .pm = pm_sleep_ptr(&zforce_pm_ops), |
943 | .of_match_table = of_match_ptr(zforce_dt_idtable), |
944 | }, |
945 | .probe = zforce_probe, |
946 | .id_table = zforce_idtable, |
947 | }; |
948 | |
949 | module_i2c_driver(zforce_driver); |
950 | |
951 | MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>" ); |
952 | MODULE_DESCRIPTION("zForce TouchScreen Driver" ); |
953 | MODULE_LICENSE("GPL" ); |
954 | |