Loading...
Note: File does not exist in v3.1.
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-2012 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/slab.h>
24
25/* APA trackpad firmware generation */
26#define CYAPA_GEN3 0x03 /* support MT-protocol B with tracking ID. */
27
28#define CYAPA_NAME "Cypress APA Trackpad (cyapa)"
29
30/* commands for read/write registers of Cypress trackpad */
31#define CYAPA_CMD_SOFT_RESET 0x00
32#define CYAPA_CMD_POWER_MODE 0x01
33#define CYAPA_CMD_DEV_STATUS 0x02
34#define CYAPA_CMD_GROUP_DATA 0x03
35#define CYAPA_CMD_GROUP_CMD 0x04
36#define CYAPA_CMD_GROUP_QUERY 0x05
37#define CYAPA_CMD_BL_STATUS 0x06
38#define CYAPA_CMD_BL_HEAD 0x07
39#define CYAPA_CMD_BL_CMD 0x08
40#define CYAPA_CMD_BL_DATA 0x09
41#define CYAPA_CMD_BL_ALL 0x0a
42#define CYAPA_CMD_BLK_PRODUCT_ID 0x0b
43#define CYAPA_CMD_BLK_HEAD 0x0c
44
45/* report data start reg offset address. */
46#define DATA_REG_START_OFFSET 0x0000
47
48#define BL_HEAD_OFFSET 0x00
49#define BL_DATA_OFFSET 0x10
50
51/*
52 * Operational Device Status Register
53 *
54 * bit 7: Valid interrupt source
55 * bit 6 - 4: Reserved
56 * bit 3 - 2: Power status
57 * bit 1 - 0: Device status
58 */
59#define REG_OP_STATUS 0x00
60#define OP_STATUS_SRC 0x80
61#define OP_STATUS_POWER 0x0c
62#define OP_STATUS_DEV 0x03
63#define OP_STATUS_MASK (OP_STATUS_SRC | OP_STATUS_POWER | OP_STATUS_DEV)
64
65/*
66 * Operational Finger Count/Button Flags Register
67 *
68 * bit 7 - 4: Number of touched finger
69 * bit 3: Valid data
70 * bit 2: Middle Physical Button
71 * bit 1: Right Physical Button
72 * bit 0: Left physical Button
73 */
74#define REG_OP_DATA1 0x01
75#define OP_DATA_VALID 0x08
76#define OP_DATA_MIDDLE_BTN 0x04
77#define OP_DATA_RIGHT_BTN 0x02
78#define OP_DATA_LEFT_BTN 0x01
79#define OP_DATA_BTN_MASK (OP_DATA_MIDDLE_BTN | OP_DATA_RIGHT_BTN | \
80 OP_DATA_LEFT_BTN)
81
82/*
83 * Bootloader Status Register
84 *
85 * bit 7: Busy
86 * bit 6 - 5: Reserved
87 * bit 4: Bootloader running
88 * bit 3 - 1: Reserved
89 * bit 0: Checksum valid
90 */
91#define REG_BL_STATUS 0x01
92#define BL_STATUS_BUSY 0x80
93#define BL_STATUS_RUNNING 0x10
94#define BL_STATUS_DATA_VALID 0x08
95#define BL_STATUS_CSUM_VALID 0x01
96
97/*
98 * Bootloader Error Register
99 *
100 * bit 7: Invalid
101 * bit 6: Invalid security key
102 * bit 5: Bootloading
103 * bit 4: Command checksum
104 * bit 3: Flash protection error
105 * bit 2: Flash checksum error
106 * bit 1 - 0: Reserved
107 */
108#define REG_BL_ERROR 0x02
109#define BL_ERROR_INVALID 0x80
110#define BL_ERROR_INVALID_KEY 0x40
111#define BL_ERROR_BOOTLOADING 0x20
112#define BL_ERROR_CMD_CSUM 0x10
113#define BL_ERROR_FLASH_PROT 0x08
114#define BL_ERROR_FLASH_CSUM 0x04
115
116#define BL_STATUS_SIZE 3 /* length of bootloader status registers */
117#define BLK_HEAD_BYTES 32
118
119#define PRODUCT_ID_SIZE 16
120#define QUERY_DATA_SIZE 27
121#define REG_PROTOCOL_GEN_QUERY_OFFSET 20
122
123#define REG_OFFSET_DATA_BASE 0x0000
124#define REG_OFFSET_COMMAND_BASE 0x0028
125#define REG_OFFSET_QUERY_BASE 0x002a
126
127#define CAPABILITY_LEFT_BTN_MASK (0x01 << 3)
128#define CAPABILITY_RIGHT_BTN_MASK (0x01 << 4)
129#define CAPABILITY_MIDDLE_BTN_MASK (0x01 << 5)
130#define CAPABILITY_BTN_MASK (CAPABILITY_LEFT_BTN_MASK | \
131 CAPABILITY_RIGHT_BTN_MASK | \
132 CAPABILITY_MIDDLE_BTN_MASK)
133
134#define CYAPA_OFFSET_SOFT_RESET REG_OFFSET_COMMAND_BASE
135
136#define REG_OFFSET_POWER_MODE (REG_OFFSET_COMMAND_BASE + 1)
137
138#define PWR_MODE_MASK 0xfc
139#define PWR_MODE_FULL_ACTIVE (0x3f << 2)
140#define PWR_MODE_IDLE (0x05 << 2) /* default sleep time is 50 ms. */
141#define PWR_MODE_OFF (0x00 << 2)
142
143#define PWR_STATUS_MASK 0x0c
144#define PWR_STATUS_ACTIVE (0x03 << 2)
145#define PWR_STATUS_IDLE (0x02 << 2)
146#define PWR_STATUS_OFF (0x00 << 2)
147
148/*
149 * CYAPA trackpad device states.
150 * Used in register 0x00, bit1-0, DeviceStatus field.
151 * Other values indicate device is in an abnormal state and must be reset.
152 */
153#define CYAPA_DEV_NORMAL 0x03
154#define CYAPA_DEV_BUSY 0x01
155
156enum cyapa_state {
157 CYAPA_STATE_OP,
158 CYAPA_STATE_BL_IDLE,
159 CYAPA_STATE_BL_ACTIVE,
160 CYAPA_STATE_BL_BUSY,
161 CYAPA_STATE_NO_DEVICE,
162};
163
164
165struct cyapa_touch {
166 /*
167 * high bits or x/y position value
168 * bit 7 - 4: high 4 bits of x position value
169 * bit 3 - 0: high 4 bits of y position value
170 */
171 u8 xy_hi;
172 u8 x_lo; /* low 8 bits of x position value. */
173 u8 y_lo; /* low 8 bits of y position value. */
174 u8 pressure;
175 /* id range is 1 - 15. It is incremented with every new touch. */
176 u8 id;
177} __packed;
178
179/* The touch.id is used as the MT slot id, thus max MT slot is 15 */
180#define CYAPA_MAX_MT_SLOTS 15
181
182struct cyapa_reg_data {
183 /*
184 * bit 0 - 1: device status
185 * bit 3 - 2: power mode
186 * bit 6 - 4: reserved
187 * bit 7: interrupt valid bit
188 */
189 u8 device_status;
190 /*
191 * bit 7 - 4: number of fingers currently touching pad
192 * bit 3: valid data check bit
193 * bit 2: middle mechanism button state if exists
194 * bit 1: right mechanism button state if exists
195 * bit 0: left mechanism button state if exists
196 */
197 u8 finger_btn;
198 /* CYAPA reports up to 5 touches per packet. */
199 struct cyapa_touch touches[5];
200} __packed;
201
202/* The main device structure */
203struct cyapa {
204 enum cyapa_state state;
205
206 struct i2c_client *client;
207 struct input_dev *input;
208 char phys[32]; /* device physical location */
209 int irq;
210 bool irq_wake; /* irq wake is enabled */
211 bool smbus;
212
213 /* read from query data region. */
214 char product_id[16];
215 u8 btn_capability;
216 u8 gen;
217 int max_abs_x;
218 int max_abs_y;
219 int physical_size_x;
220 int physical_size_y;
221};
222
223static const u8 bl_deactivate[] = { 0x00, 0xff, 0x3b, 0x00, 0x01, 0x02, 0x03,
224 0x04, 0x05, 0x06, 0x07 };
225static const u8 bl_exit[] = { 0x00, 0xff, 0xa5, 0x00, 0x01, 0x02, 0x03, 0x04,
226 0x05, 0x06, 0x07 };
227
228struct cyapa_cmd_len {
229 u8 cmd;
230 u8 len;
231};
232
233#define CYAPA_ADAPTER_FUNC_NONE 0
234#define CYAPA_ADAPTER_FUNC_I2C 1
235#define CYAPA_ADAPTER_FUNC_SMBUS 2
236#define CYAPA_ADAPTER_FUNC_BOTH 3
237
238/*
239 * macros for SMBus communication
240 */
241#define SMBUS_READ 0x01
242#define SMBUS_WRITE 0x00
243#define SMBUS_ENCODE_IDX(cmd, idx) ((cmd) | (((idx) & 0x03) << 1))
244#define SMBUS_ENCODE_RW(cmd, rw) ((cmd) | ((rw) & 0x01))
245#define SMBUS_BYTE_BLOCK_CMD_MASK 0x80
246#define SMBUS_GROUP_BLOCK_CMD_MASK 0x40
247
248 /* for byte read/write command */
249#define CMD_RESET 0
250#define CMD_POWER_MODE 1
251#define CMD_DEV_STATUS 2
252#define SMBUS_BYTE_CMD(cmd) (((cmd) & 0x3f) << 1)
253#define CYAPA_SMBUS_RESET SMBUS_BYTE_CMD(CMD_RESET)
254#define CYAPA_SMBUS_POWER_MODE SMBUS_BYTE_CMD(CMD_POWER_MODE)
255#define CYAPA_SMBUS_DEV_STATUS SMBUS_BYTE_CMD(CMD_DEV_STATUS)
256
257 /* for group registers read/write command */
258#define REG_GROUP_DATA 0
259#define REG_GROUP_CMD 2
260#define REG_GROUP_QUERY 3
261#define SMBUS_GROUP_CMD(grp) (0x80 | (((grp) & 0x07) << 3))
262#define CYAPA_SMBUS_GROUP_DATA SMBUS_GROUP_CMD(REG_GROUP_DATA)
263#define CYAPA_SMBUS_GROUP_CMD SMBUS_GROUP_CMD(REG_GROUP_CMD)
264#define CYAPA_SMBUS_GROUP_QUERY SMBUS_GROUP_CMD(REG_GROUP_QUERY)
265
266 /* for register block read/write command */
267#define CMD_BL_STATUS 0
268#define CMD_BL_HEAD 1
269#define CMD_BL_CMD 2
270#define CMD_BL_DATA 3
271#define CMD_BL_ALL 4
272#define CMD_BLK_PRODUCT_ID 5
273#define CMD_BLK_HEAD 6
274#define SMBUS_BLOCK_CMD(cmd) (0xc0 | (((cmd) & 0x1f) << 1))
275
276/* register block read/write command in bootloader mode */
277#define CYAPA_SMBUS_BL_STATUS SMBUS_BLOCK_CMD(CMD_BL_STATUS)
278#define CYAPA_SMBUS_BL_HEAD SMBUS_BLOCK_CMD(CMD_BL_HEAD)
279#define CYAPA_SMBUS_BL_CMD SMBUS_BLOCK_CMD(CMD_BL_CMD)
280#define CYAPA_SMBUS_BL_DATA SMBUS_BLOCK_CMD(CMD_BL_DATA)
281#define CYAPA_SMBUS_BL_ALL SMBUS_BLOCK_CMD(CMD_BL_ALL)
282
283/* register block read/write command in operational mode */
284#define CYAPA_SMBUS_BLK_PRODUCT_ID SMBUS_BLOCK_CMD(CMD_BLK_PRODUCT_ID)
285#define CYAPA_SMBUS_BLK_HEAD SMBUS_BLOCK_CMD(CMD_BLK_HEAD)
286
287static const struct cyapa_cmd_len cyapa_i2c_cmds[] = {
288 { CYAPA_OFFSET_SOFT_RESET, 1 },
289 { REG_OFFSET_COMMAND_BASE + 1, 1 },
290 { REG_OFFSET_DATA_BASE, 1 },
291 { REG_OFFSET_DATA_BASE, sizeof(struct cyapa_reg_data) },
292 { REG_OFFSET_COMMAND_BASE, 0 },
293 { REG_OFFSET_QUERY_BASE, QUERY_DATA_SIZE },
294 { BL_HEAD_OFFSET, 3 },
295 { BL_HEAD_OFFSET, 16 },
296 { BL_HEAD_OFFSET, 16 },
297 { BL_DATA_OFFSET, 16 },
298 { BL_HEAD_OFFSET, 32 },
299 { REG_OFFSET_QUERY_BASE, PRODUCT_ID_SIZE },
300 { REG_OFFSET_DATA_BASE, 32 }
301};
302
303static const struct cyapa_cmd_len cyapa_smbus_cmds[] = {
304 { CYAPA_SMBUS_RESET, 1 },
305 { CYAPA_SMBUS_POWER_MODE, 1 },
306 { CYAPA_SMBUS_DEV_STATUS, 1 },
307 { CYAPA_SMBUS_GROUP_DATA, sizeof(struct cyapa_reg_data) },
308 { CYAPA_SMBUS_GROUP_CMD, 2 },
309 { CYAPA_SMBUS_GROUP_QUERY, QUERY_DATA_SIZE },
310 { CYAPA_SMBUS_BL_STATUS, 3 },
311 { CYAPA_SMBUS_BL_HEAD, 16 },
312 { CYAPA_SMBUS_BL_CMD, 16 },
313 { CYAPA_SMBUS_BL_DATA, 16 },
314 { CYAPA_SMBUS_BL_ALL, 32 },
315 { CYAPA_SMBUS_BLK_PRODUCT_ID, PRODUCT_ID_SIZE },
316 { CYAPA_SMBUS_BLK_HEAD, 16 },
317};
318
319static ssize_t cyapa_i2c_reg_read_block(struct cyapa *cyapa, u8 reg, size_t len,
320 u8 *values)
321{
322 return i2c_smbus_read_i2c_block_data(cyapa->client, reg, len, values);
323}
324
325static ssize_t cyapa_i2c_reg_write_block(struct cyapa *cyapa, u8 reg,
326 size_t len, const u8 *values)
327{
328 return i2c_smbus_write_i2c_block_data(cyapa->client, reg, len, values);
329}
330
331/*
332 * cyapa_smbus_read_block - perform smbus block read command
333 * @cyapa - private data structure of the driver
334 * @cmd - the properly encoded smbus command
335 * @len - expected length of smbus command result
336 * @values - buffer to store smbus command result
337 *
338 * Returns negative errno, else the number of bytes written.
339 *
340 * Note:
341 * In trackpad device, the memory block allocated for I2C register map
342 * is 256 bytes, so the max read block for I2C bus is 256 bytes.
343 */
344static ssize_t cyapa_smbus_read_block(struct cyapa *cyapa, u8 cmd, size_t len,
345 u8 *values)
346{
347 ssize_t ret;
348 u8 index;
349 u8 smbus_cmd;
350 u8 *buf;
351 struct i2c_client *client = cyapa->client;
352
353 if (!(SMBUS_BYTE_BLOCK_CMD_MASK & cmd))
354 return -EINVAL;
355
356 if (SMBUS_GROUP_BLOCK_CMD_MASK & cmd) {
357 /* read specific block registers command. */
358 smbus_cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ);
359 ret = i2c_smbus_read_block_data(client, smbus_cmd, values);
360 goto out;
361 }
362
363 ret = 0;
364 for (index = 0; index * I2C_SMBUS_BLOCK_MAX < len; index++) {
365 smbus_cmd = SMBUS_ENCODE_IDX(cmd, index);
366 smbus_cmd = SMBUS_ENCODE_RW(smbus_cmd, SMBUS_READ);
367 buf = values + I2C_SMBUS_BLOCK_MAX * index;
368 ret = i2c_smbus_read_block_data(client, smbus_cmd, buf);
369 if (ret < 0)
370 goto out;
371 }
372
373out:
374 return ret > 0 ? len : ret;
375}
376
377static s32 cyapa_read_byte(struct cyapa *cyapa, u8 cmd_idx)
378{
379 u8 cmd;
380
381 if (cyapa->smbus) {
382 cmd = cyapa_smbus_cmds[cmd_idx].cmd;
383 cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ);
384 } else {
385 cmd = cyapa_i2c_cmds[cmd_idx].cmd;
386 }
387 return i2c_smbus_read_byte_data(cyapa->client, cmd);
388}
389
390static s32 cyapa_write_byte(struct cyapa *cyapa, u8 cmd_idx, u8 value)
391{
392 u8 cmd;
393
394 if (cyapa->smbus) {
395 cmd = cyapa_smbus_cmds[cmd_idx].cmd;
396 cmd = SMBUS_ENCODE_RW(cmd, SMBUS_WRITE);
397 } else {
398 cmd = cyapa_i2c_cmds[cmd_idx].cmd;
399 }
400 return i2c_smbus_write_byte_data(cyapa->client, cmd, value);
401}
402
403static ssize_t cyapa_read_block(struct cyapa *cyapa, u8 cmd_idx, u8 *values)
404{
405 u8 cmd;
406 size_t len;
407
408 if (cyapa->smbus) {
409 cmd = cyapa_smbus_cmds[cmd_idx].cmd;
410 len = cyapa_smbus_cmds[cmd_idx].len;
411 return cyapa_smbus_read_block(cyapa, cmd, len, values);
412 } else {
413 cmd = cyapa_i2c_cmds[cmd_idx].cmd;
414 len = cyapa_i2c_cmds[cmd_idx].len;
415 return cyapa_i2c_reg_read_block(cyapa, cmd, len, values);
416 }
417}
418
419/*
420 * Query device for its current operating state.
421 *
422 */
423static int cyapa_get_state(struct cyapa *cyapa)
424{
425 int ret;
426 u8 status[BL_STATUS_SIZE];
427
428 cyapa->state = CYAPA_STATE_NO_DEVICE;
429
430 /*
431 * Get trackpad status by reading 3 registers starting from 0.
432 * If the device is in the bootloader, this will be BL_HEAD.
433 * If the device is in operation mode, this will be the DATA regs.
434 *
435 */
436 ret = cyapa_i2c_reg_read_block(cyapa, BL_HEAD_OFFSET, BL_STATUS_SIZE,
437 status);
438
439 /*
440 * On smbus systems in OP mode, the i2c_reg_read will fail with
441 * -ETIMEDOUT. In this case, try again using the smbus equivalent
442 * command. This should return a BL_HEAD indicating CYAPA_STATE_OP.
443 */
444 if (cyapa->smbus && (ret == -ETIMEDOUT || ret == -ENXIO))
445 ret = cyapa_read_block(cyapa, CYAPA_CMD_BL_STATUS, status);
446
447 if (ret != BL_STATUS_SIZE)
448 goto error;
449
450 if ((status[REG_OP_STATUS] & OP_STATUS_SRC) == OP_STATUS_SRC) {
451 switch (status[REG_OP_STATUS] & OP_STATUS_DEV) {
452 case CYAPA_DEV_NORMAL:
453 case CYAPA_DEV_BUSY:
454 cyapa->state = CYAPA_STATE_OP;
455 break;
456 default:
457 ret = -EAGAIN;
458 goto error;
459 }
460 } else {
461 if (status[REG_BL_STATUS] & BL_STATUS_BUSY)
462 cyapa->state = CYAPA_STATE_BL_BUSY;
463 else if (status[REG_BL_ERROR] & BL_ERROR_BOOTLOADING)
464 cyapa->state = CYAPA_STATE_BL_ACTIVE;
465 else
466 cyapa->state = CYAPA_STATE_BL_IDLE;
467 }
468
469 return 0;
470error:
471 return (ret < 0) ? ret : -EAGAIN;
472}
473
474/*
475 * Poll device for its status in a loop, waiting up to timeout for a response.
476 *
477 * When the device switches state, it usually takes ~300 ms.
478 * However, when running a new firmware image, the device must calibrate its
479 * sensors, which can take as long as 2 seconds.
480 *
481 * Note: The timeout has granularity of the polling rate, which is 100 ms.
482 *
483 * Returns:
484 * 0 when the device eventually responds with a valid non-busy state.
485 * -ETIMEDOUT if device never responds (too many -EAGAIN)
486 * < 0 other errors
487 */
488static int cyapa_poll_state(struct cyapa *cyapa, unsigned int timeout)
489{
490 int ret;
491 int tries = timeout / 100;
492
493 ret = cyapa_get_state(cyapa);
494 while ((ret || cyapa->state >= CYAPA_STATE_BL_BUSY) && tries--) {
495 msleep(100);
496 ret = cyapa_get_state(cyapa);
497 }
498 return (ret == -EAGAIN || ret == -ETIMEDOUT) ? -ETIMEDOUT : ret;
499}
500
501static int cyapa_bl_deactivate(struct cyapa *cyapa)
502{
503 int ret;
504
505 ret = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_deactivate),
506 bl_deactivate);
507 if (ret < 0)
508 return ret;
509
510 /* wait for bootloader to switch to idle state; should take < 100ms */
511 msleep(100);
512 ret = cyapa_poll_state(cyapa, 500);
513 if (ret < 0)
514 return ret;
515 if (cyapa->state != CYAPA_STATE_BL_IDLE)
516 return -EAGAIN;
517 return 0;
518}
519
520/*
521 * Exit bootloader
522 *
523 * Send bl_exit command, then wait 50 - 100 ms to let device transition to
524 * operational mode. If this is the first time the device's firmware is
525 * running, it can take up to 2 seconds to calibrate its sensors. So, poll
526 * the device's new state for up to 2 seconds.
527 *
528 * Returns:
529 * -EIO failure while reading from device
530 * -EAGAIN device is stuck in bootloader, b/c it has invalid firmware
531 * 0 device is supported and in operational mode
532 */
533static int cyapa_bl_exit(struct cyapa *cyapa)
534{
535 int ret;
536
537 ret = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_exit), bl_exit);
538 if (ret < 0)
539 return ret;
540
541 /*
542 * Wait for bootloader to exit, and operation mode to start.
543 * Normally, this takes at least 50 ms.
544 */
545 usleep_range(50000, 100000);
546 /*
547 * In addition, when a device boots for the first time after being
548 * updated to new firmware, it must first calibrate its sensors, which
549 * can take up to an additional 2 seconds.
550 */
551 ret = cyapa_poll_state(cyapa, 2000);
552 if (ret < 0)
553 return ret;
554 if (cyapa->state != CYAPA_STATE_OP)
555 return -EAGAIN;
556
557 return 0;
558}
559
560/*
561 * Set device power mode
562 *
563 */
564static int cyapa_set_power_mode(struct cyapa *cyapa, u8 power_mode)
565{
566 struct device *dev = &cyapa->client->dev;
567 int ret;
568 u8 power;
569
570 if (cyapa->state != CYAPA_STATE_OP)
571 return 0;
572
573 ret = cyapa_read_byte(cyapa, CYAPA_CMD_POWER_MODE);
574 if (ret < 0)
575 return ret;
576
577 power = ret & ~PWR_MODE_MASK;
578 power |= power_mode & PWR_MODE_MASK;
579 ret = cyapa_write_byte(cyapa, CYAPA_CMD_POWER_MODE, power);
580 if (ret < 0)
581 dev_err(dev, "failed to set power_mode 0x%02x err = %d\n",
582 power_mode, ret);
583 return ret;
584}
585
586static int cyapa_get_query_data(struct cyapa *cyapa)
587{
588 u8 query_data[QUERY_DATA_SIZE];
589 int ret;
590
591 if (cyapa->state != CYAPA_STATE_OP)
592 return -EBUSY;
593
594 ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_QUERY, query_data);
595 if (ret < 0)
596 return ret;
597 if (ret != QUERY_DATA_SIZE)
598 return -EIO;
599
600 memcpy(&cyapa->product_id[0], &query_data[0], 5);
601 cyapa->product_id[5] = '-';
602 memcpy(&cyapa->product_id[6], &query_data[5], 6);
603 cyapa->product_id[12] = '-';
604 memcpy(&cyapa->product_id[13], &query_data[11], 2);
605 cyapa->product_id[15] = '\0';
606
607 cyapa->btn_capability = query_data[19] & CAPABILITY_BTN_MASK;
608
609 cyapa->gen = query_data[20] & 0x0f;
610
611 cyapa->max_abs_x = ((query_data[21] & 0xf0) << 4) | query_data[22];
612 cyapa->max_abs_y = ((query_data[21] & 0x0f) << 8) | query_data[23];
613
614 cyapa->physical_size_x =
615 ((query_data[24] & 0xf0) << 4) | query_data[25];
616 cyapa->physical_size_y =
617 ((query_data[24] & 0x0f) << 8) | query_data[26];
618
619 return 0;
620}
621
622/*
623 * Check if device is operational.
624 *
625 * An operational device is responding, has exited bootloader, and has
626 * firmware supported by this driver.
627 *
628 * Returns:
629 * -EBUSY no device or in bootloader
630 * -EIO failure while reading from device
631 * -EAGAIN device is still in bootloader
632 * if ->state = CYAPA_STATE_BL_IDLE, device has invalid firmware
633 * -EINVAL device is in operational mode, but not supported by this driver
634 * 0 device is supported
635 */
636static int cyapa_check_is_operational(struct cyapa *cyapa)
637{
638 struct device *dev = &cyapa->client->dev;
639 static const char unique_str[] = "CYTRA";
640 int ret;
641
642 ret = cyapa_poll_state(cyapa, 2000);
643 if (ret < 0)
644 return ret;
645 switch (cyapa->state) {
646 case CYAPA_STATE_BL_ACTIVE:
647 ret = cyapa_bl_deactivate(cyapa);
648 if (ret)
649 return ret;
650
651 /* Fallthrough state */
652 case CYAPA_STATE_BL_IDLE:
653 ret = cyapa_bl_exit(cyapa);
654 if (ret)
655 return ret;
656
657 /* Fallthrough state */
658 case CYAPA_STATE_OP:
659 ret = cyapa_get_query_data(cyapa);
660 if (ret < 0)
661 return ret;
662
663 /* only support firmware protocol gen3 */
664 if (cyapa->gen != CYAPA_GEN3) {
665 dev_err(dev, "unsupported protocol version (%d)",
666 cyapa->gen);
667 return -EINVAL;
668 }
669
670 /* only support product ID starting with CYTRA */
671 if (memcmp(cyapa->product_id, unique_str,
672 sizeof(unique_str) - 1) != 0) {
673 dev_err(dev, "unsupported product ID (%s)\n",
674 cyapa->product_id);
675 return -EINVAL;
676 }
677 return 0;
678
679 default:
680 return -EIO;
681 }
682 return 0;
683}
684
685static irqreturn_t cyapa_irq(int irq, void *dev_id)
686{
687 struct cyapa *cyapa = dev_id;
688 struct device *dev = &cyapa->client->dev;
689 struct input_dev *input = cyapa->input;
690 struct cyapa_reg_data data;
691 int i;
692 int ret;
693 int num_fingers;
694
695 if (device_may_wakeup(dev))
696 pm_wakeup_event(dev, 0);
697
698 ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_DATA, (u8 *)&data);
699 if (ret != sizeof(data))
700 goto out;
701
702 if ((data.device_status & OP_STATUS_SRC) != OP_STATUS_SRC ||
703 (data.device_status & OP_STATUS_DEV) != CYAPA_DEV_NORMAL ||
704 (data.finger_btn & OP_DATA_VALID) != OP_DATA_VALID) {
705 goto out;
706 }
707
708 num_fingers = (data.finger_btn >> 4) & 0x0f;
709 for (i = 0; i < num_fingers; i++) {
710 const struct cyapa_touch *touch = &data.touches[i];
711 /* Note: touch->id range is 1 to 15; slots are 0 to 14. */
712 int slot = touch->id - 1;
713
714 input_mt_slot(input, slot);
715 input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
716 input_report_abs(input, ABS_MT_POSITION_X,
717 ((touch->xy_hi & 0xf0) << 4) | touch->x_lo);
718 input_report_abs(input, ABS_MT_POSITION_Y,
719 ((touch->xy_hi & 0x0f) << 8) | touch->y_lo);
720 input_report_abs(input, ABS_MT_PRESSURE, touch->pressure);
721 }
722
723 input_mt_sync_frame(input);
724
725 if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK)
726 input_report_key(input, BTN_LEFT,
727 data.finger_btn & OP_DATA_LEFT_BTN);
728
729 if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK)
730 input_report_key(input, BTN_MIDDLE,
731 data.finger_btn & OP_DATA_MIDDLE_BTN);
732
733 if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK)
734 input_report_key(input, BTN_RIGHT,
735 data.finger_btn & OP_DATA_RIGHT_BTN);
736
737 input_sync(input);
738
739out:
740 return IRQ_HANDLED;
741}
742
743static u8 cyapa_check_adapter_functionality(struct i2c_client *client)
744{
745 u8 ret = CYAPA_ADAPTER_FUNC_NONE;
746
747 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
748 ret |= CYAPA_ADAPTER_FUNC_I2C;
749 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
750 I2C_FUNC_SMBUS_BLOCK_DATA |
751 I2C_FUNC_SMBUS_I2C_BLOCK))
752 ret |= CYAPA_ADAPTER_FUNC_SMBUS;
753 return ret;
754}
755
756static int cyapa_create_input_dev(struct cyapa *cyapa)
757{
758 struct device *dev = &cyapa->client->dev;
759 int ret;
760 struct input_dev *input;
761
762 if (!cyapa->physical_size_x || !cyapa->physical_size_y)
763 return -EINVAL;
764
765 input = cyapa->input = input_allocate_device();
766 if (!input) {
767 dev_err(dev, "allocate memory for input device failed\n");
768 return -ENOMEM;
769 }
770
771 input->name = CYAPA_NAME;
772 input->phys = cyapa->phys;
773 input->id.bustype = BUS_I2C;
774 input->id.version = 1;
775 input->id.product = 0; /* means any product in eventcomm. */
776 input->dev.parent = &cyapa->client->dev;
777
778 input_set_drvdata(input, cyapa);
779
780 __set_bit(EV_ABS, input->evbit);
781
782 /* finger position */
783 input_set_abs_params(input, ABS_MT_POSITION_X, 0, cyapa->max_abs_x, 0,
784 0);
785 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, cyapa->max_abs_y, 0,
786 0);
787 input_set_abs_params(input, ABS_MT_PRESSURE, 0, 255, 0, 0);
788
789 input_abs_set_res(input, ABS_MT_POSITION_X,
790 cyapa->max_abs_x / cyapa->physical_size_x);
791 input_abs_set_res(input, ABS_MT_POSITION_Y,
792 cyapa->max_abs_y / cyapa->physical_size_y);
793
794 if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK)
795 __set_bit(BTN_LEFT, input->keybit);
796 if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK)
797 __set_bit(BTN_MIDDLE, input->keybit);
798 if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK)
799 __set_bit(BTN_RIGHT, input->keybit);
800
801 if (cyapa->btn_capability == CAPABILITY_LEFT_BTN_MASK)
802 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
803
804 /* handle pointer emulation and unused slots in core */
805 ret = input_mt_init_slots(input, CYAPA_MAX_MT_SLOTS,
806 INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED);
807 if (ret) {
808 dev_err(dev, "allocate memory for MT slots failed, %d\n", ret);
809 goto err_free_device;
810 }
811
812 /* Register the device in input subsystem */
813 ret = input_register_device(input);
814 if (ret) {
815 dev_err(dev, "input device register failed, %d\n", ret);
816 goto err_free_device;
817 }
818 return 0;
819
820err_free_device:
821 input_free_device(input);
822 cyapa->input = NULL;
823 return ret;
824}
825
826static int cyapa_probe(struct i2c_client *client,
827 const struct i2c_device_id *dev_id)
828{
829 int ret;
830 u8 adapter_func;
831 struct cyapa *cyapa;
832 struct device *dev = &client->dev;
833
834 adapter_func = cyapa_check_adapter_functionality(client);
835 if (adapter_func == CYAPA_ADAPTER_FUNC_NONE) {
836 dev_err(dev, "not a supported I2C/SMBus adapter\n");
837 return -EIO;
838 }
839
840 cyapa = kzalloc(sizeof(struct cyapa), GFP_KERNEL);
841 if (!cyapa) {
842 dev_err(dev, "allocate memory for cyapa failed\n");
843 return -ENOMEM;
844 }
845
846 cyapa->gen = CYAPA_GEN3;
847 cyapa->client = client;
848 i2c_set_clientdata(client, cyapa);
849 sprintf(cyapa->phys, "i2c-%d-%04x/input0", client->adapter->nr,
850 client->addr);
851
852 /* i2c isn't supported, use smbus */
853 if (adapter_func == CYAPA_ADAPTER_FUNC_SMBUS)
854 cyapa->smbus = true;
855 cyapa->state = CYAPA_STATE_NO_DEVICE;
856 ret = cyapa_check_is_operational(cyapa);
857 if (ret) {
858 dev_err(dev, "device not operational, %d\n", ret);
859 goto err_mem_free;
860 }
861
862 ret = cyapa_create_input_dev(cyapa);
863 if (ret) {
864 dev_err(dev, "create input_dev instance failed, %d\n", ret);
865 goto err_mem_free;
866 }
867
868 ret = cyapa_set_power_mode(cyapa, PWR_MODE_FULL_ACTIVE);
869 if (ret) {
870 dev_err(dev, "set active power failed, %d\n", ret);
871 goto err_unregister_device;
872 }
873
874 cyapa->irq = client->irq;
875 ret = request_threaded_irq(cyapa->irq,
876 NULL,
877 cyapa_irq,
878 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
879 "cyapa",
880 cyapa);
881 if (ret) {
882 dev_err(dev, "IRQ request failed: %d\n, ", ret);
883 goto err_unregister_device;
884 }
885
886 return 0;
887
888err_unregister_device:
889 input_unregister_device(cyapa->input);
890err_mem_free:
891 kfree(cyapa);
892
893 return ret;
894}
895
896static int cyapa_remove(struct i2c_client *client)
897{
898 struct cyapa *cyapa = i2c_get_clientdata(client);
899
900 free_irq(cyapa->irq, cyapa);
901 input_unregister_device(cyapa->input);
902 cyapa_set_power_mode(cyapa, PWR_MODE_OFF);
903 kfree(cyapa);
904
905 return 0;
906}
907
908#ifdef CONFIG_PM_SLEEP
909static int cyapa_suspend(struct device *dev)
910{
911 int ret;
912 u8 power_mode;
913 struct cyapa *cyapa = dev_get_drvdata(dev);
914
915 disable_irq(cyapa->irq);
916
917 /*
918 * Set trackpad device to idle mode if wakeup is allowed,
919 * otherwise turn off.
920 */
921 power_mode = device_may_wakeup(dev) ? PWR_MODE_IDLE
922 : PWR_MODE_OFF;
923 ret = cyapa_set_power_mode(cyapa, power_mode);
924 if (ret < 0)
925 dev_err(dev, "set power mode failed, %d\n", ret);
926
927 if (device_may_wakeup(dev))
928 cyapa->irq_wake = (enable_irq_wake(cyapa->irq) == 0);
929 return 0;
930}
931
932static int cyapa_resume(struct device *dev)
933{
934 int ret;
935 struct cyapa *cyapa = dev_get_drvdata(dev);
936
937 if (device_may_wakeup(dev) && cyapa->irq_wake)
938 disable_irq_wake(cyapa->irq);
939
940 ret = cyapa_set_power_mode(cyapa, PWR_MODE_FULL_ACTIVE);
941 if (ret)
942 dev_warn(dev, "resume active power failed, %d\n", ret);
943
944 enable_irq(cyapa->irq);
945 return 0;
946}
947#endif /* CONFIG_PM_SLEEP */
948
949static SIMPLE_DEV_PM_OPS(cyapa_pm_ops, cyapa_suspend, cyapa_resume);
950
951static const struct i2c_device_id cyapa_id_table[] = {
952 { "cyapa", 0 },
953 { },
954};
955MODULE_DEVICE_TABLE(i2c, cyapa_id_table);
956
957static struct i2c_driver cyapa_driver = {
958 .driver = {
959 .name = "cyapa",
960 .owner = THIS_MODULE,
961 .pm = &cyapa_pm_ops,
962 },
963
964 .probe = cyapa_probe,
965 .remove = cyapa_remove,
966 .id_table = cyapa_id_table,
967};
968
969module_i2c_driver(cyapa_driver);
970
971MODULE_DESCRIPTION("Cypress APA I2C Trackpad Driver");
972MODULE_AUTHOR("Dudley Du <dudl@cypress.com>");
973MODULE_LICENSE("GPL");