projects/linux·blob master · refs

1499 lines · 36.9 KiB

1/*
2 * Cypress APA trackpad with I2C interface
3 *
4 * Author: Dudley Du <[email protected]>
5 * Further cleanup and restructuring by:
6 * Daniel Kurtz <[email protected]>
7 * Benson Leung <[email protected]>
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
40const char product_id[] = "CYTRA";
41
42static int cyapa_reinitialize(struct cyapa *cyapa);
43
44bool 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
55bool 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
66static 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
79static 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. */
91static 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 = &reg,
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(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 */
128static 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, len + 1);
142 if (ret != len + 1)
143 return ret < 0 ? ret : -EIO;
144
145 return 0;
146}
147
148static u8 cyapa_check_adapter_functionality(struct i2c_client *client)
149{
150 u8 ret = CYAPA_ADAPTER_FUNC_NONE;
151
152 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
153 ret |= CYAPA_ADAPTER_FUNC_I2C;
154 if (i2c_check_functionality(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 */
164static 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 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, 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 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, 0, 2, cmd);
241 if (error)
242 goto error;
243
244 msleep(50);
245
246 error = cyapa_i2c_read(cyapa, BL_HEAD_OFFSET,
247 BL_STATUS_SIZE, status);
248 if (error)
249 goto error;
250 }
251 } while (--retries > 0 && !smbus);
252
253 goto error;
254
255out_detected:
256 if (cyapa->state <= CYAPA_STATE_BL_BUSY)
257 return -EAGAIN;
258 return 0;
259
260error:
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 */
279int 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(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 */
311static int cyapa_check_is_operational(struct cyapa *cyapa)
312{
313 int error;
314
315 error = cyapa_poll_state(cyapa, 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 */
348static 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
368static int cyapa_open(struct input_dev *input)
369{
370 struct cyapa *cyapa = input_get_drvdata(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(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_put_sync_autosuspend(dev);
407out:
408 mutex_unlock(&cyapa->state_sync_lock);
409 return error;
410}
411
412static void cyapa_close(struct input_dev *input)
413{
414 struct cyapa *cyapa = input_get_drvdata(input);
415 struct i2c_client *client = cyapa->client;
416 struct device *dev = &cyapa->client->dev;
417
418 mutex_lock(&cyapa->state_sync_lock);
419
420 disable_irq(client->irq);
421 if (pm_runtime_enabled(dev))
422 pm_runtime_disable(dev);
423 pm_runtime_set_suspended(dev);
424
425 if (cyapa->operational)
426 cyapa->ops->set_power_mode(cyapa,
427 PWR_MODE_OFF, 0, CYAPA_PM_DEACTIVE);
428
429 mutex_unlock(&cyapa->state_sync_lock);
430}
431
432static int cyapa_create_input_dev(struct cyapa *cyapa)
433{
434 struct device *dev = &cyapa->client->dev;
435 struct input_dev *input;
436 int error;
437
438 if (!cyapa->physical_size_x || !cyapa->physical_size_y)
439 return -EINVAL;
440
441 input = devm_input_allocate_device(dev);
442 if (!input) {
443 dev_err(dev, "failed to allocate memory for input device.\n");
444 return -ENOMEM;
445 }
446
447 input->name = CYAPA_NAME;
448 input->phys = cyapa->phys;
449 input->id.bustype = BUS_I2C;
450 input->id.version = 1;
451 input->id.product = 0; /* Means any product in eventcomm. */
452 input->dev.parent = &cyapa->client->dev;
453
454 input->open = cyapa_open;
455 input->close = cyapa_close;
456
457 input_set_drvdata(input, cyapa);
458
459 __set_bit(EV_ABS, input->evbit);
460
461 /* Finger position */
462 input_set_abs_params(input, ABS_MT_POSITION_X, 0, cyapa->max_abs_x, 0,
463 0);
464 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, cyapa->max_abs_y, 0,
465 0);
466 input_set_abs_params(input, ABS_MT_PRESSURE, 0, cyapa->max_z, 0, 0);
467 if (cyapa->gen > CYAPA_GEN3) {
468 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
469 input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
470 /*
471 * Orientation is the angle between the vertical axis and
472 * the major axis of the contact ellipse.
473 * The range is -127 to 127.
474 * the positive direction is clockwise form the vertical axis.
475 * If the ellipse of contact degenerates into a circle,
476 * orientation is reported as 0.
477 *
478 * Also, for Gen5 trackpad the accurate of this orientation
479 * value is value + (-30 ~ 30).
480 */
481 input_set_abs_params(input, ABS_MT_ORIENTATION,
482 -127, 127, 0, 0);
483 }
484 if (cyapa->gen >= CYAPA_GEN5) {
485 input_set_abs_params(input, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
486 input_set_abs_params(input, ABS_MT_WIDTH_MINOR, 0, 255, 0, 0);
487 input_set_abs_params(input, ABS_DISTANCE, 0, 1, 0, 0);
488 }
489
490 input_abs_set_res(input, ABS_MT_POSITION_X,
491 cyapa->max_abs_x / cyapa->physical_size_x);
492 input_abs_set_res(input, ABS_MT_POSITION_Y,
493 cyapa->max_abs_y / cyapa->physical_size_y);
494
495 if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK)
496 __set_bit(BTN_LEFT, input->keybit);
497 if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK)
498 __set_bit(BTN_MIDDLE, input->keybit);
499 if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK)
500 __set_bit(BTN_RIGHT, input->keybit);
501
502 if (cyapa->btn_capability == CAPABILITY_LEFT_BTN_MASK)
503 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
504
505 /* Handle pointer emulation and unused slots in core */
506 error = input_mt_init_slots(input, CYAPA_MAX_MT_SLOTS,
507 INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED);
508 if (error) {
509 dev_err(dev, "failed to initialize MT slots: %d\n", error);
510 return error;
511 }
512
513 /* Register the device in input subsystem */
514 error = input_register_device(input);
515 if (error) {
516 dev_err(dev, "failed to register input device: %d\n", error);
517 return error;
518 }
519
520 cyapa->input = input;
521 return 0;
522}
523
524static void cyapa_enable_irq_for_cmd(struct cyapa *cyapa)
525{
526 struct input_dev *input = cyapa->input;
527
528 if (!input || !input_device_enabled(input)) {
529 /*
530 * When input is NULL, TP must be in deep sleep mode.
531 * In this mode, later non-power I2C command will always failed
532 * if not bring it out of deep sleep mode firstly,
533 * so must command TP to active mode here.
534 */
535 if (!input || cyapa->operational)
536 cyapa->ops->set_power_mode(cyapa,
537 PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_ACTIVE);
538 /* Gen3 always using polling mode for command. */
539 if (cyapa->gen >= CYAPA_GEN5)
540 enable_irq(cyapa->client->irq);
541 }
542}
543
544static void cyapa_disable_irq_for_cmd(struct cyapa *cyapa)
545{
546 struct input_dev *input = cyapa->input;
547
548 if (!input || !input_device_enabled(input)) {
549 if (cyapa->gen >= CYAPA_GEN5)
550 disable_irq(cyapa->client->irq);
551 if (!input || cyapa->operational)
552 cyapa->ops->set_power_mode(cyapa,
553 PWR_MODE_OFF, 0, CYAPA_PM_ACTIVE);
554 }
555}
556
557/*
558 * cyapa_sleep_time_to_pwr_cmd and cyapa_pwr_cmd_to_sleep_time
559 *
560 * These are helper functions that convert to and from integer idle
561 * times and register settings to write to the PowerMode register.
562 * The trackpad supports between 20ms to 1000ms scan intervals.
563 * The time will be increased in increments of 10ms from 20ms to 100ms.
564 * From 100ms to 1000ms, time will be increased in increments of 20ms.
565 *
566 * When Idle_Time < 100, the format to convert Idle_Time to Idle_Command is:
567 * Idle_Command = Idle Time / 10;
568 * When Idle_Time >= 100, the format to convert Idle_Time to Idle_Command is:
569 * Idle_Command = Idle Time / 20 + 5;
570 */
571u8 cyapa_sleep_time_to_pwr_cmd(u16 sleep_time)
572{
573 u16 encoded_time;
574
575 sleep_time = clamp_val(sleep_time, 20, 1000);
576 encoded_time = sleep_time < 100 ? sleep_time / 10 : sleep_time / 20 + 5;
577 return (encoded_time << 2) & PWR_MODE_MASK;
578}
579
580u16 cyapa_pwr_cmd_to_sleep_time(u8 pwr_mode)
581{
582 u8 encoded_time = pwr_mode >> 2;
583
584 return (encoded_time < 10) ? encoded_time * 10
585 : (encoded_time - 5) * 20;
586}
587
588/* 0 on driver initialize and detected successfully, negative on failure. */
589static int cyapa_initialize(struct cyapa *cyapa)
590{
591 int error = 0;
592
593 cyapa->state = CYAPA_STATE_NO_DEVICE;
594 cyapa->gen = CYAPA_GEN_UNKNOWN;
595 mutex_init(&cyapa->state_sync_lock);
596
597 /*
598 * Set to hard code default, they will be updated with trackpad set
599 * default values after probe and initialized.
600 */
601 cyapa->suspend_power_mode = PWR_MODE_SLEEP;
602 cyapa->suspend_sleep_time =
603 cyapa_pwr_cmd_to_sleep_time(cyapa->suspend_power_mode);
604
605 /* ops.initialize() is aimed to prepare for module communications. */
606 error = cyapa_gen3_ops.initialize(cyapa);
607 if (!error)
608 error = cyapa_gen5_ops.initialize(cyapa);
609 if (!error)
610 error = cyapa_gen6_ops.initialize(cyapa);
611 if (error)
612 return error;
613
614 error = cyapa_detect(cyapa);
615 if (error)
616 return error;
617
618 /* Power down the device until we need it. */
619 if (cyapa->operational)
620 cyapa->ops->set_power_mode(cyapa,
621 PWR_MODE_OFF, 0, CYAPA_PM_ACTIVE);
622
623 return 0;
624}
625
626static int cyapa_reinitialize(struct cyapa *cyapa)
627{
628 struct device *dev = &cyapa->client->dev;
629 struct input_dev *input = cyapa->input;
630 int error;
631
632 if (pm_runtime_enabled(dev))
633 pm_runtime_disable(dev);
634
635 /* Avoid command failures when TP was in OFF state. */
636 if (cyapa->operational)
637 cyapa->ops->set_power_mode(cyapa,
638 PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_ACTIVE);
639
640 error = cyapa_detect(cyapa);
641 if (error)
642 goto out;
643
644 if (!input && cyapa->operational) {
645 error = cyapa_create_input_dev(cyapa);
646 if (error) {
647 dev_err(dev, "create input_dev instance failed: %d\n",
648 error);
649 goto out;
650 }
651 }
652
653out:
654 if (!input || !input_device_enabled(input)) {
655 /* Reset to power OFF state to save power when no user open. */
656 if (cyapa->operational)
657 cyapa->ops->set_power_mode(cyapa,
658 PWR_MODE_OFF, 0, CYAPA_PM_DEACTIVE);
659 } else if (!error && cyapa->operational) {
660 /*
661 * Make sure only enable runtime PM when device is
662 * in operational mode and input->users > 0.
663 */
664 pm_runtime_set_active(dev);
665 pm_runtime_enable(dev);
666
667 pm_runtime_get_sync(dev);
668 pm_runtime_put_sync_autosuspend(dev);
669 }
670
671 return error;
672}
673
674static irqreturn_t cyapa_irq(int irq, void *dev_id)
675{
676 struct cyapa *cyapa = dev_id;
677 struct device *dev = &cyapa->client->dev;
678 int error;
679
680 if (device_may_wakeup(dev))
681 pm_wakeup_event(dev, 0);
682
683 /* Interrupt event can be caused by host command to trackpad device. */
684 if (cyapa->ops->irq_cmd_handler(cyapa)) {
685 /*
686 * Interrupt event maybe from trackpad device input reporting.
687 */
688 if (!cyapa->input) {
689 /*
690 * Still in probing or in firmware image
691 * updating or reading.
692 */
693 cyapa->ops->sort_empty_output_data(cyapa,
694 NULL, NULL, NULL);
695 goto out;
696 }
697
698 if (cyapa->operational) {
699 error = cyapa->ops->irq_handler(cyapa);
700
701 /*
702 * Apply runtime power management to touch report event
703 * except the events caused by the command responses.
704 * Note:
705 * It will introduce about 20~40 ms additional delay
706 * time in receiving for first valid touch report data.
707 * The time is used to execute device runtime resume
708 * process.
709 */
710 pm_runtime_get_sync(dev);
711 pm_runtime_put_sync_autosuspend(dev);
712 }
713
714 if (!cyapa->operational || error) {
715 if (!mutex_trylock(&cyapa->state_sync_lock)) {
716 cyapa->ops->sort_empty_output_data(cyapa,
717 NULL, NULL, NULL);
718 goto out;
719 }
720 cyapa_reinitialize(cyapa);
721 mutex_unlock(&cyapa->state_sync_lock);
722 }
723 }
724
725out:
726 return IRQ_HANDLED;
727}
728
729/*
730 **************************************************************
731 * sysfs interface
732 **************************************************************
733*/
734#ifdef CONFIG_PM_SLEEP
735static ssize_t cyapa_show_suspend_scanrate(struct device *dev,
736 struct device_attribute *attr,
737 char *buf)
738{
739 struct cyapa *cyapa = dev_get_drvdata(dev);
740 u8 pwr_cmd;
741 u16 sleep_time;
742 int len;
743 int error;
744
745 error = mutex_lock_interruptible(&cyapa->state_sync_lock);
746 if (error)
747 return error;
748
749 pwr_cmd = cyapa->suspend_power_mode;
750 sleep_time = cyapa->suspend_sleep_time;
751
752 mutex_unlock(&cyapa->state_sync_lock);
753
754 switch (pwr_cmd) {
755 case PWR_MODE_BTN_ONLY:
756 len = sysfs_emit(buf, "%s\n", BTN_ONLY_MODE_NAME);
757 break;
758
759 case PWR_MODE_OFF:
760 len = sysfs_emit(buf, "%s\n", OFF_MODE_NAME);
761 break;
762
763 default:
764 len = sysfs_emit(buf, "%u\n",
765 cyapa->gen == CYAPA_GEN3 ?
766 cyapa_pwr_cmd_to_sleep_time(pwr_cmd) :
767 sleep_time);
768 break;
769 }
770
771 return len;
772}
773
774static ssize_t cyapa_update_suspend_scanrate(struct device *dev,
775 struct device_attribute *attr,
776 const char *buf, size_t count)
777{
778 struct cyapa *cyapa = dev_get_drvdata(dev);
779 u16 sleep_time;
780 int error;
781
782 error = mutex_lock_interruptible(&cyapa->state_sync_lock);
783 if (error)
784 return error;
785
786 if (sysfs_streq(buf, BTN_ONLY_MODE_NAME)) {
787 cyapa->suspend_power_mode = PWR_MODE_BTN_ONLY;
788 } else if (sysfs_streq(buf, OFF_MODE_NAME)) {
789 cyapa->suspend_power_mode = PWR_MODE_OFF;
790 } else if (!kstrtou16(buf, 10, &sleep_time)) {
791 cyapa->suspend_sleep_time = min_t(u16, sleep_time, 1000);
792 cyapa->suspend_power_mode =
793 cyapa_sleep_time_to_pwr_cmd(cyapa->suspend_sleep_time);
794 } else {
795 count = -EINVAL;
796 }
797
798 mutex_unlock(&cyapa->state_sync_lock);
799
800 return count;
801}
802
803static DEVICE_ATTR(suspend_scanrate_ms, S_IRUGO|S_IWUSR,
804 cyapa_show_suspend_scanrate,
805 cyapa_update_suspend_scanrate);
806
807static struct attribute *cyapa_power_wakeup_entries[] = {
808 &dev_attr_suspend_scanrate_ms.attr,
809 NULL,
810};
811
812static const struct attribute_group cyapa_power_wakeup_group = {
813 .name = power_group_name,
814 .attrs = cyapa_power_wakeup_entries,
815};
816
817static void cyapa_remove_power_wakeup_group(void *data)
818{
819 struct cyapa *cyapa = data;
820
821 sysfs_unmerge_group(&cyapa->client->dev.kobj,
822 &cyapa_power_wakeup_group);
823}
824
825static int cyapa_prepare_wakeup_controls(struct cyapa *cyapa)
826{
827 struct i2c_client *client = cyapa->client;
828 struct device *dev = &client->dev;
829 int error;
830
831 if (device_can_wakeup(dev)) {
832 error = sysfs_merge_group(&dev->kobj,
833 &cyapa_power_wakeup_group);
834 if (error) {
835 dev_err(dev, "failed to add power wakeup group: %d\n",
836 error);
837 return error;
838 }
839
840 error = devm_add_action_or_reset(dev,
841 cyapa_remove_power_wakeup_group, cyapa);
842 if (error) {
843 dev_err(dev, "failed to add power cleanup action: %d\n",
844 error);
845 return error;
846 }
847 }
848
849 return 0;
850}
851#else
852static inline int cyapa_prepare_wakeup_controls(struct cyapa *cyapa)
853{
854 return 0;
855}
856#endif /* CONFIG_PM_SLEEP */
857
858#ifdef CONFIG_PM
859static ssize_t cyapa_show_rt_suspend_scanrate(struct device *dev,
860 struct device_attribute *attr,
861 char *buf)
862{
863 struct cyapa *cyapa = dev_get_drvdata(dev);
864 u8 pwr_cmd;
865 u16 sleep_time;
866 int error;
867
868 error = mutex_lock_interruptible(&cyapa->state_sync_lock);
869 if (error)
870 return error;
871
872 pwr_cmd = cyapa->runtime_suspend_power_mode;
873 sleep_time = cyapa->runtime_suspend_sleep_time;
874
875 mutex_unlock(&cyapa->state_sync_lock);
876
877 return sysfs_emit(buf, "%u\n",
878 cyapa->gen == CYAPA_GEN3 ?
879 cyapa_pwr_cmd_to_sleep_time(pwr_cmd) :
880 sleep_time);
881}
882
883static ssize_t cyapa_update_rt_suspend_scanrate(struct device *dev,
884 struct device_attribute *attr,
885 const char *buf, size_t count)
886{
887 struct cyapa *cyapa = dev_get_drvdata(dev);
888 u16 time;
889 int error;
890
891 if (buf == NULL || count == 0 || kstrtou16(buf, 10, &time)) {
892 dev_err(dev, "invalid runtime suspend scanrate ms parameter\n");
893 return -EINVAL;
894 }
895
896 /*
897 * When the suspend scanrate is changed, pm_runtime_get to resume
898 * a potentially suspended device, update to the new pwr_cmd
899 * and then pm_runtime_put to suspend into the new power mode.
900 */
901 pm_runtime_get_sync(dev);
902
903 error = mutex_lock_interruptible(&cyapa->state_sync_lock);
904 if (error)
905 return error;
906
907 cyapa->runtime_suspend_sleep_time = min_t(u16, time, 1000);
908 cyapa->runtime_suspend_power_mode =
909 cyapa_sleep_time_to_pwr_cmd(cyapa->runtime_suspend_sleep_time);
910
911 mutex_unlock(&cyapa->state_sync_lock);
912
913 pm_runtime_put_sync_autosuspend(dev);
914
915 return count;
916}
917
918static DEVICE_ATTR(runtime_suspend_scanrate_ms, S_IRUGO|S_IWUSR,
919 cyapa_show_rt_suspend_scanrate,
920 cyapa_update_rt_suspend_scanrate);
921
922static struct attribute *cyapa_power_runtime_entries[] = {
923 &dev_attr_runtime_suspend_scanrate_ms.attr,
924 NULL,
925};
926
927static const struct attribute_group cyapa_power_runtime_group = {
928 .name = power_group_name,
929 .attrs = cyapa_power_runtime_entries,
930};
931
932static void cyapa_remove_power_runtime_group(void *data)
933{
934 struct cyapa *cyapa = data;
935
936 sysfs_unmerge_group(&cyapa->client->dev.kobj,
937 &cyapa_power_runtime_group);
938}
939
940static int cyapa_start_runtime(struct cyapa *cyapa)
941{
942 struct device *dev = &cyapa->client->dev;
943 int error;
944
945 cyapa->runtime_suspend_power_mode = PWR_MODE_IDLE;
946 cyapa->runtime_suspend_sleep_time =
947 cyapa_pwr_cmd_to_sleep_time(cyapa->runtime_suspend_power_mode);
948
949 error = sysfs_merge_group(&dev->kobj, &cyapa_power_runtime_group);
950 if (error) {
951 dev_err(dev,
952 "failed to create power runtime group: %d\n", error);
953 return error;
954 }
955
956 error = devm_add_action_or_reset(dev, cyapa_remove_power_runtime_group,
957 cyapa);
958 if (error) {
959 dev_err(dev,
960 "failed to add power runtime cleanup action: %d\n",
961 error);
962 return error;
963 }
964
965 /* runtime is enabled until device is operational and opened. */
966 pm_runtime_set_suspended(dev);
967 pm_runtime_use_autosuspend(dev);
968 pm_runtime_set_autosuspend_delay(dev, AUTOSUSPEND_DELAY);
969
970 return 0;
971}
972#else
973static inline int cyapa_start_runtime(struct cyapa *cyapa)
974{
975 return 0;
976}
977#endif /* CONFIG_PM */
978
979static ssize_t cyapa_show_fm_ver(struct device *dev,
980 struct device_attribute *attr, char *buf)
981{
982 int error;
983 struct cyapa *cyapa = dev_get_drvdata(dev);
984
985 error = mutex_lock_interruptible(&cyapa->state_sync_lock);
986 if (error)
987 return error;
988 error = sysfs_emit(buf, "%d.%d\n",
989 cyapa->fw_maj_ver, cyapa->fw_min_ver);
990 mutex_unlock(&cyapa->state_sync_lock);
991 return error;
992}
993
994static ssize_t cyapa_show_product_id(struct device *dev,
995 struct device_attribute *attr, char *buf)
996{
997 struct cyapa *cyapa = dev_get_drvdata(dev);
998 int size;
999 int error;
1000
1001 error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1002 if (error)
1003 return error;
1004 size = sysfs_emit(buf, "%s\n", cyapa->product_id);
1005 mutex_unlock(&cyapa->state_sync_lock);
1006 return size;
1007}
1008
1009static int cyapa_firmware(struct cyapa *cyapa, const char *fw_name)
1010{
1011 struct device *dev = &cyapa->client->dev;
1012 const struct firmware *fw;
1013 int error;
1014
1015 error = request_firmware(&fw, fw_name, dev);
1016 if (error) {
1017 dev_err(dev, "Could not load firmware from %s: %d\n",
1018 fw_name, error);
1019 return error;
1020 }
1021
1022 error = cyapa->ops->check_fw(cyapa, fw);
1023 if (error) {
1024 dev_err(dev, "Invalid CYAPA firmware image: %s\n",
1025 fw_name);
1026 goto done;
1027 }
1028
1029 /*
1030 * Resume the potentially suspended device because doing FW
1031 * update on a device not in the FULL mode has a chance to
1032 * fail.
1033 */
1034 pm_runtime_get_sync(dev);
1035
1036 /* Require IRQ support for firmware update commands. */
1037 cyapa_enable_irq_for_cmd(cyapa);
1038
1039 error = cyapa->ops->bl_enter(cyapa);
1040 if (error) {
1041 dev_err(dev, "bl_enter failed, %d\n", error);
1042 goto err_detect;
1043 }
1044
1045 error = cyapa->ops->bl_activate(cyapa);
1046 if (error) {
1047 dev_err(dev, "bl_activate failed, %d\n", error);
1048 goto err_detect;
1049 }
1050
1051 error = cyapa->ops->bl_initiate(cyapa, fw);
1052 if (error) {
1053 dev_err(dev, "bl_initiate failed, %d\n", error);
1054 goto err_detect;
1055 }
1056
1057 error = cyapa->ops->update_fw(cyapa, fw);
1058 if (error) {
1059 dev_err(dev, "update_fw failed, %d\n", error);
1060 goto err_detect;
1061 }
1062
1063err_detect:
1064 cyapa_disable_irq_for_cmd(cyapa);
1065 pm_runtime_put_noidle(dev);
1066
1067done:
1068 release_firmware(fw);
1069 return error;
1070}
1071
1072static ssize_t cyapa_update_fw_store(struct device *dev,
1073 struct device_attribute *attr,
1074 const char *buf, size_t count)
1075{
1076 struct cyapa *cyapa = dev_get_drvdata(dev);
1077 char fw_name[NAME_MAX];
1078 int ret, error;
1079
1080 if (!count || count >= NAME_MAX) {
1081 dev_err(dev, "Bad file name size\n");
1082 return -EINVAL;
1083 }
1084
1085 memcpy(fw_name, buf, count);
1086 if (fw_name[count - 1] == '\n')
1087 fw_name[count - 1] = '\0';
1088 else
1089 fw_name[count] = '\0';
1090
1091 if (cyapa->input) {
1092 /*
1093 * Force the input device to be registered after the firmware
1094 * image is updated, so if the corresponding parameters updated
1095 * in the new firmware image can taken effect immediately.
1096 */
1097 input_unregister_device(cyapa->input);
1098 cyapa->input = NULL;
1099 }
1100
1101 error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1102 if (error) {
1103 /*
1104 * Whatever, do reinitialize to try to recover TP state to
1105 * previous state just as it entered fw update entrance.
1106 */
1107 cyapa_reinitialize(cyapa);
1108 return error;
1109 }
1110
1111 error = cyapa_firmware(cyapa, fw_name);
1112 if (error)
1113 dev_err(dev, "firmware update failed: %d\n", error);
1114 else
1115 dev_dbg(dev, "firmware update successfully done.\n");
1116
1117 /*
1118 * Re-detect trackpad device states because firmware update process
1119 * will reset trackpad device into bootloader mode.
1120 */
1121 ret = cyapa_reinitialize(cyapa);
1122 if (ret) {
1123 dev_err(dev, "failed to re-detect after updated: %d\n", ret);
1124 error = error ? error : ret;
1125 }
1126
1127 mutex_unlock(&cyapa->state_sync_lock);
1128
1129 return error ? error : count;
1130}
1131
1132static ssize_t cyapa_calibrate_store(struct device *dev,
1133 struct device_attribute *attr,
1134 const char *buf, size_t count)
1135{
1136 struct cyapa *cyapa = dev_get_drvdata(dev);
1137 int error;
1138
1139 error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1140 if (error)
1141 return error;
1142
1143 if (cyapa->operational) {
1144 cyapa_enable_irq_for_cmd(cyapa);
1145 error = cyapa->ops->calibrate_store(dev, attr, buf, count);
1146 cyapa_disable_irq_for_cmd(cyapa);
1147 } else {
1148 error = -EBUSY; /* Still running in bootloader mode. */
1149 }
1150
1151 mutex_unlock(&cyapa->state_sync_lock);
1152 return error < 0 ? error : count;
1153}
1154
1155static ssize_t cyapa_show_baseline(struct device *dev,
1156 struct device_attribute *attr, char *buf)
1157{
1158 struct cyapa *cyapa = dev_get_drvdata(dev);
1159 ssize_t error;
1160
1161 error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1162 if (error)
1163 return error;
1164
1165 if (cyapa->operational) {
1166 cyapa_enable_irq_for_cmd(cyapa);
1167 error = cyapa->ops->show_baseline(dev, attr, buf);
1168 cyapa_disable_irq_for_cmd(cyapa);
1169 } else {
1170 error = -EBUSY; /* Still running in bootloader mode. */
1171 }
1172
1173 mutex_unlock(&cyapa->state_sync_lock);
1174 return error;
1175}
1176
1177static char *cyapa_state_to_string(struct cyapa *cyapa)
1178{
1179 switch (cyapa->state) {
1180 case CYAPA_STATE_BL_BUSY:
1181 return "bootloader busy";
1182 case CYAPA_STATE_BL_IDLE:
1183 return "bootloader idle";
1184 case CYAPA_STATE_BL_ACTIVE:
1185 return "bootloader active";
1186 case CYAPA_STATE_GEN5_BL:
1187 case CYAPA_STATE_GEN6_BL:
1188 return "bootloader";
1189 case CYAPA_STATE_OP:
1190 case CYAPA_STATE_GEN5_APP:
1191 case CYAPA_STATE_GEN6_APP:
1192 return "operational"; /* Normal valid state. */
1193 default:
1194 return "invalid mode";
1195 }
1196}
1197
1198static ssize_t cyapa_show_mode(struct device *dev,
1199 struct device_attribute *attr, char *buf)
1200{
1201 struct cyapa *cyapa = dev_get_drvdata(dev);
1202 int size;
1203 int error;
1204
1205 error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1206 if (error)
1207 return error;
1208
1209 size = sysfs_emit(buf, "gen%d %s\n",
1210 cyapa->gen, cyapa_state_to_string(cyapa));
1211
1212 mutex_unlock(&cyapa->state_sync_lock);
1213 return size;
1214}
1215
1216static DEVICE_ATTR(firmware_version, S_IRUGO, cyapa_show_fm_ver, NULL);
1217static DEVICE_ATTR(product_id, S_IRUGO, cyapa_show_product_id, NULL);
1218static DEVICE_ATTR(update_fw, S_IWUSR, NULL, cyapa_update_fw_store);
1219static DEVICE_ATTR(baseline, S_IRUGO, cyapa_show_baseline, NULL);
1220static DEVICE_ATTR(calibrate, S_IWUSR, NULL, cyapa_calibrate_store);
1221static DEVICE_ATTR(mode, S_IRUGO, cyapa_show_mode, NULL);
1222
1223static struct attribute *cyapa_attrs[] = {
1224 &dev_attr_firmware_version.attr,
1225 &dev_attr_product_id.attr,
1226 &dev_attr_update_fw.attr,
1227 &dev_attr_baseline.attr,
1228 &dev_attr_calibrate.attr,
1229 &dev_attr_mode.attr,
1230 NULL,
1231};
1232ATTRIBUTE_GROUPS(cyapa);
1233
1234static void cyapa_disable_regulator(void *data)
1235{
1236 struct cyapa *cyapa = data;
1237
1238 regulator_disable(cyapa->vcc);
1239}
1240
1241static int cyapa_probe(struct i2c_client *client)
1242{
1243 struct device *dev = &client->dev;
1244 struct cyapa *cyapa;
1245 u8 adapter_func;
1246 union i2c_smbus_data dummy;
1247 int error;
1248
1249 adapter_func = cyapa_check_adapter_functionality(client);
1250 if (adapter_func == CYAPA_ADAPTER_FUNC_NONE) {
1251 dev_err(dev, "not a supported I2C/SMBus adapter\n");
1252 return -EIO;
1253 }
1254
1255 /* Make sure there is something at this address */
1256 if (i2c_smbus_xfer(client->adapter, client->addr, 0,
1257 I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &dummy) < 0)
1258 return -ENODEV;
1259
1260 cyapa = devm_kzalloc(dev, sizeof(struct cyapa), GFP_KERNEL);
1261 if (!cyapa)
1262 return -ENOMEM;
1263
1264 /* i2c isn't supported, use smbus */
1265 if (adapter_func == CYAPA_ADAPTER_FUNC_SMBUS)
1266 cyapa->smbus = true;
1267
1268 cyapa->client = client;
1269 i2c_set_clientdata(client, cyapa);
1270 sprintf(cyapa->phys, "i2c-%d-%04x/input0", client->adapter->nr,
1271 client->addr);
1272
1273 cyapa->vcc = devm_regulator_get(dev, "vcc");
1274 if (IS_ERR(cyapa->vcc)) {
1275 error = PTR_ERR(cyapa->vcc);
1276 dev_err(dev, "failed to get vcc regulator: %d\n", error);
1277 return error;
1278 }
1279
1280 error = regulator_enable(cyapa->vcc);
1281 if (error) {
1282 dev_err(dev, "failed to enable regulator: %d\n", error);
1283 return error;
1284 }
1285
1286 error = devm_add_action_or_reset(dev, cyapa_disable_regulator, cyapa);
1287 if (error) {
1288 dev_err(dev, "failed to add disable regulator action: %d\n",
1289 error);
1290 return error;
1291 }
1292
1293 error = cyapa_initialize(cyapa);
1294 if (error) {
1295 dev_err(dev, "failed to detect and initialize tp device.\n");
1296 return error;
1297 }
1298
1299 error = cyapa_prepare_wakeup_controls(cyapa);
1300 if (error) {
1301 dev_err(dev, "failed to prepare wakeup controls: %d\n", error);
1302 return error;
1303 }
1304
1305 error = cyapa_start_runtime(cyapa);
1306 if (error) {
1307 dev_err(dev, "failed to start pm_runtime: %d\n", error);
1308 return error;
1309 }
1310
1311 error = devm_request_threaded_irq(dev, client->irq,
1312 NULL, cyapa_irq,
1313 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1314 "cyapa", cyapa);
1315 if (error) {
1316 dev_err(dev, "failed to request threaded irq: %d\n", error);
1317 return error;
1318 }
1319
1320 /* Disable IRQ until the device is opened */
1321 disable_irq(client->irq);
1322
1323 /*
1324 * Register the device in the input subsystem when it's operational.
1325 * Otherwise, keep in this driver, so it can be be recovered or updated
1326 * through the sysfs mode and update_fw interfaces by user or apps.
1327 */
1328 if (cyapa->operational) {
1329 error = cyapa_create_input_dev(cyapa);
1330 if (error) {
1331 dev_err(dev, "create input_dev instance failed: %d\n",
1332 error);
1333 return error;
1334 }
1335 }
1336
1337 return 0;
1338}
1339
1340static int cyapa_suspend(struct device *dev)
1341{
1342 struct i2c_client *client = to_i2c_client(dev);
1343 struct cyapa *cyapa = i2c_get_clientdata(client);
1344 u8 power_mode;
1345 int error;
1346
1347 error = mutex_lock_interruptible(&cyapa->input->mutex);
1348 if (error)
1349 return error;
1350
1351 error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1352 if (error) {
1353 mutex_unlock(&cyapa->input->mutex);
1354 return error;
1355 }
1356
1357 /*
1358 * Runtime PM is enable only when device is in operational mode and
1359 * users in use, so need check it before disable it to
1360 * avoid unbalance warning.
1361 */
1362 if (pm_runtime_enabled(dev))
1363 pm_runtime_disable(dev);
1364 disable_irq(client->irq);
1365
1366 /*
1367 * Set trackpad device to idle mode if wakeup is allowed,
1368 * otherwise turn off.
1369 */
1370 if (cyapa->operational) {
1371 power_mode = device_may_wakeup(dev) ? cyapa->suspend_power_mode
1372 : PWR_MODE_OFF;
1373 error = cyapa->ops->set_power_mode(cyapa, power_mode,
1374 cyapa->suspend_sleep_time, CYAPA_PM_SUSPEND);
1375 if (error)
1376 dev_err(dev, "suspend set power mode failed: %d\n",
1377 error);
1378 }
1379
1380 /*
1381 * Disable proximity interrupt when system idle, want true touch to
1382 * wake the system.
1383 */
1384 if (cyapa->dev_pwr_mode != PWR_MODE_OFF)
1385 cyapa->ops->set_proximity(cyapa, false);
1386
1387 if (device_may_wakeup(dev))
1388 cyapa->irq_wake = (enable_irq_wake(client->irq) == 0);
1389
1390 mutex_unlock(&cyapa->state_sync_lock);
1391 mutex_unlock(&cyapa->input->mutex);
1392
1393 return 0;
1394}
1395
1396static int cyapa_resume(struct device *dev)
1397{
1398 struct i2c_client *client = to_i2c_client(dev);
1399 struct cyapa *cyapa = i2c_get_clientdata(client);
1400 int error;
1401
1402 mutex_lock(&cyapa->input->mutex);
1403 mutex_lock(&cyapa->state_sync_lock);
1404
1405 if (device_may_wakeup(dev) && cyapa->irq_wake) {
1406 disable_irq_wake(client->irq);
1407 cyapa->irq_wake = false;
1408 }
1409
1410 /*
1411 * Update device states and runtime PM states.
1412 * Re-Enable proximity interrupt after enter operational mode.
1413 */
1414 error = cyapa_reinitialize(cyapa);
1415 if (error)
1416 dev_warn(dev, "failed to reinitialize TP device: %d\n", error);
1417
1418 enable_irq(client->irq);
1419
1420 mutex_unlock(&cyapa->state_sync_lock);
1421 mutex_unlock(&cyapa->input->mutex);
1422 return 0;
1423}
1424
1425static int cyapa_runtime_suspend(struct device *dev)
1426{
1427 struct cyapa *cyapa = dev_get_drvdata(dev);
1428 int error;
1429
1430 error = cyapa->ops->set_power_mode(cyapa,
1431 cyapa->runtime_suspend_power_mode,
1432 cyapa->runtime_suspend_sleep_time,
1433 CYAPA_PM_RUNTIME_SUSPEND);
1434 if (error)
1435 dev_warn(dev, "runtime suspend failed: %d\n", error);
1436
1437 return 0;
1438}
1439
1440static int cyapa_runtime_resume(struct device *dev)
1441{
1442 struct cyapa *cyapa = dev_get_drvdata(dev);
1443 int error;
1444
1445 error = cyapa->ops->set_power_mode(cyapa,
1446 PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_RUNTIME_RESUME);
1447 if (error)
1448 dev_warn(dev, "runtime resume failed: %d\n", error);
1449
1450 return 0;
1451}
1452
1453static const struct dev_pm_ops cyapa_pm_ops = {
1454 SYSTEM_SLEEP_PM_OPS(cyapa_suspend, cyapa_resume)
1455 RUNTIME_PM_OPS(cyapa_runtime_suspend, cyapa_runtime_resume, NULL)
1456};
1457
1458static const struct i2c_device_id cyapa_id_table[] = {
1459 { .name = "cyapa" },
1460 { }
1461};
1462MODULE_DEVICE_TABLE(i2c, cyapa_id_table);
1463
1464#ifdef CONFIG_ACPI
1465static const struct acpi_device_id cyapa_acpi_id[] = {
1466 { "CYAP0000", 0 }, /* Gen3 trackpad with 0x67 I2C address. */
1467 { "CYAP0001", 0 }, /* Gen5 trackpad with 0x24 I2C address. */
1468 { "CYAP0002", 0 }, /* Gen6 trackpad with 0x24 I2C address. */
1469 { }
1470};
1471MODULE_DEVICE_TABLE(acpi, cyapa_acpi_id);
1472#endif
1473
1474#ifdef CONFIG_OF
1475static const struct of_device_id cyapa_of_match[] = {
1476 { .compatible = "cypress,cyapa" },
1477 { /* sentinel */ }
1478};
1479MODULE_DEVICE_TABLE(of, cyapa_of_match);
1480#endif
1481
1482static struct i2c_driver cyapa_driver = {
1483 .driver = {
1484 .name = "cyapa",
1485 .dev_groups = cyapa_groups,
1486 .pm = pm_ptr(&cyapa_pm_ops),
1487 .acpi_match_table = ACPI_PTR(cyapa_acpi_id),
1488 .of_match_table = of_match_ptr(cyapa_of_match),
1489 },
1490
1491 .probe = cyapa_probe,
1492 .id_table = cyapa_id_table,
1493};
1494
1495module_i2c_driver(cyapa_driver);
1496
1497MODULE_DESCRIPTION("Cypress APA I2C Trackpad Driver");
1498MODULE_AUTHOR("Dudley Du <[email protected]>");
1499MODULE_LICENSE("GPL");