1 | /* |
2 | * Cypress APA trackpad with I2C interface |
3 | * |
4 | * Author: Dudley Du <dudl@cypress.com> |
5 | * Further cleanup and restructuring by: |
6 | * Daniel Kurtz <djkurtz@chromium.org> |
7 | * Benson Leung <bleung@chromium.org> |
8 | * |
9 | * Copyright (C) 2011-2015 Cypress Semiconductor, Inc. |
10 | * Copyright (C) 2011-2012 Google, Inc. |
11 | * |
12 | * This file is subject to the terms and conditions of the GNU General Public |
13 | * License. See the file COPYING in the main directory of this archive for |
14 | * more details. |
15 | */ |
16 | |
17 | #include <linux/delay.h> |
18 | #include <linux/i2c.h> |
19 | #include <linux/input.h> |
20 | #include <linux/input/mt.h> |
21 | #include <linux/interrupt.h> |
22 | #include <linux/module.h> |
23 | #include <linux/mutex.h> |
24 | #include <linux/regulator/consumer.h> |
25 | #include <linux/slab.h> |
26 | #include <linux/uaccess.h> |
27 | #include <linux/pm_runtime.h> |
28 | #include <linux/acpi.h> |
29 | #include <linux/of.h> |
30 | #include "cyapa.h" |
31 | |
32 | |
33 | #define CYAPA_ADAPTER_FUNC_NONE 0 |
34 | #define CYAPA_ADAPTER_FUNC_I2C 1 |
35 | #define CYAPA_ADAPTER_FUNC_SMBUS 2 |
36 | #define CYAPA_ADAPTER_FUNC_BOTH 3 |
37 | |
38 | #define CYAPA_FW_NAME "cyapa.bin" |
39 | |
40 | const char product_id[] = "CYTRA" ; |
41 | |
42 | static int cyapa_reinitialize(struct cyapa *cyapa); |
43 | |
44 | bool cyapa_is_pip_bl_mode(struct cyapa *cyapa) |
45 | { |
46 | if (cyapa->gen == CYAPA_GEN6 && cyapa->state == CYAPA_STATE_GEN6_BL) |
47 | return true; |
48 | |
49 | if (cyapa->gen == CYAPA_GEN5 && cyapa->state == CYAPA_STATE_GEN5_BL) |
50 | return true; |
51 | |
52 | return false; |
53 | } |
54 | |
55 | bool cyapa_is_pip_app_mode(struct cyapa *cyapa) |
56 | { |
57 | if (cyapa->gen == CYAPA_GEN6 && cyapa->state == CYAPA_STATE_GEN6_APP) |
58 | return true; |
59 | |
60 | if (cyapa->gen == CYAPA_GEN5 && cyapa->state == CYAPA_STATE_GEN5_APP) |
61 | return true; |
62 | |
63 | return false; |
64 | } |
65 | |
66 | static bool cyapa_is_bootloader_mode(struct cyapa *cyapa) |
67 | { |
68 | if (cyapa_is_pip_bl_mode(cyapa)) |
69 | return true; |
70 | |
71 | if (cyapa->gen == CYAPA_GEN3 && |
72 | cyapa->state >= CYAPA_STATE_BL_BUSY && |
73 | cyapa->state <= CYAPA_STATE_BL_ACTIVE) |
74 | return true; |
75 | |
76 | return false; |
77 | } |
78 | |
79 | static inline bool cyapa_is_operational_mode(struct cyapa *cyapa) |
80 | { |
81 | if (cyapa_is_pip_app_mode(cyapa)) |
82 | return true; |
83 | |
84 | if (cyapa->gen == CYAPA_GEN3 && cyapa->state == CYAPA_STATE_OP) |
85 | return true; |
86 | |
87 | return false; |
88 | } |
89 | |
90 | /* Returns 0 on success, else negative errno on failure. */ |
91 | static ssize_t cyapa_i2c_read(struct cyapa *cyapa, u8 reg, size_t len, |
92 | u8 *values) |
93 | { |
94 | struct i2c_client *client = cyapa->client; |
95 | struct i2c_msg msgs[] = { |
96 | { |
97 | .addr = client->addr, |
98 | .flags = 0, |
99 | .len = 1, |
100 | .buf = ®, |
101 | }, |
102 | { |
103 | .addr = client->addr, |
104 | .flags = I2C_M_RD, |
105 | .len = len, |
106 | .buf = values, |
107 | }, |
108 | }; |
109 | int ret; |
110 | |
111 | ret = i2c_transfer(adap: client->adapter, msgs, ARRAY_SIZE(msgs)); |
112 | |
113 | if (ret != ARRAY_SIZE(msgs)) |
114 | return ret < 0 ? ret : -EIO; |
115 | |
116 | return 0; |
117 | } |
118 | |
119 | /** |
120 | * cyapa_i2c_write - Execute i2c block data write operation |
121 | * @cyapa: Handle to this driver |
122 | * @reg: Offset of the data to written in the register map |
123 | * @len: number of bytes to write |
124 | * @values: Data to be written |
125 | * |
126 | * Return negative errno code on error; return zero when success. |
127 | */ |
128 | static int cyapa_i2c_write(struct cyapa *cyapa, u8 reg, |
129 | size_t len, const void *values) |
130 | { |
131 | struct i2c_client *client = cyapa->client; |
132 | char buf[32]; |
133 | int ret; |
134 | |
135 | if (len > sizeof(buf) - 1) |
136 | return -ENOMEM; |
137 | |
138 | buf[0] = reg; |
139 | memcpy(&buf[1], values, len); |
140 | |
141 | ret = i2c_master_send(client, buf, count: len + 1); |
142 | if (ret != len + 1) |
143 | return ret < 0 ? ret : -EIO; |
144 | |
145 | return 0; |
146 | } |
147 | |
148 | static u8 cyapa_check_adapter_functionality(struct i2c_client *client) |
149 | { |
150 | u8 ret = CYAPA_ADAPTER_FUNC_NONE; |
151 | |
152 | if (i2c_check_functionality(adap: client->adapter, I2C_FUNC_I2C)) |
153 | ret |= CYAPA_ADAPTER_FUNC_I2C; |
154 | if (i2c_check_functionality(adap: client->adapter, I2C_FUNC_SMBUS_BYTE_DATA | |
155 | I2C_FUNC_SMBUS_BLOCK_DATA | |
156 | I2C_FUNC_SMBUS_I2C_BLOCK)) |
157 | ret |= CYAPA_ADAPTER_FUNC_SMBUS; |
158 | return ret; |
159 | } |
160 | |
161 | /* |
162 | * Query device for its current operating state. |
163 | */ |
164 | static int cyapa_get_state(struct cyapa *cyapa) |
165 | { |
166 | u8 status[BL_STATUS_SIZE]; |
167 | u8 cmd[32]; |
168 | /* The i2c address of gen4 and gen5 trackpad device must be even. */ |
169 | bool even_addr = ((cyapa->client->addr & 0x0001) == 0); |
170 | bool smbus = false; |
171 | int retries = 2; |
172 | int error; |
173 | |
174 | cyapa->state = CYAPA_STATE_NO_DEVICE; |
175 | |
176 | /* |
177 | * Get trackpad status by reading 3 registers starting from 0. |
178 | * If the device is in the bootloader, this will be BL_HEAD. |
179 | * If the device is in operation mode, this will be the DATA regs. |
180 | * |
181 | */ |
182 | error = cyapa_i2c_reg_read_block(cyapa, BL_HEAD_OFFSET, BL_STATUS_SIZE, |
183 | values: status); |
184 | |
185 | /* |
186 | * On smbus systems in OP mode, the i2c_reg_read will fail with |
187 | * -ETIMEDOUT. In this case, try again using the smbus equivalent |
188 | * command. This should return a BL_HEAD indicating CYAPA_STATE_OP. |
189 | */ |
190 | if (cyapa->smbus && (error == -ETIMEDOUT || error == -ENXIO)) { |
191 | if (!even_addr) |
192 | error = cyapa_read_block(cyapa, |
193 | CYAPA_CMD_BL_STATUS, values: status); |
194 | smbus = true; |
195 | } |
196 | |
197 | if (error != BL_STATUS_SIZE) |
198 | goto error; |
199 | |
200 | /* |
201 | * Detect trackpad protocol based on characteristic registers and bits. |
202 | */ |
203 | do { |
204 | cyapa->status[REG_OP_STATUS] = status[REG_OP_STATUS]; |
205 | cyapa->status[REG_BL_STATUS] = status[REG_BL_STATUS]; |
206 | cyapa->status[REG_BL_ERROR] = status[REG_BL_ERROR]; |
207 | |
208 | if (cyapa->gen == CYAPA_GEN_UNKNOWN || |
209 | cyapa->gen == CYAPA_GEN3) { |
210 | error = cyapa_gen3_ops.state_parse(cyapa, |
211 | status, BL_STATUS_SIZE); |
212 | if (!error) |
213 | goto out_detected; |
214 | } |
215 | if (cyapa->gen == CYAPA_GEN_UNKNOWN || |
216 | cyapa->gen == CYAPA_GEN6 || |
217 | cyapa->gen == CYAPA_GEN5) { |
218 | error = cyapa_pip_state_parse(cyapa, |
219 | reg_data: status, BL_STATUS_SIZE); |
220 | if (!error) |
221 | goto out_detected; |
222 | } |
223 | /* For old Gen5 trackpads detecting. */ |
224 | if ((cyapa->gen == CYAPA_GEN_UNKNOWN || |
225 | cyapa->gen == CYAPA_GEN5) && |
226 | !smbus && even_addr) { |
227 | error = cyapa_gen5_ops.state_parse(cyapa, |
228 | status, BL_STATUS_SIZE); |
229 | if (!error) |
230 | goto out_detected; |
231 | } |
232 | |
233 | /* |
234 | * Write 0x00 0x00 to trackpad device to force update its |
235 | * status, then redo the detection again. |
236 | */ |
237 | if (!smbus) { |
238 | cmd[0] = 0x00; |
239 | cmd[1] = 0x00; |
240 | error = cyapa_i2c_write(cyapa, reg: 0, len: 2, values: cmd); |
241 | if (error) |
242 | goto error; |
243 | |
244 | msleep(msecs: 50); |
245 | |
246 | error = cyapa_i2c_read(cyapa, BL_HEAD_OFFSET, |
247 | BL_STATUS_SIZE, values: status); |
248 | if (error) |
249 | goto error; |
250 | } |
251 | } while (--retries > 0 && !smbus); |
252 | |
253 | goto error; |
254 | |
255 | out_detected: |
256 | if (cyapa->state <= CYAPA_STATE_BL_BUSY) |
257 | return -EAGAIN; |
258 | return 0; |
259 | |
260 | error: |
261 | return (error < 0) ? error : -EAGAIN; |
262 | } |
263 | |
264 | /* |
265 | * Poll device for its status in a loop, waiting up to timeout for a response. |
266 | * |
267 | * When the device switches state, it usually takes ~300 ms. |
268 | * However, when running a new firmware image, the device must calibrate its |
269 | * sensors, which can take as long as 2 seconds. |
270 | * |
271 | * Note: The timeout has granularity of the polling rate, which is 100 ms. |
272 | * |
273 | * Returns: |
274 | * 0 when the device eventually responds with a valid non-busy state. |
275 | * -ETIMEDOUT if device never responds (too many -EAGAIN) |
276 | * -EAGAIN if bootload is busy, or unknown state. |
277 | * < 0 other errors |
278 | */ |
279 | int cyapa_poll_state(struct cyapa *cyapa, unsigned int timeout) |
280 | { |
281 | int error; |
282 | int tries = timeout / 100; |
283 | |
284 | do { |
285 | error = cyapa_get_state(cyapa); |
286 | if (!error && cyapa->state > CYAPA_STATE_BL_BUSY) |
287 | return 0; |
288 | |
289 | msleep(msecs: 100); |
290 | } while (tries--); |
291 | |
292 | return (error == -EAGAIN || error == -ETIMEDOUT) ? -ETIMEDOUT : error; |
293 | } |
294 | |
295 | /* |
296 | * Check if device is operational. |
297 | * |
298 | * An operational device is responding, has exited bootloader, and has |
299 | * firmware supported by this driver. |
300 | * |
301 | * Returns: |
302 | * -ENODEV no device |
303 | * -EBUSY no device or in bootloader |
304 | * -EIO failure while reading from device |
305 | * -ETIMEDOUT timeout failure for bus idle or bus no response |
306 | * -EAGAIN device is still in bootloader |
307 | * if ->state = CYAPA_STATE_BL_IDLE, device has invalid firmware |
308 | * -EINVAL device is in operational mode, but not supported by this driver |
309 | * 0 device is supported |
310 | */ |
311 | static int cyapa_check_is_operational(struct cyapa *cyapa) |
312 | { |
313 | int error; |
314 | |
315 | error = cyapa_poll_state(cyapa, timeout: 4000); |
316 | if (error) |
317 | return error; |
318 | |
319 | switch (cyapa->gen) { |
320 | case CYAPA_GEN6: |
321 | cyapa->ops = &cyapa_gen6_ops; |
322 | break; |
323 | case CYAPA_GEN5: |
324 | cyapa->ops = &cyapa_gen5_ops; |
325 | break; |
326 | case CYAPA_GEN3: |
327 | cyapa->ops = &cyapa_gen3_ops; |
328 | break; |
329 | default: |
330 | return -ENODEV; |
331 | } |
332 | |
333 | error = cyapa->ops->operational_check(cyapa); |
334 | if (!error && cyapa_is_operational_mode(cyapa)) |
335 | cyapa->operational = true; |
336 | else |
337 | cyapa->operational = false; |
338 | |
339 | return error; |
340 | } |
341 | |
342 | |
343 | /* |
344 | * Returns 0 on device detected, negative errno on no device detected. |
345 | * And when the device is detected and operational, it will be reset to |
346 | * full power active mode automatically. |
347 | */ |
348 | static int cyapa_detect(struct cyapa *cyapa) |
349 | { |
350 | struct device *dev = &cyapa->client->dev; |
351 | int error; |
352 | |
353 | error = cyapa_check_is_operational(cyapa); |
354 | if (error) { |
355 | if (error != -ETIMEDOUT && error != -ENODEV && |
356 | cyapa_is_bootloader_mode(cyapa)) { |
357 | dev_warn(dev, "device detected but not operational\n" ); |
358 | return 0; |
359 | } |
360 | |
361 | dev_err(dev, "no device detected: %d\n" , error); |
362 | return error; |
363 | } |
364 | |
365 | return 0; |
366 | } |
367 | |
368 | static int cyapa_open(struct input_dev *input) |
369 | { |
370 | struct cyapa *cyapa = input_get_drvdata(dev: input); |
371 | struct i2c_client *client = cyapa->client; |
372 | struct device *dev = &client->dev; |
373 | int error; |
374 | |
375 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
376 | if (error) |
377 | return error; |
378 | |
379 | if (cyapa->operational) { |
380 | /* |
381 | * though failed to set active power mode, |
382 | * but still may be able to work in lower scan rate |
383 | * when in operational mode. |
384 | */ |
385 | error = cyapa->ops->set_power_mode(cyapa, |
386 | PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_ACTIVE); |
387 | if (error) { |
388 | dev_warn(dev, "set active power failed: %d\n" , error); |
389 | goto out; |
390 | } |
391 | } else { |
392 | error = cyapa_reinitialize(cyapa); |
393 | if (error || !cyapa->operational) { |
394 | error = error ? error : -EAGAIN; |
395 | goto out; |
396 | } |
397 | } |
398 | |
399 | enable_irq(irq: client->irq); |
400 | if (!pm_runtime_enabled(dev)) { |
401 | pm_runtime_set_active(dev); |
402 | pm_runtime_enable(dev); |
403 | } |
404 | |
405 | pm_runtime_get_sync(dev); |
406 | pm_runtime_mark_last_busy(dev); |
407 | pm_runtime_put_sync_autosuspend(dev); |
408 | out: |
409 | mutex_unlock(lock: &cyapa->state_sync_lock); |
410 | return error; |
411 | } |
412 | |
413 | static void cyapa_close(struct input_dev *input) |
414 | { |
415 | struct cyapa *cyapa = input_get_drvdata(dev: input); |
416 | struct i2c_client *client = cyapa->client; |
417 | struct device *dev = &cyapa->client->dev; |
418 | |
419 | mutex_lock(&cyapa->state_sync_lock); |
420 | |
421 | disable_irq(irq: client->irq); |
422 | if (pm_runtime_enabled(dev)) |
423 | pm_runtime_disable(dev); |
424 | pm_runtime_set_suspended(dev); |
425 | |
426 | if (cyapa->operational) |
427 | cyapa->ops->set_power_mode(cyapa, |
428 | PWR_MODE_OFF, 0, CYAPA_PM_DEACTIVE); |
429 | |
430 | mutex_unlock(lock: &cyapa->state_sync_lock); |
431 | } |
432 | |
433 | static int cyapa_create_input_dev(struct cyapa *cyapa) |
434 | { |
435 | struct device *dev = &cyapa->client->dev; |
436 | struct input_dev *input; |
437 | int error; |
438 | |
439 | if (!cyapa->physical_size_x || !cyapa->physical_size_y) |
440 | return -EINVAL; |
441 | |
442 | input = devm_input_allocate_device(dev); |
443 | if (!input) { |
444 | dev_err(dev, "failed to allocate memory for input device.\n" ); |
445 | return -ENOMEM; |
446 | } |
447 | |
448 | input->name = CYAPA_NAME; |
449 | input->phys = cyapa->phys; |
450 | input->id.bustype = BUS_I2C; |
451 | input->id.version = 1; |
452 | input->id.product = 0; /* Means any product in eventcomm. */ |
453 | input->dev.parent = &cyapa->client->dev; |
454 | |
455 | input->open = cyapa_open; |
456 | input->close = cyapa_close; |
457 | |
458 | input_set_drvdata(dev: input, data: cyapa); |
459 | |
460 | __set_bit(EV_ABS, input->evbit); |
461 | |
462 | /* Finger position */ |
463 | input_set_abs_params(dev: input, ABS_MT_POSITION_X, min: 0, max: cyapa->max_abs_x, fuzz: 0, |
464 | flat: 0); |
465 | input_set_abs_params(dev: input, ABS_MT_POSITION_Y, min: 0, max: cyapa->max_abs_y, fuzz: 0, |
466 | flat: 0); |
467 | input_set_abs_params(dev: input, ABS_MT_PRESSURE, min: 0, max: cyapa->max_z, fuzz: 0, flat: 0); |
468 | if (cyapa->gen > CYAPA_GEN3) { |
469 | input_set_abs_params(dev: input, ABS_MT_TOUCH_MAJOR, min: 0, max: 255, fuzz: 0, flat: 0); |
470 | input_set_abs_params(dev: input, ABS_MT_TOUCH_MINOR, min: 0, max: 255, fuzz: 0, flat: 0); |
471 | /* |
472 | * Orientation is the angle between the vertical axis and |
473 | * the major axis of the contact ellipse. |
474 | * The range is -127 to 127. |
475 | * the positive direction is clockwise form the vertical axis. |
476 | * If the ellipse of contact degenerates into a circle, |
477 | * orientation is reported as 0. |
478 | * |
479 | * Also, for Gen5 trackpad the accurate of this orientation |
480 | * value is value + (-30 ~ 30). |
481 | */ |
482 | input_set_abs_params(dev: input, ABS_MT_ORIENTATION, |
483 | min: -127, max: 127, fuzz: 0, flat: 0); |
484 | } |
485 | if (cyapa->gen >= CYAPA_GEN5) { |
486 | input_set_abs_params(dev: input, ABS_MT_WIDTH_MAJOR, min: 0, max: 255, fuzz: 0, flat: 0); |
487 | input_set_abs_params(dev: input, ABS_MT_WIDTH_MINOR, min: 0, max: 255, fuzz: 0, flat: 0); |
488 | input_set_abs_params(dev: input, ABS_DISTANCE, min: 0, max: 1, fuzz: 0, flat: 0); |
489 | } |
490 | |
491 | input_abs_set_res(dev: input, ABS_MT_POSITION_X, |
492 | val: cyapa->max_abs_x / cyapa->physical_size_x); |
493 | input_abs_set_res(dev: input, ABS_MT_POSITION_Y, |
494 | val: cyapa->max_abs_y / cyapa->physical_size_y); |
495 | |
496 | if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK) |
497 | __set_bit(BTN_LEFT, input->keybit); |
498 | if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK) |
499 | __set_bit(BTN_MIDDLE, input->keybit); |
500 | if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK) |
501 | __set_bit(BTN_RIGHT, input->keybit); |
502 | |
503 | if (cyapa->btn_capability == CAPABILITY_LEFT_BTN_MASK) |
504 | __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); |
505 | |
506 | /* Handle pointer emulation and unused slots in core */ |
507 | error = input_mt_init_slots(dev: input, CYAPA_MAX_MT_SLOTS, |
508 | INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED); |
509 | if (error) { |
510 | dev_err(dev, "failed to initialize MT slots: %d\n" , error); |
511 | return error; |
512 | } |
513 | |
514 | /* Register the device in input subsystem */ |
515 | error = input_register_device(input); |
516 | if (error) { |
517 | dev_err(dev, "failed to register input device: %d\n" , error); |
518 | return error; |
519 | } |
520 | |
521 | cyapa->input = input; |
522 | return 0; |
523 | } |
524 | |
525 | static void cyapa_enable_irq_for_cmd(struct cyapa *cyapa) |
526 | { |
527 | struct input_dev *input = cyapa->input; |
528 | |
529 | if (!input || !input_device_enabled(dev: input)) { |
530 | /* |
531 | * When input is NULL, TP must be in deep sleep mode. |
532 | * In this mode, later non-power I2C command will always failed |
533 | * if not bring it out of deep sleep mode firstly, |
534 | * so must command TP to active mode here. |
535 | */ |
536 | if (!input || cyapa->operational) |
537 | cyapa->ops->set_power_mode(cyapa, |
538 | PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_ACTIVE); |
539 | /* Gen3 always using polling mode for command. */ |
540 | if (cyapa->gen >= CYAPA_GEN5) |
541 | enable_irq(irq: cyapa->client->irq); |
542 | } |
543 | } |
544 | |
545 | static void cyapa_disable_irq_for_cmd(struct cyapa *cyapa) |
546 | { |
547 | struct input_dev *input = cyapa->input; |
548 | |
549 | if (!input || !input_device_enabled(dev: input)) { |
550 | if (cyapa->gen >= CYAPA_GEN5) |
551 | disable_irq(irq: cyapa->client->irq); |
552 | if (!input || cyapa->operational) |
553 | cyapa->ops->set_power_mode(cyapa, |
554 | PWR_MODE_OFF, 0, CYAPA_PM_ACTIVE); |
555 | } |
556 | } |
557 | |
558 | /* |
559 | * cyapa_sleep_time_to_pwr_cmd and cyapa_pwr_cmd_to_sleep_time |
560 | * |
561 | * These are helper functions that convert to and from integer idle |
562 | * times and register settings to write to the PowerMode register. |
563 | * The trackpad supports between 20ms to 1000ms scan intervals. |
564 | * The time will be increased in increments of 10ms from 20ms to 100ms. |
565 | * From 100ms to 1000ms, time will be increased in increments of 20ms. |
566 | * |
567 | * When Idle_Time < 100, the format to convert Idle_Time to Idle_Command is: |
568 | * Idle_Command = Idle Time / 10; |
569 | * When Idle_Time >= 100, the format to convert Idle_Time to Idle_Command is: |
570 | * Idle_Command = Idle Time / 20 + 5; |
571 | */ |
572 | u8 cyapa_sleep_time_to_pwr_cmd(u16 sleep_time) |
573 | { |
574 | u16 encoded_time; |
575 | |
576 | sleep_time = clamp_val(sleep_time, 20, 1000); |
577 | encoded_time = sleep_time < 100 ? sleep_time / 10 : sleep_time / 20 + 5; |
578 | return (encoded_time << 2) & PWR_MODE_MASK; |
579 | } |
580 | |
581 | u16 cyapa_pwr_cmd_to_sleep_time(u8 pwr_mode) |
582 | { |
583 | u8 encoded_time = pwr_mode >> 2; |
584 | |
585 | return (encoded_time < 10) ? encoded_time * 10 |
586 | : (encoded_time - 5) * 20; |
587 | } |
588 | |
589 | /* 0 on driver initialize and detected successfully, negative on failure. */ |
590 | static int cyapa_initialize(struct cyapa *cyapa) |
591 | { |
592 | int error = 0; |
593 | |
594 | cyapa->state = CYAPA_STATE_NO_DEVICE; |
595 | cyapa->gen = CYAPA_GEN_UNKNOWN; |
596 | mutex_init(&cyapa->state_sync_lock); |
597 | |
598 | /* |
599 | * Set to hard code default, they will be updated with trackpad set |
600 | * default values after probe and initialized. |
601 | */ |
602 | cyapa->suspend_power_mode = PWR_MODE_SLEEP; |
603 | cyapa->suspend_sleep_time = |
604 | cyapa_pwr_cmd_to_sleep_time(pwr_mode: cyapa->suspend_power_mode); |
605 | |
606 | /* ops.initialize() is aimed to prepare for module communications. */ |
607 | error = cyapa_gen3_ops.initialize(cyapa); |
608 | if (!error) |
609 | error = cyapa_gen5_ops.initialize(cyapa); |
610 | if (!error) |
611 | error = cyapa_gen6_ops.initialize(cyapa); |
612 | if (error) |
613 | return error; |
614 | |
615 | error = cyapa_detect(cyapa); |
616 | if (error) |
617 | return error; |
618 | |
619 | /* Power down the device until we need it. */ |
620 | if (cyapa->operational) |
621 | cyapa->ops->set_power_mode(cyapa, |
622 | PWR_MODE_OFF, 0, CYAPA_PM_ACTIVE); |
623 | |
624 | return 0; |
625 | } |
626 | |
627 | static int cyapa_reinitialize(struct cyapa *cyapa) |
628 | { |
629 | struct device *dev = &cyapa->client->dev; |
630 | struct input_dev *input = cyapa->input; |
631 | int error; |
632 | |
633 | if (pm_runtime_enabled(dev)) |
634 | pm_runtime_disable(dev); |
635 | |
636 | /* Avoid command failures when TP was in OFF state. */ |
637 | if (cyapa->operational) |
638 | cyapa->ops->set_power_mode(cyapa, |
639 | PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_ACTIVE); |
640 | |
641 | error = cyapa_detect(cyapa); |
642 | if (error) |
643 | goto out; |
644 | |
645 | if (!input && cyapa->operational) { |
646 | error = cyapa_create_input_dev(cyapa); |
647 | if (error) { |
648 | dev_err(dev, "create input_dev instance failed: %d\n" , |
649 | error); |
650 | goto out; |
651 | } |
652 | } |
653 | |
654 | out: |
655 | if (!input || !input_device_enabled(dev: input)) { |
656 | /* Reset to power OFF state to save power when no user open. */ |
657 | if (cyapa->operational) |
658 | cyapa->ops->set_power_mode(cyapa, |
659 | PWR_MODE_OFF, 0, CYAPA_PM_DEACTIVE); |
660 | } else if (!error && cyapa->operational) { |
661 | /* |
662 | * Make sure only enable runtime PM when device is |
663 | * in operational mode and input->users > 0. |
664 | */ |
665 | pm_runtime_set_active(dev); |
666 | pm_runtime_enable(dev); |
667 | |
668 | pm_runtime_get_sync(dev); |
669 | pm_runtime_mark_last_busy(dev); |
670 | pm_runtime_put_sync_autosuspend(dev); |
671 | } |
672 | |
673 | return error; |
674 | } |
675 | |
676 | static irqreturn_t cyapa_irq(int irq, void *dev_id) |
677 | { |
678 | struct cyapa *cyapa = dev_id; |
679 | struct device *dev = &cyapa->client->dev; |
680 | int error; |
681 | |
682 | if (device_may_wakeup(dev)) |
683 | pm_wakeup_event(dev, msec: 0); |
684 | |
685 | /* Interrupt event can be caused by host command to trackpad device. */ |
686 | if (cyapa->ops->irq_cmd_handler(cyapa)) { |
687 | /* |
688 | * Interrupt event maybe from trackpad device input reporting. |
689 | */ |
690 | if (!cyapa->input) { |
691 | /* |
692 | * Still in probing or in firmware image |
693 | * updating or reading. |
694 | */ |
695 | cyapa->ops->sort_empty_output_data(cyapa, |
696 | NULL, NULL, NULL); |
697 | goto out; |
698 | } |
699 | |
700 | if (cyapa->operational) { |
701 | error = cyapa->ops->irq_handler(cyapa); |
702 | |
703 | /* |
704 | * Apply runtime power management to touch report event |
705 | * except the events caused by the command responses. |
706 | * Note: |
707 | * It will introduce about 20~40 ms additional delay |
708 | * time in receiving for first valid touch report data. |
709 | * The time is used to execute device runtime resume |
710 | * process. |
711 | */ |
712 | pm_runtime_get_sync(dev); |
713 | pm_runtime_mark_last_busy(dev); |
714 | pm_runtime_put_sync_autosuspend(dev); |
715 | } |
716 | |
717 | if (!cyapa->operational || error) { |
718 | if (!mutex_trylock(lock: &cyapa->state_sync_lock)) { |
719 | cyapa->ops->sort_empty_output_data(cyapa, |
720 | NULL, NULL, NULL); |
721 | goto out; |
722 | } |
723 | cyapa_reinitialize(cyapa); |
724 | mutex_unlock(lock: &cyapa->state_sync_lock); |
725 | } |
726 | } |
727 | |
728 | out: |
729 | return IRQ_HANDLED; |
730 | } |
731 | |
732 | /* |
733 | ************************************************************** |
734 | * sysfs interface |
735 | ************************************************************** |
736 | */ |
737 | #ifdef CONFIG_PM_SLEEP |
738 | static ssize_t cyapa_show_suspend_scanrate(struct device *dev, |
739 | struct device_attribute *attr, |
740 | char *buf) |
741 | { |
742 | struct cyapa *cyapa = dev_get_drvdata(dev); |
743 | u8 pwr_cmd; |
744 | u16 sleep_time; |
745 | int len; |
746 | int error; |
747 | |
748 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
749 | if (error) |
750 | return error; |
751 | |
752 | pwr_cmd = cyapa->suspend_power_mode; |
753 | sleep_time = cyapa->suspend_sleep_time; |
754 | |
755 | mutex_unlock(lock: &cyapa->state_sync_lock); |
756 | |
757 | switch (pwr_cmd) { |
758 | case PWR_MODE_BTN_ONLY: |
759 | len = scnprintf(buf, PAGE_SIZE, fmt: "%s\n" , BTN_ONLY_MODE_NAME); |
760 | break; |
761 | |
762 | case PWR_MODE_OFF: |
763 | len = scnprintf(buf, PAGE_SIZE, fmt: "%s\n" , OFF_MODE_NAME); |
764 | break; |
765 | |
766 | default: |
767 | len = scnprintf(buf, PAGE_SIZE, fmt: "%u\n" , |
768 | cyapa->gen == CYAPA_GEN3 ? |
769 | cyapa_pwr_cmd_to_sleep_time(pwr_mode: pwr_cmd) : |
770 | sleep_time); |
771 | break; |
772 | } |
773 | |
774 | return len; |
775 | } |
776 | |
777 | static ssize_t cyapa_update_suspend_scanrate(struct device *dev, |
778 | struct device_attribute *attr, |
779 | const char *buf, size_t count) |
780 | { |
781 | struct cyapa *cyapa = dev_get_drvdata(dev); |
782 | u16 sleep_time; |
783 | int error; |
784 | |
785 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
786 | if (error) |
787 | return error; |
788 | |
789 | if (sysfs_streq(s1: buf, BTN_ONLY_MODE_NAME)) { |
790 | cyapa->suspend_power_mode = PWR_MODE_BTN_ONLY; |
791 | } else if (sysfs_streq(s1: buf, OFF_MODE_NAME)) { |
792 | cyapa->suspend_power_mode = PWR_MODE_OFF; |
793 | } else if (!kstrtou16(s: buf, base: 10, res: &sleep_time)) { |
794 | cyapa->suspend_sleep_time = min_t(u16, sleep_time, 1000); |
795 | cyapa->suspend_power_mode = |
796 | cyapa_sleep_time_to_pwr_cmd(sleep_time: cyapa->suspend_sleep_time); |
797 | } else { |
798 | count = -EINVAL; |
799 | } |
800 | |
801 | mutex_unlock(lock: &cyapa->state_sync_lock); |
802 | |
803 | return count; |
804 | } |
805 | |
806 | static DEVICE_ATTR(suspend_scanrate_ms, S_IRUGO|S_IWUSR, |
807 | cyapa_show_suspend_scanrate, |
808 | cyapa_update_suspend_scanrate); |
809 | |
810 | static struct attribute *cyapa_power_wakeup_entries[] = { |
811 | &dev_attr_suspend_scanrate_ms.attr, |
812 | NULL, |
813 | }; |
814 | |
815 | static const struct attribute_group cyapa_power_wakeup_group = { |
816 | .name = power_group_name, |
817 | .attrs = cyapa_power_wakeup_entries, |
818 | }; |
819 | |
820 | static void cyapa_remove_power_wakeup_group(void *data) |
821 | { |
822 | struct cyapa *cyapa = data; |
823 | |
824 | sysfs_unmerge_group(kobj: &cyapa->client->dev.kobj, |
825 | grp: &cyapa_power_wakeup_group); |
826 | } |
827 | |
828 | static int cyapa_prepare_wakeup_controls(struct cyapa *cyapa) |
829 | { |
830 | struct i2c_client *client = cyapa->client; |
831 | struct device *dev = &client->dev; |
832 | int error; |
833 | |
834 | if (device_can_wakeup(dev)) { |
835 | error = sysfs_merge_group(kobj: &dev->kobj, |
836 | grp: &cyapa_power_wakeup_group); |
837 | if (error) { |
838 | dev_err(dev, "failed to add power wakeup group: %d\n" , |
839 | error); |
840 | return error; |
841 | } |
842 | |
843 | error = devm_add_action_or_reset(dev, |
844 | cyapa_remove_power_wakeup_group, cyapa); |
845 | if (error) { |
846 | dev_err(dev, "failed to add power cleanup action: %d\n" , |
847 | error); |
848 | return error; |
849 | } |
850 | } |
851 | |
852 | return 0; |
853 | } |
854 | #else |
855 | static inline int cyapa_prepare_wakeup_controls(struct cyapa *cyapa) |
856 | { |
857 | return 0; |
858 | } |
859 | #endif /* CONFIG_PM_SLEEP */ |
860 | |
861 | #ifdef CONFIG_PM |
862 | static ssize_t cyapa_show_rt_suspend_scanrate(struct device *dev, |
863 | struct device_attribute *attr, |
864 | char *buf) |
865 | { |
866 | struct cyapa *cyapa = dev_get_drvdata(dev); |
867 | u8 pwr_cmd; |
868 | u16 sleep_time; |
869 | int error; |
870 | |
871 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
872 | if (error) |
873 | return error; |
874 | |
875 | pwr_cmd = cyapa->runtime_suspend_power_mode; |
876 | sleep_time = cyapa->runtime_suspend_sleep_time; |
877 | |
878 | mutex_unlock(lock: &cyapa->state_sync_lock); |
879 | |
880 | return scnprintf(buf, PAGE_SIZE, fmt: "%u\n" , |
881 | cyapa->gen == CYAPA_GEN3 ? |
882 | cyapa_pwr_cmd_to_sleep_time(pwr_mode: pwr_cmd) : |
883 | sleep_time); |
884 | } |
885 | |
886 | static ssize_t cyapa_update_rt_suspend_scanrate(struct device *dev, |
887 | struct device_attribute *attr, |
888 | const char *buf, size_t count) |
889 | { |
890 | struct cyapa *cyapa = dev_get_drvdata(dev); |
891 | u16 time; |
892 | int error; |
893 | |
894 | if (buf == NULL || count == 0 || kstrtou16(s: buf, base: 10, res: &time)) { |
895 | dev_err(dev, "invalid runtime suspend scanrate ms parameter\n" ); |
896 | return -EINVAL; |
897 | } |
898 | |
899 | /* |
900 | * When the suspend scanrate is changed, pm_runtime_get to resume |
901 | * a potentially suspended device, update to the new pwr_cmd |
902 | * and then pm_runtime_put to suspend into the new power mode. |
903 | */ |
904 | pm_runtime_get_sync(dev); |
905 | |
906 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
907 | if (error) |
908 | return error; |
909 | |
910 | cyapa->runtime_suspend_sleep_time = min_t(u16, time, 1000); |
911 | cyapa->runtime_suspend_power_mode = |
912 | cyapa_sleep_time_to_pwr_cmd(sleep_time: cyapa->runtime_suspend_sleep_time); |
913 | |
914 | mutex_unlock(lock: &cyapa->state_sync_lock); |
915 | |
916 | pm_runtime_put_sync_autosuspend(dev); |
917 | |
918 | return count; |
919 | } |
920 | |
921 | static DEVICE_ATTR(runtime_suspend_scanrate_ms, S_IRUGO|S_IWUSR, |
922 | cyapa_show_rt_suspend_scanrate, |
923 | cyapa_update_rt_suspend_scanrate); |
924 | |
925 | static struct attribute *cyapa_power_runtime_entries[] = { |
926 | &dev_attr_runtime_suspend_scanrate_ms.attr, |
927 | NULL, |
928 | }; |
929 | |
930 | static const struct attribute_group cyapa_power_runtime_group = { |
931 | .name = power_group_name, |
932 | .attrs = cyapa_power_runtime_entries, |
933 | }; |
934 | |
935 | static void cyapa_remove_power_runtime_group(void *data) |
936 | { |
937 | struct cyapa *cyapa = data; |
938 | |
939 | sysfs_unmerge_group(kobj: &cyapa->client->dev.kobj, |
940 | grp: &cyapa_power_runtime_group); |
941 | } |
942 | |
943 | static int cyapa_start_runtime(struct cyapa *cyapa) |
944 | { |
945 | struct device *dev = &cyapa->client->dev; |
946 | int error; |
947 | |
948 | cyapa->runtime_suspend_power_mode = PWR_MODE_IDLE; |
949 | cyapa->runtime_suspend_sleep_time = |
950 | cyapa_pwr_cmd_to_sleep_time(pwr_mode: cyapa->runtime_suspend_power_mode); |
951 | |
952 | error = sysfs_merge_group(kobj: &dev->kobj, grp: &cyapa_power_runtime_group); |
953 | if (error) { |
954 | dev_err(dev, |
955 | "failed to create power runtime group: %d\n" , error); |
956 | return error; |
957 | } |
958 | |
959 | error = devm_add_action_or_reset(dev, cyapa_remove_power_runtime_group, |
960 | cyapa); |
961 | if (error) { |
962 | dev_err(dev, |
963 | "failed to add power runtime cleanup action: %d\n" , |
964 | error); |
965 | return error; |
966 | } |
967 | |
968 | /* runtime is enabled until device is operational and opened. */ |
969 | pm_runtime_set_suspended(dev); |
970 | pm_runtime_use_autosuspend(dev); |
971 | pm_runtime_set_autosuspend_delay(dev, AUTOSUSPEND_DELAY); |
972 | |
973 | return 0; |
974 | } |
975 | #else |
976 | static inline int cyapa_start_runtime(struct cyapa *cyapa) |
977 | { |
978 | return 0; |
979 | } |
980 | #endif /* CONFIG_PM */ |
981 | |
982 | static ssize_t cyapa_show_fm_ver(struct device *dev, |
983 | struct device_attribute *attr, char *buf) |
984 | { |
985 | int error; |
986 | struct cyapa *cyapa = dev_get_drvdata(dev); |
987 | |
988 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
989 | if (error) |
990 | return error; |
991 | error = scnprintf(buf, PAGE_SIZE, fmt: "%d.%d\n" , cyapa->fw_maj_ver, |
992 | cyapa->fw_min_ver); |
993 | mutex_unlock(lock: &cyapa->state_sync_lock); |
994 | return error; |
995 | } |
996 | |
997 | static ssize_t cyapa_show_product_id(struct device *dev, |
998 | struct device_attribute *attr, char *buf) |
999 | { |
1000 | struct cyapa *cyapa = dev_get_drvdata(dev); |
1001 | int size; |
1002 | int error; |
1003 | |
1004 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
1005 | if (error) |
1006 | return error; |
1007 | size = scnprintf(buf, PAGE_SIZE, fmt: "%s\n" , cyapa->product_id); |
1008 | mutex_unlock(lock: &cyapa->state_sync_lock); |
1009 | return size; |
1010 | } |
1011 | |
1012 | static int cyapa_firmware(struct cyapa *cyapa, const char *fw_name) |
1013 | { |
1014 | struct device *dev = &cyapa->client->dev; |
1015 | const struct firmware *fw; |
1016 | int error; |
1017 | |
1018 | error = request_firmware(fw: &fw, name: fw_name, device: dev); |
1019 | if (error) { |
1020 | dev_err(dev, "Could not load firmware from %s: %d\n" , |
1021 | fw_name, error); |
1022 | return error; |
1023 | } |
1024 | |
1025 | error = cyapa->ops->check_fw(cyapa, fw); |
1026 | if (error) { |
1027 | dev_err(dev, "Invalid CYAPA firmware image: %s\n" , |
1028 | fw_name); |
1029 | goto done; |
1030 | } |
1031 | |
1032 | /* |
1033 | * Resume the potentially suspended device because doing FW |
1034 | * update on a device not in the FULL mode has a chance to |
1035 | * fail. |
1036 | */ |
1037 | pm_runtime_get_sync(dev); |
1038 | |
1039 | /* Require IRQ support for firmware update commands. */ |
1040 | cyapa_enable_irq_for_cmd(cyapa); |
1041 | |
1042 | error = cyapa->ops->bl_enter(cyapa); |
1043 | if (error) { |
1044 | dev_err(dev, "bl_enter failed, %d\n" , error); |
1045 | goto err_detect; |
1046 | } |
1047 | |
1048 | error = cyapa->ops->bl_activate(cyapa); |
1049 | if (error) { |
1050 | dev_err(dev, "bl_activate failed, %d\n" , error); |
1051 | goto err_detect; |
1052 | } |
1053 | |
1054 | error = cyapa->ops->bl_initiate(cyapa, fw); |
1055 | if (error) { |
1056 | dev_err(dev, "bl_initiate failed, %d\n" , error); |
1057 | goto err_detect; |
1058 | } |
1059 | |
1060 | error = cyapa->ops->update_fw(cyapa, fw); |
1061 | if (error) { |
1062 | dev_err(dev, "update_fw failed, %d\n" , error); |
1063 | goto err_detect; |
1064 | } |
1065 | |
1066 | err_detect: |
1067 | cyapa_disable_irq_for_cmd(cyapa); |
1068 | pm_runtime_put_noidle(dev); |
1069 | |
1070 | done: |
1071 | release_firmware(fw); |
1072 | return error; |
1073 | } |
1074 | |
1075 | static ssize_t cyapa_update_fw_store(struct device *dev, |
1076 | struct device_attribute *attr, |
1077 | const char *buf, size_t count) |
1078 | { |
1079 | struct cyapa *cyapa = dev_get_drvdata(dev); |
1080 | char fw_name[NAME_MAX]; |
1081 | int ret, error; |
1082 | |
1083 | if (count >= NAME_MAX) { |
1084 | dev_err(dev, "File name too long\n" ); |
1085 | return -EINVAL; |
1086 | } |
1087 | |
1088 | memcpy(fw_name, buf, count); |
1089 | if (fw_name[count - 1] == '\n') |
1090 | fw_name[count - 1] = '\0'; |
1091 | else |
1092 | fw_name[count] = '\0'; |
1093 | |
1094 | if (cyapa->input) { |
1095 | /* |
1096 | * Force the input device to be registered after the firmware |
1097 | * image is updated, so if the corresponding parameters updated |
1098 | * in the new firmware image can taken effect immediately. |
1099 | */ |
1100 | input_unregister_device(cyapa->input); |
1101 | cyapa->input = NULL; |
1102 | } |
1103 | |
1104 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
1105 | if (error) { |
1106 | /* |
1107 | * Whatever, do reinitialize to try to recover TP state to |
1108 | * previous state just as it entered fw update entrance. |
1109 | */ |
1110 | cyapa_reinitialize(cyapa); |
1111 | return error; |
1112 | } |
1113 | |
1114 | error = cyapa_firmware(cyapa, fw_name); |
1115 | if (error) |
1116 | dev_err(dev, "firmware update failed: %d\n" , error); |
1117 | else |
1118 | dev_dbg(dev, "firmware update successfully done.\n" ); |
1119 | |
1120 | /* |
1121 | * Re-detect trackpad device states because firmware update process |
1122 | * will reset trackpad device into bootloader mode. |
1123 | */ |
1124 | ret = cyapa_reinitialize(cyapa); |
1125 | if (ret) { |
1126 | dev_err(dev, "failed to re-detect after updated: %d\n" , ret); |
1127 | error = error ? error : ret; |
1128 | } |
1129 | |
1130 | mutex_unlock(lock: &cyapa->state_sync_lock); |
1131 | |
1132 | return error ? error : count; |
1133 | } |
1134 | |
1135 | static ssize_t cyapa_calibrate_store(struct device *dev, |
1136 | struct device_attribute *attr, |
1137 | const char *buf, size_t count) |
1138 | { |
1139 | struct cyapa *cyapa = dev_get_drvdata(dev); |
1140 | int error; |
1141 | |
1142 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
1143 | if (error) |
1144 | return error; |
1145 | |
1146 | if (cyapa->operational) { |
1147 | cyapa_enable_irq_for_cmd(cyapa); |
1148 | error = cyapa->ops->calibrate_store(dev, attr, buf, count); |
1149 | cyapa_disable_irq_for_cmd(cyapa); |
1150 | } else { |
1151 | error = -EBUSY; /* Still running in bootloader mode. */ |
1152 | } |
1153 | |
1154 | mutex_unlock(lock: &cyapa->state_sync_lock); |
1155 | return error < 0 ? error : count; |
1156 | } |
1157 | |
1158 | static ssize_t cyapa_show_baseline(struct device *dev, |
1159 | struct device_attribute *attr, char *buf) |
1160 | { |
1161 | struct cyapa *cyapa = dev_get_drvdata(dev); |
1162 | ssize_t error; |
1163 | |
1164 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
1165 | if (error) |
1166 | return error; |
1167 | |
1168 | if (cyapa->operational) { |
1169 | cyapa_enable_irq_for_cmd(cyapa); |
1170 | error = cyapa->ops->show_baseline(dev, attr, buf); |
1171 | cyapa_disable_irq_for_cmd(cyapa); |
1172 | } else { |
1173 | error = -EBUSY; /* Still running in bootloader mode. */ |
1174 | } |
1175 | |
1176 | mutex_unlock(lock: &cyapa->state_sync_lock); |
1177 | return error; |
1178 | } |
1179 | |
1180 | static char *cyapa_state_to_string(struct cyapa *cyapa) |
1181 | { |
1182 | switch (cyapa->state) { |
1183 | case CYAPA_STATE_BL_BUSY: |
1184 | return "bootloader busy" ; |
1185 | case CYAPA_STATE_BL_IDLE: |
1186 | return "bootloader idle" ; |
1187 | case CYAPA_STATE_BL_ACTIVE: |
1188 | return "bootloader active" ; |
1189 | case CYAPA_STATE_GEN5_BL: |
1190 | case CYAPA_STATE_GEN6_BL: |
1191 | return "bootloader" ; |
1192 | case CYAPA_STATE_OP: |
1193 | case CYAPA_STATE_GEN5_APP: |
1194 | case CYAPA_STATE_GEN6_APP: |
1195 | return "operational" ; /* Normal valid state. */ |
1196 | default: |
1197 | return "invalid mode" ; |
1198 | } |
1199 | } |
1200 | |
1201 | static ssize_t cyapa_show_mode(struct device *dev, |
1202 | struct device_attribute *attr, char *buf) |
1203 | { |
1204 | struct cyapa *cyapa = dev_get_drvdata(dev); |
1205 | int size; |
1206 | int error; |
1207 | |
1208 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
1209 | if (error) |
1210 | return error; |
1211 | |
1212 | size = scnprintf(buf, PAGE_SIZE, fmt: "gen%d %s\n" , |
1213 | cyapa->gen, cyapa_state_to_string(cyapa)); |
1214 | |
1215 | mutex_unlock(lock: &cyapa->state_sync_lock); |
1216 | return size; |
1217 | } |
1218 | |
1219 | static DEVICE_ATTR(firmware_version, S_IRUGO, cyapa_show_fm_ver, NULL); |
1220 | static DEVICE_ATTR(product_id, S_IRUGO, cyapa_show_product_id, NULL); |
1221 | static DEVICE_ATTR(update_fw, S_IWUSR, NULL, cyapa_update_fw_store); |
1222 | static DEVICE_ATTR(baseline, S_IRUGO, cyapa_show_baseline, NULL); |
1223 | static DEVICE_ATTR(calibrate, S_IWUSR, NULL, cyapa_calibrate_store); |
1224 | static DEVICE_ATTR(mode, S_IRUGO, cyapa_show_mode, NULL); |
1225 | |
1226 | static struct attribute *cyapa_sysfs_entries[] = { |
1227 | &dev_attr_firmware_version.attr, |
1228 | &dev_attr_product_id.attr, |
1229 | &dev_attr_update_fw.attr, |
1230 | &dev_attr_baseline.attr, |
1231 | &dev_attr_calibrate.attr, |
1232 | &dev_attr_mode.attr, |
1233 | NULL, |
1234 | }; |
1235 | |
1236 | static const struct attribute_group cyapa_sysfs_group = { |
1237 | .attrs = cyapa_sysfs_entries, |
1238 | }; |
1239 | |
1240 | static void cyapa_disable_regulator(void *data) |
1241 | { |
1242 | struct cyapa *cyapa = data; |
1243 | |
1244 | regulator_disable(regulator: cyapa->vcc); |
1245 | } |
1246 | |
1247 | static int cyapa_probe(struct i2c_client *client) |
1248 | { |
1249 | struct device *dev = &client->dev; |
1250 | struct cyapa *cyapa; |
1251 | u8 adapter_func; |
1252 | union i2c_smbus_data dummy; |
1253 | int error; |
1254 | |
1255 | adapter_func = cyapa_check_adapter_functionality(client); |
1256 | if (adapter_func == CYAPA_ADAPTER_FUNC_NONE) { |
1257 | dev_err(dev, "not a supported I2C/SMBus adapter\n" ); |
1258 | return -EIO; |
1259 | } |
1260 | |
1261 | /* Make sure there is something at this address */ |
1262 | if (i2c_smbus_xfer(adapter: client->adapter, addr: client->addr, flags: 0, |
1263 | I2C_SMBUS_READ, command: 0, I2C_SMBUS_BYTE, data: &dummy) < 0) |
1264 | return -ENODEV; |
1265 | |
1266 | cyapa = devm_kzalloc(dev, size: sizeof(struct cyapa), GFP_KERNEL); |
1267 | if (!cyapa) |
1268 | return -ENOMEM; |
1269 | |
1270 | /* i2c isn't supported, use smbus */ |
1271 | if (adapter_func == CYAPA_ADAPTER_FUNC_SMBUS) |
1272 | cyapa->smbus = true; |
1273 | |
1274 | cyapa->client = client; |
1275 | i2c_set_clientdata(client, data: cyapa); |
1276 | sprintf(buf: cyapa->phys, fmt: "i2c-%d-%04x/input0" , client->adapter->nr, |
1277 | client->addr); |
1278 | |
1279 | cyapa->vcc = devm_regulator_get(dev, id: "vcc" ); |
1280 | if (IS_ERR(ptr: cyapa->vcc)) { |
1281 | error = PTR_ERR(ptr: cyapa->vcc); |
1282 | dev_err(dev, "failed to get vcc regulator: %d\n" , error); |
1283 | return error; |
1284 | } |
1285 | |
1286 | error = regulator_enable(regulator: cyapa->vcc); |
1287 | if (error) { |
1288 | dev_err(dev, "failed to enable regulator: %d\n" , error); |
1289 | return error; |
1290 | } |
1291 | |
1292 | error = devm_add_action_or_reset(dev, cyapa_disable_regulator, cyapa); |
1293 | if (error) { |
1294 | dev_err(dev, "failed to add disable regulator action: %d\n" , |
1295 | error); |
1296 | return error; |
1297 | } |
1298 | |
1299 | error = cyapa_initialize(cyapa); |
1300 | if (error) { |
1301 | dev_err(dev, "failed to detect and initialize tp device.\n" ); |
1302 | return error; |
1303 | } |
1304 | |
1305 | error = devm_device_add_group(dev, grp: &cyapa_sysfs_group); |
1306 | if (error) { |
1307 | dev_err(dev, "failed to create sysfs entries: %d\n" , error); |
1308 | return error; |
1309 | } |
1310 | |
1311 | error = cyapa_prepare_wakeup_controls(cyapa); |
1312 | if (error) { |
1313 | dev_err(dev, "failed to prepare wakeup controls: %d\n" , error); |
1314 | return error; |
1315 | } |
1316 | |
1317 | error = cyapa_start_runtime(cyapa); |
1318 | if (error) { |
1319 | dev_err(dev, "failed to start pm_runtime: %d\n" , error); |
1320 | return error; |
1321 | } |
1322 | |
1323 | error = devm_request_threaded_irq(dev, irq: client->irq, |
1324 | NULL, thread_fn: cyapa_irq, |
1325 | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
1326 | devname: "cyapa" , dev_id: cyapa); |
1327 | if (error) { |
1328 | dev_err(dev, "failed to request threaded irq: %d\n" , error); |
1329 | return error; |
1330 | } |
1331 | |
1332 | /* Disable IRQ until the device is opened */ |
1333 | disable_irq(irq: client->irq); |
1334 | |
1335 | /* |
1336 | * Register the device in the input subsystem when it's operational. |
1337 | * Otherwise, keep in this driver, so it can be be recovered or updated |
1338 | * through the sysfs mode and update_fw interfaces by user or apps. |
1339 | */ |
1340 | if (cyapa->operational) { |
1341 | error = cyapa_create_input_dev(cyapa); |
1342 | if (error) { |
1343 | dev_err(dev, "create input_dev instance failed: %d\n" , |
1344 | error); |
1345 | return error; |
1346 | } |
1347 | } |
1348 | |
1349 | return 0; |
1350 | } |
1351 | |
1352 | static int cyapa_suspend(struct device *dev) |
1353 | { |
1354 | struct i2c_client *client = to_i2c_client(dev); |
1355 | struct cyapa *cyapa = i2c_get_clientdata(client); |
1356 | u8 power_mode; |
1357 | int error; |
1358 | |
1359 | error = mutex_lock_interruptible(&cyapa->state_sync_lock); |
1360 | if (error) |
1361 | return error; |
1362 | |
1363 | /* |
1364 | * Runtime PM is enable only when device is in operational mode and |
1365 | * users in use, so need check it before disable it to |
1366 | * avoid unbalance warning. |
1367 | */ |
1368 | if (pm_runtime_enabled(dev)) |
1369 | pm_runtime_disable(dev); |
1370 | disable_irq(irq: client->irq); |
1371 | |
1372 | /* |
1373 | * Set trackpad device to idle mode if wakeup is allowed, |
1374 | * otherwise turn off. |
1375 | */ |
1376 | if (cyapa->operational) { |
1377 | power_mode = device_may_wakeup(dev) ? cyapa->suspend_power_mode |
1378 | : PWR_MODE_OFF; |
1379 | error = cyapa->ops->set_power_mode(cyapa, power_mode, |
1380 | cyapa->suspend_sleep_time, CYAPA_PM_SUSPEND); |
1381 | if (error) |
1382 | dev_err(dev, "suspend set power mode failed: %d\n" , |
1383 | error); |
1384 | } |
1385 | |
1386 | /* |
1387 | * Disable proximity interrupt when system idle, want true touch to |
1388 | * wake the system. |
1389 | */ |
1390 | if (cyapa->dev_pwr_mode != PWR_MODE_OFF) |
1391 | cyapa->ops->set_proximity(cyapa, false); |
1392 | |
1393 | if (device_may_wakeup(dev)) |
1394 | cyapa->irq_wake = (enable_irq_wake(irq: client->irq) == 0); |
1395 | |
1396 | mutex_unlock(lock: &cyapa->state_sync_lock); |
1397 | return 0; |
1398 | } |
1399 | |
1400 | static int cyapa_resume(struct device *dev) |
1401 | { |
1402 | struct i2c_client *client = to_i2c_client(dev); |
1403 | struct cyapa *cyapa = i2c_get_clientdata(client); |
1404 | int error; |
1405 | |
1406 | mutex_lock(&cyapa->state_sync_lock); |
1407 | |
1408 | if (device_may_wakeup(dev) && cyapa->irq_wake) { |
1409 | disable_irq_wake(irq: client->irq); |
1410 | cyapa->irq_wake = false; |
1411 | } |
1412 | |
1413 | /* |
1414 | * Update device states and runtime PM states. |
1415 | * Re-Enable proximity interrupt after enter operational mode. |
1416 | */ |
1417 | error = cyapa_reinitialize(cyapa); |
1418 | if (error) |
1419 | dev_warn(dev, "failed to reinitialize TP device: %d\n" , error); |
1420 | |
1421 | enable_irq(irq: client->irq); |
1422 | |
1423 | mutex_unlock(lock: &cyapa->state_sync_lock); |
1424 | return 0; |
1425 | } |
1426 | |
1427 | static int cyapa_runtime_suspend(struct device *dev) |
1428 | { |
1429 | struct cyapa *cyapa = dev_get_drvdata(dev); |
1430 | int error; |
1431 | |
1432 | error = cyapa->ops->set_power_mode(cyapa, |
1433 | cyapa->runtime_suspend_power_mode, |
1434 | cyapa->runtime_suspend_sleep_time, |
1435 | CYAPA_PM_RUNTIME_SUSPEND); |
1436 | if (error) |
1437 | dev_warn(dev, "runtime suspend failed: %d\n" , error); |
1438 | |
1439 | return 0; |
1440 | } |
1441 | |
1442 | static int cyapa_runtime_resume(struct device *dev) |
1443 | { |
1444 | struct cyapa *cyapa = dev_get_drvdata(dev); |
1445 | int error; |
1446 | |
1447 | error = cyapa->ops->set_power_mode(cyapa, |
1448 | PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_RUNTIME_RESUME); |
1449 | if (error) |
1450 | dev_warn(dev, "runtime resume failed: %d\n" , error); |
1451 | |
1452 | return 0; |
1453 | } |
1454 | |
1455 | static const struct dev_pm_ops cyapa_pm_ops = { |
1456 | SYSTEM_SLEEP_PM_OPS(cyapa_suspend, cyapa_resume) |
1457 | RUNTIME_PM_OPS(cyapa_runtime_suspend, cyapa_runtime_resume, NULL) |
1458 | }; |
1459 | |
1460 | static const struct i2c_device_id cyapa_id_table[] = { |
1461 | { "cyapa" , 0 }, |
1462 | { }, |
1463 | }; |
1464 | MODULE_DEVICE_TABLE(i2c, cyapa_id_table); |
1465 | |
1466 | #ifdef CONFIG_ACPI |
1467 | static const struct acpi_device_id cyapa_acpi_id[] = { |
1468 | { "CYAP0000" , 0 }, /* Gen3 trackpad with 0x67 I2C address. */ |
1469 | { "CYAP0001" , 0 }, /* Gen5 trackpad with 0x24 I2C address. */ |
1470 | { "CYAP0002" , 0 }, /* Gen6 trackpad with 0x24 I2C address. */ |
1471 | { } |
1472 | }; |
1473 | MODULE_DEVICE_TABLE(acpi, cyapa_acpi_id); |
1474 | #endif |
1475 | |
1476 | #ifdef CONFIG_OF |
1477 | static const struct of_device_id cyapa_of_match[] = { |
1478 | { .compatible = "cypress,cyapa" }, |
1479 | { /* sentinel */ } |
1480 | }; |
1481 | MODULE_DEVICE_TABLE(of, cyapa_of_match); |
1482 | #endif |
1483 | |
1484 | static struct i2c_driver cyapa_driver = { |
1485 | .driver = { |
1486 | .name = "cyapa" , |
1487 | .pm = pm_ptr(&cyapa_pm_ops), |
1488 | .acpi_match_table = ACPI_PTR(cyapa_acpi_id), |
1489 | .of_match_table = of_match_ptr(cyapa_of_match), |
1490 | }, |
1491 | |
1492 | .probe = cyapa_probe, |
1493 | .id_table = cyapa_id_table, |
1494 | }; |
1495 | |
1496 | module_i2c_driver(cyapa_driver); |
1497 | |
1498 | MODULE_DESCRIPTION("Cypress APA I2C Trackpad Driver" ); |
1499 | MODULE_AUTHOR("Dudley Du <dudl@cypress.com>" ); |
1500 | MODULE_LICENSE("GPL" ); |
1501 | |