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 156 enum 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 165 struct 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 182 struct 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 */ 203 struct 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 223 static const u8 bl_deactivate[] = { 0x00, 0xff, 0x3b, 0x00, 0x01, 0x02, 0x03, 224 0x04, 0x05, 0x06, 0x07 }; 225 static const u8 bl_exit[] = { 0x00, 0xff, 0xa5, 0x00, 0x01, 0x02, 0x03, 0x04, 226 0x05, 0x06, 0x07 }; 227 228 struct 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 287 static 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 303 static 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 319 static 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 325 static 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 */ 344 static 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 373 out: 374 return ret > 0 ? len : ret; 375 } 376 377 static 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 390 static 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 403 static 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 */ 423 static 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; 470 error: 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 */ 488 static 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 501 static 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 */ 533 static 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 */ 564 static 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 586 static 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 */ 636 static 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 685 static 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 739 out: 740 return IRQ_HANDLED; 741 } 742 743 static 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 756 static 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 820 err_free_device: 821 input_free_device(input); 822 cyapa->input = NULL; 823 return ret; 824 } 825 826 static 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 888 err_unregister_device: 889 input_unregister_device(cyapa->input); 890 err_mem_free: 891 kfree(cyapa); 892 893 return ret; 894 } 895 896 static 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 909 static 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 932 static 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 949 static SIMPLE_DEV_PM_OPS(cyapa_pm_ops, cyapa_suspend, cyapa_resume); 950 951 static const struct i2c_device_id cyapa_id_table[] = { 952 { "cyapa", 0 }, 953 { }, 954 }; 955 MODULE_DEVICE_TABLE(i2c, cyapa_id_table); 956 957 static 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 969 module_i2c_driver(cyapa_driver); 970 971 MODULE_DESCRIPTION("Cypress APA I2C Trackpad Driver"); 972 MODULE_AUTHOR("Dudley Du <dudl@cypress.com>"); 973 MODULE_LICENSE("GPL"); 974