Commit | Line | Data |
---|---|---|
9f1cd857 DD |
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 | * | |
94897619 | 9 | * Copyright (C) 2011-2015 Cypress Semiconductor, Inc. |
9f1cd857 DD |
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/module.h> | |
22 | #include <linux/slab.h> | |
17a28055 | 23 | #include <asm/unaligned.h> |
9f1cd857 DD |
24 | #include "cyapa.h" |
25 | ||
26 | ||
27 | #define GEN3_MAX_FINGERS 5 | |
28 | #define GEN3_FINGER_NUM(x) (((x) >> 4) & 0x07) | |
29 | ||
30 | #define BLK_HEAD_BYTES 32 | |
31 | ||
32 | /* Macro for register map group offset. */ | |
33 | #define PRODUCT_ID_SIZE 16 | |
34 | #define QUERY_DATA_SIZE 27 | |
35 | #define REG_PROTOCOL_GEN_QUERY_OFFSET 20 | |
36 | ||
37 | #define REG_OFFSET_DATA_BASE 0x0000 | |
38 | #define REG_OFFSET_COMMAND_BASE 0x0028 | |
39 | #define REG_OFFSET_QUERY_BASE 0x002a | |
40 | ||
41 | #define CYAPA_OFFSET_SOFT_RESET REG_OFFSET_COMMAND_BASE | |
42 | #define OP_RECALIBRATION_MASK 0x80 | |
43 | #define OP_REPORT_BASELINE_MASK 0x40 | |
44 | #define REG_OFFSET_MAX_BASELINE 0x0026 | |
45 | #define REG_OFFSET_MIN_BASELINE 0x0027 | |
46 | ||
47 | #define REG_OFFSET_POWER_MODE (REG_OFFSET_COMMAND_BASE + 1) | |
48 | #define SET_POWER_MODE_DELAY 10000 /* Unit: us */ | |
49 | #define SET_POWER_MODE_TRIES 5 | |
50 | ||
51 | #define GEN3_BL_CMD_CHECKSUM_SEED 0xff | |
52 | #define GEN3_BL_CMD_INITIATE_BL 0x38 | |
53 | #define GEN3_BL_CMD_WRITE_BLOCK 0x39 | |
54 | #define GEN3_BL_CMD_VERIFY_BLOCK 0x3a | |
55 | #define GEN3_BL_CMD_TERMINATE_BL 0x3b | |
56 | #define GEN3_BL_CMD_LAUNCH_APP 0xa5 | |
57 | ||
58 | /* | |
59 | * CYAPA trackpad device states. | |
60 | * Used in register 0x00, bit1-0, DeviceStatus field. | |
61 | * Other values indicate device is in an abnormal state and must be reset. | |
62 | */ | |
63 | #define CYAPA_DEV_NORMAL 0x03 | |
64 | #define CYAPA_DEV_BUSY 0x01 | |
65 | ||
66 | #define CYAPA_FW_BLOCK_SIZE 64 | |
67 | #define CYAPA_FW_READ_SIZE 16 | |
68 | #define CYAPA_FW_HDR_START 0x0780 | |
69 | #define CYAPA_FW_HDR_BLOCK_COUNT 2 | |
70 | #define CYAPA_FW_HDR_BLOCK_START (CYAPA_FW_HDR_START / CYAPA_FW_BLOCK_SIZE) | |
71 | #define CYAPA_FW_HDR_SIZE (CYAPA_FW_HDR_BLOCK_COUNT * \ | |
72 | CYAPA_FW_BLOCK_SIZE) | |
73 | #define CYAPA_FW_DATA_START 0x0800 | |
74 | #define CYAPA_FW_DATA_BLOCK_COUNT 480 | |
75 | #define CYAPA_FW_DATA_BLOCK_START (CYAPA_FW_DATA_START / CYAPA_FW_BLOCK_SIZE) | |
76 | #define CYAPA_FW_DATA_SIZE (CYAPA_FW_DATA_BLOCK_COUNT * \ | |
77 | CYAPA_FW_BLOCK_SIZE) | |
78 | #define CYAPA_FW_SIZE (CYAPA_FW_HDR_SIZE + CYAPA_FW_DATA_SIZE) | |
79 | #define CYAPA_CMD_LEN 16 | |
80 | ||
81 | #define GEN3_BL_IDLE_FW_MAJ_VER_OFFSET 0x0b | |
82 | #define GEN3_BL_IDLE_FW_MIN_VER_OFFSET (GEN3_BL_IDLE_FW_MAJ_VER_OFFSET + 1) | |
83 | ||
84 | ||
85 | struct cyapa_touch { | |
86 | /* | |
87 | * high bits or x/y position value | |
88 | * bit 7 - 4: high 4 bits of x position value | |
89 | * bit 3 - 0: high 4 bits of y position value | |
90 | */ | |
91 | u8 xy_hi; | |
92 | u8 x_lo; /* low 8 bits of x position value. */ | |
93 | u8 y_lo; /* low 8 bits of y position value. */ | |
94 | u8 pressure; | |
95 | /* id range is 1 - 15. It is incremented with every new touch. */ | |
96 | u8 id; | |
97 | } __packed; | |
98 | ||
99 | struct cyapa_reg_data { | |
100 | /* | |
101 | * bit 0 - 1: device status | |
102 | * bit 3 - 2: power mode | |
103 | * bit 6 - 4: reserved | |
104 | * bit 7: interrupt valid bit | |
105 | */ | |
106 | u8 device_status; | |
107 | /* | |
108 | * bit 7 - 4: number of fingers currently touching pad | |
109 | * bit 3: valid data check bit | |
110 | * bit 2: middle mechanism button state if exists | |
111 | * bit 1: right mechanism button state if exists | |
112 | * bit 0: left mechanism button state if exists | |
113 | */ | |
114 | u8 finger_btn; | |
115 | /* CYAPA reports up to 5 touches per packet. */ | |
116 | struct cyapa_touch touches[5]; | |
117 | } __packed; | |
118 | ||
87b26d72 DD |
119 | struct gen3_write_block_cmd { |
120 | u8 checksum_seed; /* Always be 0xff */ | |
121 | u8 cmd_code; /* command code: 0x39 */ | |
122 | u8 key[8]; /* 8-byte security key */ | |
123 | __be16 block_num; | |
124 | u8 block_data[CYAPA_FW_BLOCK_SIZE]; | |
125 | u8 block_checksum; /* Calculated using bytes 12 - 75 */ | |
126 | u8 cmd_checksum; /* Calculated using bytes 0-76 */ | |
127 | } __packed; | |
128 | ||
129 | static const u8 security_key[] = { | |
130 | 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 }; | |
9f1cd857 DD |
131 | static const u8 bl_activate[] = { 0x00, 0xff, 0x38, 0x00, 0x01, 0x02, 0x03, |
132 | 0x04, 0x05, 0x06, 0x07 }; | |
133 | static const u8 bl_deactivate[] = { 0x00, 0xff, 0x3b, 0x00, 0x01, 0x02, 0x03, | |
134 | 0x04, 0x05, 0x06, 0x07 }; | |
135 | static const u8 bl_exit[] = { 0x00, 0xff, 0xa5, 0x00, 0x01, 0x02, 0x03, 0x04, | |
136 | 0x05, 0x06, 0x07 }; | |
137 | ||
138 | ||
139 | /* for byte read/write command */ | |
140 | #define CMD_RESET 0 | |
141 | #define CMD_POWER_MODE 1 | |
142 | #define CMD_DEV_STATUS 2 | |
143 | #define CMD_REPORT_MAX_BASELINE 3 | |
144 | #define CMD_REPORT_MIN_BASELINE 4 | |
145 | #define SMBUS_BYTE_CMD(cmd) (((cmd) & 0x3f) << 1) | |
146 | #define CYAPA_SMBUS_RESET SMBUS_BYTE_CMD(CMD_RESET) | |
147 | #define CYAPA_SMBUS_POWER_MODE SMBUS_BYTE_CMD(CMD_POWER_MODE) | |
148 | #define CYAPA_SMBUS_DEV_STATUS SMBUS_BYTE_CMD(CMD_DEV_STATUS) | |
149 | #define CYAPA_SMBUS_MAX_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MAX_BASELINE) | |
150 | #define CYAPA_SMBUS_MIN_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MIN_BASELINE) | |
151 | ||
152 | /* for group registers read/write command */ | |
153 | #define REG_GROUP_DATA 0 | |
154 | #define REG_GROUP_CMD 2 | |
155 | #define REG_GROUP_QUERY 3 | |
156 | #define SMBUS_GROUP_CMD(grp) (0x80 | (((grp) & 0x07) << 3)) | |
157 | #define CYAPA_SMBUS_GROUP_DATA SMBUS_GROUP_CMD(REG_GROUP_DATA) | |
158 | #define CYAPA_SMBUS_GROUP_CMD SMBUS_GROUP_CMD(REG_GROUP_CMD) | |
159 | #define CYAPA_SMBUS_GROUP_QUERY SMBUS_GROUP_CMD(REG_GROUP_QUERY) | |
160 | ||
161 | /* for register block read/write command */ | |
162 | #define CMD_BL_STATUS 0 | |
163 | #define CMD_BL_HEAD 1 | |
164 | #define CMD_BL_CMD 2 | |
165 | #define CMD_BL_DATA 3 | |
166 | #define CMD_BL_ALL 4 | |
167 | #define CMD_BLK_PRODUCT_ID 5 | |
168 | #define CMD_BLK_HEAD 6 | |
169 | #define SMBUS_BLOCK_CMD(cmd) (0xc0 | (((cmd) & 0x1f) << 1)) | |
170 | ||
171 | /* register block read/write command in bootloader mode */ | |
172 | #define CYAPA_SMBUS_BL_STATUS SMBUS_BLOCK_CMD(CMD_BL_STATUS) | |
173 | #define CYAPA_SMBUS_BL_HEAD SMBUS_BLOCK_CMD(CMD_BL_HEAD) | |
174 | #define CYAPA_SMBUS_BL_CMD SMBUS_BLOCK_CMD(CMD_BL_CMD) | |
175 | #define CYAPA_SMBUS_BL_DATA SMBUS_BLOCK_CMD(CMD_BL_DATA) | |
176 | #define CYAPA_SMBUS_BL_ALL SMBUS_BLOCK_CMD(CMD_BL_ALL) | |
177 | ||
178 | /* register block read/write command in operational mode */ | |
179 | #define CYAPA_SMBUS_BLK_PRODUCT_ID SMBUS_BLOCK_CMD(CMD_BLK_PRODUCT_ID) | |
180 | #define CYAPA_SMBUS_BLK_HEAD SMBUS_BLOCK_CMD(CMD_BLK_HEAD) | |
181 | ||
182 | /* for byte read/write command */ | |
183 | #define CMD_RESET 0 | |
184 | #define CMD_POWER_MODE 1 | |
185 | #define CMD_DEV_STATUS 2 | |
186 | #define CMD_REPORT_MAX_BASELINE 3 | |
187 | #define CMD_REPORT_MIN_BASELINE 4 | |
188 | #define SMBUS_BYTE_CMD(cmd) (((cmd) & 0x3f) << 1) | |
189 | #define CYAPA_SMBUS_RESET SMBUS_BYTE_CMD(CMD_RESET) | |
190 | #define CYAPA_SMBUS_POWER_MODE SMBUS_BYTE_CMD(CMD_POWER_MODE) | |
191 | #define CYAPA_SMBUS_DEV_STATUS SMBUS_BYTE_CMD(CMD_DEV_STATUS) | |
192 | #define CYAPA_SMBUS_MAX_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MAX_BASELINE) | |
193 | #define CYAPA_SMBUS_MIN_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MIN_BASELINE) | |
194 | ||
195 | /* for group registers read/write command */ | |
196 | #define REG_GROUP_DATA 0 | |
197 | #define REG_GROUP_CMD 2 | |
198 | #define REG_GROUP_QUERY 3 | |
199 | #define SMBUS_GROUP_CMD(grp) (0x80 | (((grp) & 0x07) << 3)) | |
200 | #define CYAPA_SMBUS_GROUP_DATA SMBUS_GROUP_CMD(REG_GROUP_DATA) | |
201 | #define CYAPA_SMBUS_GROUP_CMD SMBUS_GROUP_CMD(REG_GROUP_CMD) | |
202 | #define CYAPA_SMBUS_GROUP_QUERY SMBUS_GROUP_CMD(REG_GROUP_QUERY) | |
203 | ||
204 | /* for register block read/write command */ | |
205 | #define CMD_BL_STATUS 0 | |
206 | #define CMD_BL_HEAD 1 | |
207 | #define CMD_BL_CMD 2 | |
208 | #define CMD_BL_DATA 3 | |
209 | #define CMD_BL_ALL 4 | |
210 | #define CMD_BLK_PRODUCT_ID 5 | |
211 | #define CMD_BLK_HEAD 6 | |
212 | #define SMBUS_BLOCK_CMD(cmd) (0xc0 | (((cmd) & 0x1f) << 1)) | |
213 | ||
214 | /* register block read/write command in bootloader mode */ | |
215 | #define CYAPA_SMBUS_BL_STATUS SMBUS_BLOCK_CMD(CMD_BL_STATUS) | |
216 | #define CYAPA_SMBUS_BL_HEAD SMBUS_BLOCK_CMD(CMD_BL_HEAD) | |
217 | #define CYAPA_SMBUS_BL_CMD SMBUS_BLOCK_CMD(CMD_BL_CMD) | |
218 | #define CYAPA_SMBUS_BL_DATA SMBUS_BLOCK_CMD(CMD_BL_DATA) | |
219 | #define CYAPA_SMBUS_BL_ALL SMBUS_BLOCK_CMD(CMD_BL_ALL) | |
220 | ||
221 | /* register block read/write command in operational mode */ | |
222 | #define CYAPA_SMBUS_BLK_PRODUCT_ID SMBUS_BLOCK_CMD(CMD_BLK_PRODUCT_ID) | |
223 | #define CYAPA_SMBUS_BLK_HEAD SMBUS_BLOCK_CMD(CMD_BLK_HEAD) | |
224 | ||
225 | struct cyapa_cmd_len { | |
226 | u8 cmd; | |
227 | u8 len; | |
228 | }; | |
229 | ||
230 | /* maps generic CYAPA_CMD_* code to the I2C equivalent */ | |
231 | static const struct cyapa_cmd_len cyapa_i2c_cmds[] = { | |
232 | { CYAPA_OFFSET_SOFT_RESET, 1 }, /* CYAPA_CMD_SOFT_RESET */ | |
233 | { REG_OFFSET_COMMAND_BASE + 1, 1 }, /* CYAPA_CMD_POWER_MODE */ | |
234 | { REG_OFFSET_DATA_BASE, 1 }, /* CYAPA_CMD_DEV_STATUS */ | |
235 | { REG_OFFSET_DATA_BASE, sizeof(struct cyapa_reg_data) }, | |
236 | /* CYAPA_CMD_GROUP_DATA */ | |
237 | { REG_OFFSET_COMMAND_BASE, 0 }, /* CYAPA_CMD_GROUP_CMD */ | |
238 | { REG_OFFSET_QUERY_BASE, QUERY_DATA_SIZE }, /* CYAPA_CMD_GROUP_QUERY */ | |
239 | { BL_HEAD_OFFSET, 3 }, /* CYAPA_CMD_BL_STATUS */ | |
240 | { BL_HEAD_OFFSET, 16 }, /* CYAPA_CMD_BL_HEAD */ | |
241 | { BL_HEAD_OFFSET, 16 }, /* CYAPA_CMD_BL_CMD */ | |
242 | { BL_DATA_OFFSET, 16 }, /* CYAPA_CMD_BL_DATA */ | |
243 | { BL_HEAD_OFFSET, 32 }, /* CYAPA_CMD_BL_ALL */ | |
244 | { REG_OFFSET_QUERY_BASE, PRODUCT_ID_SIZE }, | |
245 | /* CYAPA_CMD_BLK_PRODUCT_ID */ | |
246 | { REG_OFFSET_DATA_BASE, 32 }, /* CYAPA_CMD_BLK_HEAD */ | |
247 | { REG_OFFSET_MAX_BASELINE, 1 }, /* CYAPA_CMD_MAX_BASELINE */ | |
248 | { REG_OFFSET_MIN_BASELINE, 1 }, /* CYAPA_CMD_MIN_BASELINE */ | |
249 | }; | |
250 | ||
251 | static const struct cyapa_cmd_len cyapa_smbus_cmds[] = { | |
252 | { CYAPA_SMBUS_RESET, 1 }, /* CYAPA_CMD_SOFT_RESET */ | |
253 | { CYAPA_SMBUS_POWER_MODE, 1 }, /* CYAPA_CMD_POWER_MODE */ | |
254 | { CYAPA_SMBUS_DEV_STATUS, 1 }, /* CYAPA_CMD_DEV_STATUS */ | |
255 | { CYAPA_SMBUS_GROUP_DATA, sizeof(struct cyapa_reg_data) }, | |
256 | /* CYAPA_CMD_GROUP_DATA */ | |
257 | { CYAPA_SMBUS_GROUP_CMD, 2 }, /* CYAPA_CMD_GROUP_CMD */ | |
258 | { CYAPA_SMBUS_GROUP_QUERY, QUERY_DATA_SIZE }, | |
259 | /* CYAPA_CMD_GROUP_QUERY */ | |
260 | { CYAPA_SMBUS_BL_STATUS, 3 }, /* CYAPA_CMD_BL_STATUS */ | |
261 | { CYAPA_SMBUS_BL_HEAD, 16 }, /* CYAPA_CMD_BL_HEAD */ | |
262 | { CYAPA_SMBUS_BL_CMD, 16 }, /* CYAPA_CMD_BL_CMD */ | |
263 | { CYAPA_SMBUS_BL_DATA, 16 }, /* CYAPA_CMD_BL_DATA */ | |
264 | { CYAPA_SMBUS_BL_ALL, 32 }, /* CYAPA_CMD_BL_ALL */ | |
265 | { CYAPA_SMBUS_BLK_PRODUCT_ID, PRODUCT_ID_SIZE }, | |
266 | /* CYAPA_CMD_BLK_PRODUCT_ID */ | |
267 | { CYAPA_SMBUS_BLK_HEAD, 16 }, /* CYAPA_CMD_BLK_HEAD */ | |
268 | { CYAPA_SMBUS_MAX_BASELINE, 1 }, /* CYAPA_CMD_MAX_BASELINE */ | |
269 | { CYAPA_SMBUS_MIN_BASELINE, 1 }, /* CYAPA_CMD_MIN_BASELINE */ | |
270 | }; | |
271 | ||
3cd47869 | 272 | static int cyapa_gen3_try_poll_handler(struct cyapa *cyapa); |
9f1cd857 DD |
273 | |
274 | /* | |
275 | * cyapa_smbus_read_block - perform smbus block read command | |
276 | * @cyapa - private data structure of the driver | |
277 | * @cmd - the properly encoded smbus command | |
278 | * @len - expected length of smbus command result | |
279 | * @values - buffer to store smbus command result | |
280 | * | |
281 | * Returns negative errno, else the number of bytes written. | |
282 | * | |
283 | * Note: | |
284 | * In trackpad device, the memory block allocated for I2C register map | |
285 | * is 256 bytes, so the max read block for I2C bus is 256 bytes. | |
286 | */ | |
287 | ssize_t cyapa_smbus_read_block(struct cyapa *cyapa, u8 cmd, size_t len, | |
288 | u8 *values) | |
289 | { | |
290 | ssize_t ret; | |
291 | u8 index; | |
292 | u8 smbus_cmd; | |
293 | u8 *buf; | |
294 | struct i2c_client *client = cyapa->client; | |
295 | ||
296 | if (!(SMBUS_BYTE_BLOCK_CMD_MASK & cmd)) | |
297 | return -EINVAL; | |
298 | ||
299 | if (SMBUS_GROUP_BLOCK_CMD_MASK & cmd) { | |
300 | /* read specific block registers command. */ | |
301 | smbus_cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ); | |
302 | ret = i2c_smbus_read_block_data(client, smbus_cmd, values); | |
303 | goto out; | |
304 | } | |
305 | ||
306 | ret = 0; | |
307 | for (index = 0; index * I2C_SMBUS_BLOCK_MAX < len; index++) { | |
308 | smbus_cmd = SMBUS_ENCODE_IDX(cmd, index); | |
309 | smbus_cmd = SMBUS_ENCODE_RW(smbus_cmd, SMBUS_READ); | |
310 | buf = values + I2C_SMBUS_BLOCK_MAX * index; | |
311 | ret = i2c_smbus_read_block_data(client, smbus_cmd, buf); | |
312 | if (ret < 0) | |
313 | goto out; | |
314 | } | |
315 | ||
316 | out: | |
317 | return ret > 0 ? len : ret; | |
318 | } | |
319 | ||
320 | static s32 cyapa_read_byte(struct cyapa *cyapa, u8 cmd_idx) | |
321 | { | |
322 | u8 cmd; | |
323 | ||
324 | if (cyapa->smbus) { | |
325 | cmd = cyapa_smbus_cmds[cmd_idx].cmd; | |
326 | cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ); | |
327 | } else { | |
328 | cmd = cyapa_i2c_cmds[cmd_idx].cmd; | |
329 | } | |
330 | return i2c_smbus_read_byte_data(cyapa->client, cmd); | |
331 | } | |
332 | ||
333 | static s32 cyapa_write_byte(struct cyapa *cyapa, u8 cmd_idx, u8 value) | |
334 | { | |
335 | u8 cmd; | |
336 | ||
337 | if (cyapa->smbus) { | |
338 | cmd = cyapa_smbus_cmds[cmd_idx].cmd; | |
339 | cmd = SMBUS_ENCODE_RW(cmd, SMBUS_WRITE); | |
340 | } else { | |
341 | cmd = cyapa_i2c_cmds[cmd_idx].cmd; | |
342 | } | |
343 | return i2c_smbus_write_byte_data(cyapa->client, cmd, value); | |
344 | } | |
345 | ||
346 | ssize_t cyapa_i2c_reg_read_block(struct cyapa *cyapa, u8 reg, size_t len, | |
347 | u8 *values) | |
348 | { | |
349 | return i2c_smbus_read_i2c_block_data(cyapa->client, reg, len, values); | |
350 | } | |
351 | ||
352 | static ssize_t cyapa_i2c_reg_write_block(struct cyapa *cyapa, u8 reg, | |
353 | size_t len, const u8 *values) | |
354 | { | |
355 | return i2c_smbus_write_i2c_block_data(cyapa->client, reg, len, values); | |
356 | } | |
357 | ||
358 | ssize_t cyapa_read_block(struct cyapa *cyapa, u8 cmd_idx, u8 *values) | |
359 | { | |
360 | u8 cmd; | |
361 | size_t len; | |
362 | ||
363 | if (cyapa->smbus) { | |
364 | cmd = cyapa_smbus_cmds[cmd_idx].cmd; | |
365 | len = cyapa_smbus_cmds[cmd_idx].len; | |
366 | return cyapa_smbus_read_block(cyapa, cmd, len, values); | |
367 | } | |
368 | cmd = cyapa_i2c_cmds[cmd_idx].cmd; | |
369 | len = cyapa_i2c_cmds[cmd_idx].len; | |
370 | return cyapa_i2c_reg_read_block(cyapa, cmd, len, values); | |
371 | } | |
372 | ||
373 | /* | |
374 | * Determine the Gen3 trackpad device's current operating state. | |
375 | * | |
376 | */ | |
377 | static int cyapa_gen3_state_parse(struct cyapa *cyapa, u8 *reg_data, int len) | |
378 | { | |
379 | cyapa->state = CYAPA_STATE_NO_DEVICE; | |
380 | ||
381 | /* Parse based on Gen3 characteristic registers and bits */ | |
382 | if (reg_data[REG_BL_FILE] == BL_FILE && | |
383 | reg_data[REG_BL_ERROR] == BL_ERROR_NO_ERR_IDLE && | |
384 | (reg_data[REG_BL_STATUS] == | |
385 | (BL_STATUS_RUNNING | BL_STATUS_CSUM_VALID) || | |
386 | reg_data[REG_BL_STATUS] == BL_STATUS_RUNNING)) { | |
387 | /* | |
388 | * Normal state after power on or reset, | |
389 | * REG_BL_STATUS == 0x11, firmware image checksum is valid. | |
390 | * REG_BL_STATUS == 0x10, firmware image checksum is invalid. | |
391 | */ | |
392 | cyapa->gen = CYAPA_GEN3; | |
393 | cyapa->state = CYAPA_STATE_BL_IDLE; | |
394 | } else if (reg_data[REG_BL_FILE] == BL_FILE && | |
395 | (reg_data[REG_BL_STATUS] & BL_STATUS_RUNNING) == | |
396 | BL_STATUS_RUNNING) { | |
397 | cyapa->gen = CYAPA_GEN3; | |
398 | if (reg_data[REG_BL_STATUS] & BL_STATUS_BUSY) { | |
399 | cyapa->state = CYAPA_STATE_BL_BUSY; | |
400 | } else { | |
401 | if ((reg_data[REG_BL_ERROR] & BL_ERROR_BOOTLOADING) == | |
402 | BL_ERROR_BOOTLOADING) | |
403 | cyapa->state = CYAPA_STATE_BL_ACTIVE; | |
404 | else | |
405 | cyapa->state = CYAPA_STATE_BL_IDLE; | |
406 | } | |
407 | } else if ((reg_data[REG_OP_STATUS] & OP_STATUS_SRC) && | |
408 | (reg_data[REG_OP_DATA1] & OP_DATA_VALID)) { | |
409 | /* | |
410 | * Normal state when running in operational mode, | |
411 | * may also not in full power state or | |
412 | * busying in command process. | |
413 | */ | |
414 | if (GEN3_FINGER_NUM(reg_data[REG_OP_DATA1]) <= | |
415 | GEN3_MAX_FINGERS) { | |
416 | /* Finger number data is valid. */ | |
417 | cyapa->gen = CYAPA_GEN3; | |
418 | cyapa->state = CYAPA_STATE_OP; | |
419 | } | |
420 | } else if (reg_data[REG_OP_STATUS] == 0x0C && | |
421 | reg_data[REG_OP_DATA1] == 0x08) { | |
422 | /* Op state when first two registers overwritten with 0x00 */ | |
423 | cyapa->gen = CYAPA_GEN3; | |
424 | cyapa->state = CYAPA_STATE_OP; | |
425 | } else if (reg_data[REG_BL_STATUS] & | |
426 | (BL_STATUS_RUNNING | BL_STATUS_BUSY)) { | |
427 | cyapa->gen = CYAPA_GEN3; | |
428 | cyapa->state = CYAPA_STATE_BL_BUSY; | |
429 | } | |
430 | ||
431 | if (cyapa->gen == CYAPA_GEN3 && (cyapa->state == CYAPA_STATE_OP || | |
432 | cyapa->state == CYAPA_STATE_BL_IDLE || | |
433 | cyapa->state == CYAPA_STATE_BL_ACTIVE || | |
434 | cyapa->state == CYAPA_STATE_BL_BUSY)) | |
435 | return 0; | |
436 | ||
437 | return -EAGAIN; | |
438 | } | |
439 | ||
87b26d72 DD |
440 | /* |
441 | * Enter bootloader by soft resetting the device. | |
442 | * | |
443 | * If device is already in the bootloader, the function just returns. | |
444 | * Otherwise, reset the device; after reset, device enters bootloader idle | |
445 | * state immediately. | |
446 | * | |
447 | * Returns: | |
448 | * 0 on success | |
449 | * -EAGAIN device was reset, but is not now in bootloader idle state | |
450 | * < 0 if the device never responds within the timeout | |
451 | */ | |
452 | static int cyapa_gen3_bl_enter(struct cyapa *cyapa) | |
453 | { | |
454 | int error; | |
455 | int waiting_time; | |
456 | ||
457 | error = cyapa_poll_state(cyapa, 500); | |
458 | if (error) | |
459 | return error; | |
460 | if (cyapa->state == CYAPA_STATE_BL_IDLE) { | |
461 | /* Already in BL_IDLE. Skipping reset. */ | |
462 | return 0; | |
463 | } | |
464 | ||
465 | if (cyapa->state != CYAPA_STATE_OP) | |
466 | return -EAGAIN; | |
467 | ||
468 | cyapa->operational = false; | |
469 | cyapa->state = CYAPA_STATE_NO_DEVICE; | |
470 | error = cyapa_write_byte(cyapa, CYAPA_CMD_SOFT_RESET, 0x01); | |
471 | if (error) | |
472 | return -EIO; | |
473 | ||
474 | usleep_range(25000, 50000); | |
475 | waiting_time = 2000; /* For some shipset, max waiting time is 1~2s. */ | |
476 | do { | |
477 | error = cyapa_poll_state(cyapa, 500); | |
478 | if (error) { | |
479 | if (error == -ETIMEDOUT) { | |
480 | waiting_time -= 500; | |
481 | continue; | |
482 | } | |
483 | return error; | |
484 | } | |
485 | ||
486 | if ((cyapa->state == CYAPA_STATE_BL_IDLE) && | |
487 | !(cyapa->status[REG_BL_STATUS] & BL_STATUS_WATCHDOG)) | |
488 | break; | |
489 | ||
490 | msleep(100); | |
491 | waiting_time -= 100; | |
492 | } while (waiting_time > 0); | |
493 | ||
494 | if ((cyapa->state != CYAPA_STATE_BL_IDLE) || | |
495 | (cyapa->status[REG_BL_STATUS] & BL_STATUS_WATCHDOG)) | |
496 | return -EAGAIN; | |
497 | ||
498 | return 0; | |
499 | } | |
500 | ||
501 | static int cyapa_gen3_bl_activate(struct cyapa *cyapa) | |
502 | { | |
503 | int error; | |
504 | ||
505 | error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_activate), | |
506 | bl_activate); | |
507 | if (error) | |
508 | return error; | |
509 | ||
510 | /* Wait for bootloader to activate; takes between 2 and 12 seconds */ | |
511 | msleep(2000); | |
512 | error = cyapa_poll_state(cyapa, 11000); | |
513 | if (error) | |
514 | return error; | |
515 | if (cyapa->state != CYAPA_STATE_BL_ACTIVE) | |
516 | return -EAGAIN; | |
517 | ||
518 | return 0; | |
519 | } | |
520 | ||
9f1cd857 DD |
521 | static int cyapa_gen3_bl_deactivate(struct cyapa *cyapa) |
522 | { | |
523 | int error; | |
524 | ||
525 | error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_deactivate), | |
526 | bl_deactivate); | |
527 | if (error) | |
528 | return error; | |
529 | ||
530 | /* Wait for bootloader to switch to idle state; should take < 100ms */ | |
531 | msleep(100); | |
532 | error = cyapa_poll_state(cyapa, 500); | |
533 | if (error) | |
534 | return error; | |
535 | if (cyapa->state != CYAPA_STATE_BL_IDLE) | |
536 | return -EAGAIN; | |
537 | return 0; | |
538 | } | |
539 | ||
540 | /* | |
541 | * Exit bootloader | |
542 | * | |
543 | * Send bl_exit command, then wait 50 - 100 ms to let device transition to | |
544 | * operational mode. If this is the first time the device's firmware is | |
545 | * running, it can take up to 2 seconds to calibrate its sensors. So, poll | |
546 | * the device's new state for up to 2 seconds. | |
547 | * | |
548 | * Returns: | |
549 | * -EIO failure while reading from device | |
550 | * -EAGAIN device is stuck in bootloader, b/c it has invalid firmware | |
551 | * 0 device is supported and in operational mode | |
552 | */ | |
553 | static int cyapa_gen3_bl_exit(struct cyapa *cyapa) | |
554 | { | |
555 | int error; | |
556 | ||
557 | error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_exit), bl_exit); | |
558 | if (error) | |
559 | return error; | |
560 | ||
561 | /* | |
562 | * Wait for bootloader to exit, and operation mode to start. | |
563 | * Normally, this takes at least 50 ms. | |
564 | */ | |
565 | usleep_range(50000, 100000); | |
566 | /* | |
567 | * In addition, when a device boots for the first time after being | |
568 | * updated to new firmware, it must first calibrate its sensors, which | |
569 | * can take up to an additional 2 seconds. If the device power is | |
570 | * running low, this may take even longer. | |
571 | */ | |
572 | error = cyapa_poll_state(cyapa, 4000); | |
573 | if (error < 0) | |
574 | return error; | |
575 | if (cyapa->state != CYAPA_STATE_OP) | |
576 | return -EAGAIN; | |
577 | ||
578 | return 0; | |
579 | } | |
580 | ||
87b26d72 DD |
581 | static u16 cyapa_gen3_csum(const u8 *buf, size_t count) |
582 | { | |
583 | int i; | |
584 | u16 csum = 0; | |
585 | ||
586 | for (i = 0; i < count; i++) | |
587 | csum += buf[i]; | |
588 | ||
589 | return csum; | |
590 | } | |
591 | ||
592 | /* | |
593 | * Verify the integrity of a CYAPA firmware image file. | |
594 | * | |
595 | * The firmware image file is 30848 bytes, composed of 482 64-byte blocks. | |
596 | * | |
597 | * The first 2 blocks are the firmware header. | |
598 | * The next 480 blocks are the firmware image. | |
599 | * | |
600 | * The first two bytes of the header hold the header checksum, computed by | |
601 | * summing the other 126 bytes of the header. | |
602 | * The last two bytes of the header hold the firmware image checksum, computed | |
603 | * by summing the 30720 bytes of the image modulo 0xffff. | |
604 | * | |
605 | * Both checksums are stored little-endian. | |
606 | */ | |
607 | static int cyapa_gen3_check_fw(struct cyapa *cyapa, const struct firmware *fw) | |
608 | { | |
609 | struct device *dev = &cyapa->client->dev; | |
610 | u16 csum; | |
611 | u16 csum_expected; | |
612 | ||
613 | /* Firmware must match exact 30848 bytes = 482 64-byte blocks. */ | |
614 | if (fw->size != CYAPA_FW_SIZE) { | |
615 | dev_err(dev, "invalid firmware size = %zu, expected %u.\n", | |
616 | fw->size, CYAPA_FW_SIZE); | |
617 | return -EINVAL; | |
618 | } | |
619 | ||
620 | /* Verify header block */ | |
621 | csum_expected = (fw->data[0] << 8) | fw->data[1]; | |
622 | csum = cyapa_gen3_csum(&fw->data[2], CYAPA_FW_HDR_SIZE - 2); | |
623 | if (csum != csum_expected) { | |
624 | dev_err(dev, "%s %04x, expected: %04x\n", | |
625 | "invalid firmware header checksum = ", | |
626 | csum, csum_expected); | |
627 | return -EINVAL; | |
628 | } | |
629 | ||
630 | /* Verify firmware image */ | |
631 | csum_expected = (fw->data[CYAPA_FW_HDR_SIZE - 2] << 8) | | |
632 | fw->data[CYAPA_FW_HDR_SIZE - 1]; | |
633 | csum = cyapa_gen3_csum(&fw->data[CYAPA_FW_HDR_SIZE], | |
634 | CYAPA_FW_DATA_SIZE); | |
635 | if (csum != csum_expected) { | |
636 | dev_err(dev, "%s %04x, expected: %04x\n", | |
637 | "invalid firmware header checksum = ", | |
638 | csum, csum_expected); | |
639 | return -EINVAL; | |
640 | } | |
641 | return 0; | |
642 | } | |
643 | ||
644 | /* | |
645 | * Write a |len| byte long buffer |buf| to the device, by chopping it up into a | |
646 | * sequence of smaller |CYAPA_CMD_LEN|-length write commands. | |
647 | * | |
648 | * The data bytes for a write command are prepended with the 1-byte offset | |
649 | * of the data relative to the start of |buf|. | |
650 | */ | |
651 | static int cyapa_gen3_write_buffer(struct cyapa *cyapa, | |
652 | const u8 *buf, size_t len) | |
653 | { | |
654 | int error; | |
655 | size_t i; | |
656 | unsigned char cmd[CYAPA_CMD_LEN + 1]; | |
657 | size_t cmd_len; | |
658 | ||
659 | for (i = 0; i < len; i += CYAPA_CMD_LEN) { | |
660 | const u8 *payload = &buf[i]; | |
661 | ||
662 | cmd_len = (len - i >= CYAPA_CMD_LEN) ? CYAPA_CMD_LEN : len - i; | |
663 | cmd[0] = i; | |
664 | memcpy(&cmd[1], payload, cmd_len); | |
665 | ||
666 | error = cyapa_i2c_reg_write_block(cyapa, 0, cmd_len + 1, cmd); | |
667 | if (error) | |
668 | return error; | |
669 | } | |
670 | return 0; | |
671 | } | |
672 | ||
673 | /* | |
674 | * A firmware block write command writes 64 bytes of data to a single flash | |
675 | * page in the device. The 78-byte block write command has the format: | |
676 | * <0xff> <CMD> <Key> <Start> <Data> <Data-Checksum> <CMD Checksum> | |
677 | * | |
678 | * <0xff> - every command starts with 0xff | |
679 | * <CMD> - the write command value is 0x39 | |
680 | * <Key> - write commands include an 8-byte key: { 00 01 02 03 04 05 06 07 } | |
681 | * <Block> - Memory Block number (address / 64) (16-bit, big-endian) | |
682 | * <Data> - 64 bytes of firmware image data | |
683 | * <Data Checksum> - sum of 64 <Data> bytes, modulo 0xff | |
684 | * <CMD Checksum> - sum of 77 bytes, from 0xff to <Data Checksum> | |
685 | * | |
686 | * Each write command is split into 5 i2c write transactions of up to 16 bytes. | |
687 | * Each transaction starts with an i2c register offset: (00, 10, 20, 30, 40). | |
688 | */ | |
689 | static int cyapa_gen3_write_fw_block(struct cyapa *cyapa, | |
690 | u16 block, const u8 *data) | |
691 | { | |
692 | int ret; | |
693 | struct gen3_write_block_cmd write_block_cmd; | |
694 | u8 status[BL_STATUS_SIZE]; | |
695 | int tries; | |
696 | u8 bl_status, bl_error; | |
697 | ||
698 | /* Set write command and security key bytes. */ | |
699 | write_block_cmd.checksum_seed = GEN3_BL_CMD_CHECKSUM_SEED; | |
700 | write_block_cmd.cmd_code = GEN3_BL_CMD_WRITE_BLOCK; | |
701 | memcpy(write_block_cmd.key, security_key, sizeof(security_key)); | |
702 | put_unaligned_be16(block, &write_block_cmd.block_num); | |
703 | memcpy(write_block_cmd.block_data, data, CYAPA_FW_BLOCK_SIZE); | |
704 | write_block_cmd.block_checksum = cyapa_gen3_csum( | |
705 | write_block_cmd.block_data, CYAPA_FW_BLOCK_SIZE); | |
706 | write_block_cmd.cmd_checksum = cyapa_gen3_csum((u8 *)&write_block_cmd, | |
707 | sizeof(write_block_cmd) - 1); | |
708 | ||
709 | ret = cyapa_gen3_write_buffer(cyapa, (u8 *)&write_block_cmd, | |
710 | sizeof(write_block_cmd)); | |
711 | if (ret) | |
712 | return ret; | |
713 | ||
714 | /* Wait for write to finish */ | |
715 | tries = 11; /* Programming for one block can take about 100ms. */ | |
716 | do { | |
717 | usleep_range(10000, 20000); | |
718 | ||
719 | /* Check block write command result status. */ | |
720 | ret = cyapa_i2c_reg_read_block(cyapa, BL_HEAD_OFFSET, | |
721 | BL_STATUS_SIZE, status); | |
722 | if (ret != BL_STATUS_SIZE) | |
723 | return (ret < 0) ? ret : -EIO; | |
724 | } while ((status[REG_BL_STATUS] & BL_STATUS_BUSY) && --tries); | |
725 | ||
726 | /* Ignore WATCHDOG bit and reserved bits. */ | |
727 | bl_status = status[REG_BL_STATUS] & ~BL_STATUS_REV_MASK; | |
728 | bl_error = status[REG_BL_ERROR] & ~BL_ERROR_RESERVED; | |
729 | ||
730 | if (bl_status & BL_STATUS_BUSY) | |
731 | ret = -ETIMEDOUT; | |
732 | else if (bl_status != BL_STATUS_RUNNING || | |
733 | bl_error != BL_ERROR_BOOTLOADING) | |
734 | ret = -EIO; | |
735 | else | |
736 | ret = 0; | |
737 | ||
738 | return ret; | |
739 | } | |
740 | ||
741 | static int cyapa_gen3_write_blocks(struct cyapa *cyapa, | |
742 | size_t start_block, size_t block_count, | |
743 | const u8 *image_data) | |
744 | { | |
745 | int error; | |
746 | int i; | |
747 | ||
748 | for (i = 0; i < block_count; i++) { | |
749 | size_t block = start_block + i; | |
750 | size_t addr = i * CYAPA_FW_BLOCK_SIZE; | |
751 | const u8 *data = &image_data[addr]; | |
752 | ||
753 | error = cyapa_gen3_write_fw_block(cyapa, block, data); | |
754 | if (error) | |
755 | return error; | |
756 | } | |
757 | return 0; | |
758 | } | |
759 | ||
760 | static int cyapa_gen3_do_fw_update(struct cyapa *cyapa, | |
761 | const struct firmware *fw) | |
762 | { | |
763 | struct device *dev = &cyapa->client->dev; | |
764 | int error; | |
765 | ||
766 | /* First write data, starting at byte 128 of fw->data */ | |
767 | error = cyapa_gen3_write_blocks(cyapa, | |
768 | CYAPA_FW_DATA_BLOCK_START, CYAPA_FW_DATA_BLOCK_COUNT, | |
769 | &fw->data[CYAPA_FW_HDR_BLOCK_COUNT * CYAPA_FW_BLOCK_SIZE]); | |
770 | if (error) { | |
771 | dev_err(dev, "FW update aborted, write image: %d\n", error); | |
772 | return error; | |
773 | } | |
774 | ||
775 | /* Then write checksum */ | |
776 | error = cyapa_gen3_write_blocks(cyapa, | |
777 | CYAPA_FW_HDR_BLOCK_START, CYAPA_FW_HDR_BLOCK_COUNT, | |
778 | &fw->data[0]); | |
779 | if (error) { | |
780 | dev_err(dev, "FW update aborted, write checksum: %d\n", error); | |
781 | return error; | |
782 | } | |
783 | ||
784 | return 0; | |
785 | } | |
786 | ||
e0f79cb7 DD |
787 | static ssize_t cyapa_gen3_do_calibrate(struct device *dev, |
788 | struct device_attribute *attr, | |
789 | const char *buf, size_t count) | |
790 | { | |
791 | struct cyapa *cyapa = dev_get_drvdata(dev); | |
792 | int tries; | |
793 | int ret; | |
794 | ||
795 | ret = cyapa_read_byte(cyapa, CYAPA_CMD_DEV_STATUS); | |
796 | if (ret < 0) { | |
797 | dev_err(dev, "Error reading dev status: %d\n", ret); | |
798 | goto out; | |
799 | } | |
800 | if ((ret & CYAPA_DEV_NORMAL) != CYAPA_DEV_NORMAL) { | |
801 | dev_warn(dev, "Trackpad device is busy, device state: 0x%02x\n", | |
802 | ret); | |
803 | ret = -EAGAIN; | |
804 | goto out; | |
805 | } | |
806 | ||
807 | ret = cyapa_write_byte(cyapa, CYAPA_CMD_SOFT_RESET, | |
808 | OP_RECALIBRATION_MASK); | |
809 | if (ret < 0) { | |
810 | dev_err(dev, "Failed to send calibrate command: %d\n", | |
811 | ret); | |
812 | goto out; | |
813 | } | |
814 | ||
815 | tries = 20; /* max recalibration timeout 2s. */ | |
816 | do { | |
817 | /* | |
818 | * For this recalibration, the max time will not exceed 2s. | |
819 | * The average time is approximately 500 - 700 ms, and we | |
820 | * will check the status every 100 - 200ms. | |
821 | */ | |
822 | usleep_range(100000, 200000); | |
823 | ||
824 | ret = cyapa_read_byte(cyapa, CYAPA_CMD_DEV_STATUS); | |
825 | if (ret < 0) { | |
826 | dev_err(dev, "Error reading dev status: %d\n", | |
827 | ret); | |
828 | goto out; | |
829 | } | |
830 | if ((ret & CYAPA_DEV_NORMAL) == CYAPA_DEV_NORMAL) | |
831 | break; | |
832 | } while (--tries); | |
833 | ||
834 | if (tries == 0) { | |
835 | dev_err(dev, "Failed to calibrate. Timeout.\n"); | |
836 | ret = -ETIMEDOUT; | |
837 | goto out; | |
838 | } | |
839 | dev_dbg(dev, "Calibration successful.\n"); | |
840 | ||
841 | out: | |
842 | return ret < 0 ? ret : count; | |
843 | } | |
844 | ||
f50efd06 DD |
845 | static ssize_t cyapa_gen3_show_baseline(struct device *dev, |
846 | struct device_attribute *attr, char *buf) | |
847 | { | |
848 | struct cyapa *cyapa = dev_get_drvdata(dev); | |
849 | int max_baseline, min_baseline; | |
850 | int tries; | |
851 | int ret; | |
852 | ||
853 | ret = cyapa_read_byte(cyapa, CYAPA_CMD_DEV_STATUS); | |
854 | if (ret < 0) { | |
855 | dev_err(dev, "Error reading dev status. err = %d\n", ret); | |
856 | goto out; | |
857 | } | |
858 | if ((ret & CYAPA_DEV_NORMAL) != CYAPA_DEV_NORMAL) { | |
859 | dev_warn(dev, "Trackpad device is busy. device state = 0x%x\n", | |
860 | ret); | |
861 | ret = -EAGAIN; | |
862 | goto out; | |
863 | } | |
864 | ||
865 | ret = cyapa_write_byte(cyapa, CYAPA_CMD_SOFT_RESET, | |
866 | OP_REPORT_BASELINE_MASK); | |
867 | if (ret < 0) { | |
868 | dev_err(dev, "Failed to send report baseline command. %d\n", | |
869 | ret); | |
870 | goto out; | |
871 | } | |
872 | ||
873 | tries = 3; /* Try for 30 to 60 ms */ | |
874 | do { | |
875 | usleep_range(10000, 20000); | |
876 | ||
877 | ret = cyapa_read_byte(cyapa, CYAPA_CMD_DEV_STATUS); | |
878 | if (ret < 0) { | |
879 | dev_err(dev, "Error reading dev status. err = %d\n", | |
880 | ret); | |
881 | goto out; | |
882 | } | |
883 | if ((ret & CYAPA_DEV_NORMAL) == CYAPA_DEV_NORMAL) | |
884 | break; | |
885 | } while (--tries); | |
886 | ||
887 | if (tries == 0) { | |
888 | dev_err(dev, "Device timed out going to Normal state.\n"); | |
889 | ret = -ETIMEDOUT; | |
890 | goto out; | |
891 | } | |
892 | ||
893 | ret = cyapa_read_byte(cyapa, CYAPA_CMD_MAX_BASELINE); | |
894 | if (ret < 0) { | |
895 | dev_err(dev, "Failed to read max baseline. err = %d\n", ret); | |
896 | goto out; | |
897 | } | |
898 | max_baseline = ret; | |
899 | ||
900 | ret = cyapa_read_byte(cyapa, CYAPA_CMD_MIN_BASELINE); | |
901 | if (ret < 0) { | |
902 | dev_err(dev, "Failed to read min baseline. err = %d\n", ret); | |
903 | goto out; | |
904 | } | |
905 | min_baseline = ret; | |
906 | ||
907 | dev_dbg(dev, "Baseline report successful. Max: %d Min: %d\n", | |
908 | max_baseline, min_baseline); | |
909 | ret = scnprintf(buf, PAGE_SIZE, "%d %d\n", max_baseline, min_baseline); | |
910 | ||
911 | out: | |
912 | return ret; | |
913 | } | |
914 | ||
9f1cd857 DD |
915 | /* |
916 | * cyapa_get_wait_time_for_pwr_cmd | |
917 | * | |
918 | * Compute the amount of time we need to wait after updating the touchpad | |
919 | * power mode. The touchpad needs to consume the incoming power mode set | |
920 | * command at the current clock rate. | |
921 | */ | |
922 | ||
923 | static u16 cyapa_get_wait_time_for_pwr_cmd(u8 pwr_mode) | |
924 | { | |
925 | switch (pwr_mode) { | |
926 | case PWR_MODE_FULL_ACTIVE: return 20; | |
927 | case PWR_MODE_BTN_ONLY: return 20; | |
928 | case PWR_MODE_OFF: return 20; | |
929 | default: return cyapa_pwr_cmd_to_sleep_time(pwr_mode) + 50; | |
930 | } | |
931 | } | |
932 | ||
933 | /* | |
934 | * Set device power mode | |
935 | * | |
936 | * Write to the field to configure power state. Power states include : | |
937 | * Full : Max scans and report rate. | |
938 | * Idle : Report rate set by user specified time. | |
939 | * ButtonOnly : No scans for fingers. When the button is triggered, | |
940 | * a slave interrupt is asserted to notify host to wake up. | |
941 | * Off : Only awake for i2c commands from host. No function for button | |
942 | * or touch sensors. | |
943 | * | |
944 | * The power_mode command should conform to the following : | |
945 | * Full : 0x3f | |
946 | * Idle : Configurable from 20 to 1000ms. See note below for | |
947 | * cyapa_sleep_time_to_pwr_cmd and cyapa_pwr_cmd_to_sleep_time | |
948 | * ButtonOnly : 0x01 | |
949 | * Off : 0x00 | |
950 | * | |
951 | * Device power mode can only be set when device is in operational mode. | |
952 | */ | |
953 | static int cyapa_gen3_set_power_mode(struct cyapa *cyapa, u8 power_mode, | |
3cd47869 | 954 | u16 always_unused, enum cyapa_pm_stage pm_stage) |
9f1cd857 | 955 | { |
3cd47869 | 956 | struct input_dev *input = cyapa->input; |
9f1cd857 DD |
957 | u8 power; |
958 | int tries; | |
3cd47869 DD |
959 | int sleep_time; |
960 | int interval; | |
961 | int ret; | |
9f1cd857 | 962 | |
9f1cd857 DD |
963 | if (cyapa->state != CYAPA_STATE_OP) |
964 | return 0; | |
965 | ||
966 | tries = SET_POWER_MODE_TRIES; | |
967 | while (tries--) { | |
968 | ret = cyapa_read_byte(cyapa, CYAPA_CMD_POWER_MODE); | |
969 | if (ret >= 0) | |
970 | break; | |
971 | usleep_range(SET_POWER_MODE_DELAY, 2 * SET_POWER_MODE_DELAY); | |
972 | } | |
973 | if (ret < 0) | |
974 | return ret; | |
975 | ||
976 | /* | |
977 | * Return early if the power mode to set is the same as the current | |
978 | * one. | |
979 | */ | |
980 | if ((ret & PWR_MODE_MASK) == power_mode) | |
981 | return 0; | |
982 | ||
3cd47869 | 983 | sleep_time = (int)cyapa_get_wait_time_for_pwr_cmd(ret & PWR_MODE_MASK); |
9f1cd857 DD |
984 | power = ret; |
985 | power &= ~PWR_MODE_MASK; | |
986 | power |= power_mode & PWR_MODE_MASK; | |
987 | tries = SET_POWER_MODE_TRIES; | |
988 | while (tries--) { | |
989 | ret = cyapa_write_byte(cyapa, CYAPA_CMD_POWER_MODE, power); | |
990 | if (!ret) | |
991 | break; | |
992 | usleep_range(SET_POWER_MODE_DELAY, 2 * SET_POWER_MODE_DELAY); | |
993 | } | |
994 | ||
995 | /* | |
996 | * Wait for the newly set power command to go in at the previous | |
997 | * clock speed (scanrate) used by the touchpad firmware. Not | |
998 | * doing so before issuing the next command may result in errors | |
999 | * depending on the command's content. | |
1000 | */ | |
3cd47869 DD |
1001 | if (cyapa->operational && input && input->users && |
1002 | (pm_stage == CYAPA_PM_RUNTIME_SUSPEND || | |
1003 | pm_stage == CYAPA_PM_RUNTIME_RESUME)) { | |
1004 | /* Try to polling in 120Hz, read may fail, just ignore it. */ | |
1005 | interval = 1000 / 120; | |
1006 | while (sleep_time > 0) { | |
1007 | if (sleep_time > interval) | |
1008 | msleep(interval); | |
1009 | else | |
1010 | msleep(sleep_time); | |
1011 | sleep_time -= interval; | |
1012 | cyapa_gen3_try_poll_handler(cyapa); | |
1013 | } | |
1014 | } else { | |
1015 | msleep(sleep_time); | |
1016 | } | |
1017 | ||
9f1cd857 DD |
1018 | return ret; |
1019 | } | |
1020 | ||
945525ee DD |
1021 | static int cyapa_gen3_set_proximity(struct cyapa *cyapa, bool enable) |
1022 | { | |
1023 | return -EOPNOTSUPP; | |
1024 | } | |
1025 | ||
9f1cd857 DD |
1026 | static int cyapa_gen3_get_query_data(struct cyapa *cyapa) |
1027 | { | |
1028 | u8 query_data[QUERY_DATA_SIZE]; | |
1029 | int ret; | |
1030 | ||
1031 | if (cyapa->state != CYAPA_STATE_OP) | |
1032 | return -EBUSY; | |
1033 | ||
1034 | ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_QUERY, query_data); | |
1035 | if (ret != QUERY_DATA_SIZE) | |
1036 | return (ret < 0) ? ret : -EIO; | |
1037 | ||
1038 | memcpy(&cyapa->product_id[0], &query_data[0], 5); | |
1039 | cyapa->product_id[5] = '-'; | |
1040 | memcpy(&cyapa->product_id[6], &query_data[5], 6); | |
1041 | cyapa->product_id[12] = '-'; | |
1042 | memcpy(&cyapa->product_id[13], &query_data[11], 2); | |
1043 | cyapa->product_id[15] = '\0'; | |
1044 | ||
1045 | cyapa->fw_maj_ver = query_data[15]; | |
1046 | cyapa->fw_min_ver = query_data[16]; | |
1047 | ||
1048 | cyapa->btn_capability = query_data[19] & CAPABILITY_BTN_MASK; | |
1049 | ||
1050 | cyapa->gen = query_data[20] & 0x0f; | |
1051 | ||
1052 | cyapa->max_abs_x = ((query_data[21] & 0xf0) << 4) | query_data[22]; | |
1053 | cyapa->max_abs_y = ((query_data[21] & 0x0f) << 8) | query_data[23]; | |
1054 | ||
1055 | cyapa->physical_size_x = | |
1056 | ((query_data[24] & 0xf0) << 4) | query_data[25]; | |
1057 | cyapa->physical_size_y = | |
1058 | ((query_data[24] & 0x0f) << 8) | query_data[26]; | |
1059 | ||
1060 | cyapa->max_z = 255; | |
1061 | ||
1062 | return 0; | |
1063 | } | |
1064 | ||
1065 | static int cyapa_gen3_bl_query_data(struct cyapa *cyapa) | |
1066 | { | |
1067 | u8 bl_data[CYAPA_CMD_LEN]; | |
1068 | int ret; | |
1069 | ||
1070 | ret = cyapa_i2c_reg_read_block(cyapa, 0, CYAPA_CMD_LEN, bl_data); | |
1071 | if (ret != CYAPA_CMD_LEN) | |
1072 | return (ret < 0) ? ret : -EIO; | |
1073 | ||
1074 | /* | |
1075 | * This value will be updated again when entered application mode. | |
1076 | * If TP failed to enter application mode, this fw version values | |
1077 | * can be used as a reference. | |
1078 | * This firmware version valid when fw image checksum is valid. | |
1079 | */ | |
1080 | if (bl_data[REG_BL_STATUS] == | |
1081 | (BL_STATUS_RUNNING | BL_STATUS_CSUM_VALID)) { | |
1082 | cyapa->fw_maj_ver = bl_data[GEN3_BL_IDLE_FW_MAJ_VER_OFFSET]; | |
1083 | cyapa->fw_min_ver = bl_data[GEN3_BL_IDLE_FW_MIN_VER_OFFSET]; | |
1084 | } | |
1085 | ||
1086 | return 0; | |
1087 | } | |
1088 | ||
1089 | /* | |
1090 | * Check if device is operational. | |
1091 | * | |
1092 | * An operational device is responding, has exited bootloader, and has | |
1093 | * firmware supported by this driver. | |
1094 | * | |
1095 | * Returns: | |
1096 | * -EBUSY no device or in bootloader | |
1097 | * -EIO failure while reading from device | |
1098 | * -EAGAIN device is still in bootloader | |
1099 | * if ->state = CYAPA_STATE_BL_IDLE, device has invalid firmware | |
1100 | * -EINVAL device is in operational mode, but not supported by this driver | |
1101 | * 0 device is supported | |
1102 | */ | |
1103 | static int cyapa_gen3_do_operational_check(struct cyapa *cyapa) | |
1104 | { | |
1105 | struct device *dev = &cyapa->client->dev; | |
1106 | int error; | |
1107 | ||
1108 | switch (cyapa->state) { | |
1109 | case CYAPA_STATE_BL_ACTIVE: | |
1110 | error = cyapa_gen3_bl_deactivate(cyapa); | |
1111 | if (error) { | |
1112 | dev_err(dev, "failed to bl_deactivate: %d\n", error); | |
1113 | return error; | |
1114 | } | |
1115 | ||
1116 | /* Fallthrough state */ | |
1117 | case CYAPA_STATE_BL_IDLE: | |
1118 | /* Try to get firmware version in bootloader mode. */ | |
1119 | cyapa_gen3_bl_query_data(cyapa); | |
1120 | ||
1121 | error = cyapa_gen3_bl_exit(cyapa); | |
1122 | if (error) { | |
1123 | dev_err(dev, "failed to bl_exit: %d\n", error); | |
1124 | return error; | |
1125 | } | |
1126 | ||
1127 | /* Fallthrough state */ | |
1128 | case CYAPA_STATE_OP: | |
1129 | /* | |
1130 | * Reading query data before going back to the full mode | |
1131 | * may cause problems, so we set the power mode first here. | |
1132 | */ | |
1133 | error = cyapa_gen3_set_power_mode(cyapa, | |
3cd47869 | 1134 | PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_ACTIVE); |
9f1cd857 DD |
1135 | if (error) |
1136 | dev_err(dev, "%s: set full power mode failed: %d\n", | |
1137 | __func__, error); | |
1138 | error = cyapa_gen3_get_query_data(cyapa); | |
1139 | if (error < 0) | |
1140 | return error; | |
1141 | ||
1142 | /* Only support firmware protocol gen3 */ | |
1143 | if (cyapa->gen != CYAPA_GEN3) { | |
1144 | dev_err(dev, "unsupported protocol version (%d)", | |
1145 | cyapa->gen); | |
1146 | return -EINVAL; | |
1147 | } | |
1148 | ||
1149 | /* Only support product ID starting with CYTRA */ | |
1150 | if (memcmp(cyapa->product_id, product_id, | |
1151 | strlen(product_id)) != 0) { | |
1152 | dev_err(dev, "unsupported product ID (%s)\n", | |
1153 | cyapa->product_id); | |
1154 | return -EINVAL; | |
1155 | } | |
1156 | ||
1157 | return 0; | |
1158 | ||
1159 | default: | |
1160 | return -EIO; | |
1161 | } | |
1162 | return 0; | |
1163 | } | |
1164 | ||
1165 | /* | |
1166 | * Return false, do not continue process | |
1167 | * Return true, continue process. | |
1168 | */ | |
1169 | static bool cyapa_gen3_irq_cmd_handler(struct cyapa *cyapa) | |
1170 | { | |
1171 | /* Not gen3 irq command response, skip for continue. */ | |
1172 | if (cyapa->gen != CYAPA_GEN3) | |
1173 | return true; | |
1174 | ||
1175 | if (cyapa->operational) | |
1176 | return true; | |
1177 | ||
1178 | /* | |
1179 | * Driver in detecting or other interface function processing, | |
1180 | * so, stop cyapa_gen3_irq_handler to continue process to | |
1181 | * avoid unwanted to error detecting and processing. | |
1182 | * | |
94897619 | 1183 | * And also, avoid the periodically asserted interrupts to be processed |
9f1cd857 DD |
1184 | * as touch inputs when gen3 failed to launch into application mode, |
1185 | * which will cause gen3 stays in bootloader mode. | |
1186 | */ | |
1187 | return false; | |
1188 | } | |
1189 | ||
3cd47869 DD |
1190 | static int cyapa_gen3_event_process(struct cyapa *cyapa, |
1191 | struct cyapa_reg_data *data) | |
9f1cd857 DD |
1192 | { |
1193 | struct input_dev *input = cyapa->input; | |
9f1cd857 | 1194 | int num_fingers; |
9f1cd857 DD |
1195 | int i; |
1196 | ||
3cd47869 | 1197 | num_fingers = (data->finger_btn >> 4) & 0x0f; |
9f1cd857 | 1198 | for (i = 0; i < num_fingers; i++) { |
3cd47869 | 1199 | const struct cyapa_touch *touch = &data->touches[i]; |
9f1cd857 DD |
1200 | /* Note: touch->id range is 1 to 15; slots are 0 to 14. */ |
1201 | int slot = touch->id - 1; | |
1202 | ||
1203 | input_mt_slot(input, slot); | |
1204 | input_mt_report_slot_state(input, MT_TOOL_FINGER, true); | |
1205 | input_report_abs(input, ABS_MT_POSITION_X, | |
1206 | ((touch->xy_hi & 0xf0) << 4) | touch->x_lo); | |
1207 | input_report_abs(input, ABS_MT_POSITION_Y, | |
1208 | ((touch->xy_hi & 0x0f) << 8) | touch->y_lo); | |
1209 | input_report_abs(input, ABS_MT_PRESSURE, touch->pressure); | |
1210 | } | |
1211 | ||
1212 | input_mt_sync_frame(input); | |
1213 | ||
1214 | if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK) | |
1215 | input_report_key(input, BTN_LEFT, | |
3cd47869 | 1216 | !!(data->finger_btn & OP_DATA_LEFT_BTN)); |
9f1cd857 DD |
1217 | if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK) |
1218 | input_report_key(input, BTN_MIDDLE, | |
3cd47869 | 1219 | !!(data->finger_btn & OP_DATA_MIDDLE_BTN)); |
9f1cd857 DD |
1220 | if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK) |
1221 | input_report_key(input, BTN_RIGHT, | |
3cd47869 | 1222 | !!(data->finger_btn & OP_DATA_RIGHT_BTN)); |
9f1cd857 DD |
1223 | input_sync(input); |
1224 | ||
1225 | return 0; | |
1226 | } | |
1227 | ||
3cd47869 DD |
1228 | static int cyapa_gen3_irq_handler(struct cyapa *cyapa) |
1229 | { | |
1230 | struct device *dev = &cyapa->client->dev; | |
1231 | struct cyapa_reg_data data; | |
1232 | int ret; | |
1233 | ||
1234 | ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_DATA, (u8 *)&data); | |
1235 | if (ret != sizeof(data)) { | |
1236 | dev_err(dev, "failed to read report data, (%d)\n", ret); | |
1237 | return -EINVAL; | |
1238 | } | |
1239 | ||
1240 | if ((data.device_status & OP_STATUS_SRC) != OP_STATUS_SRC || | |
1241 | (data.device_status & OP_STATUS_DEV) != CYAPA_DEV_NORMAL || | |
1242 | (data.finger_btn & OP_DATA_VALID) != OP_DATA_VALID) { | |
1243 | dev_err(dev, "invalid device state bytes: %02x %02x\n", | |
1244 | data.device_status, data.finger_btn); | |
1245 | return -EINVAL; | |
1246 | } | |
1247 | ||
1248 | return cyapa_gen3_event_process(cyapa, &data); | |
1249 | } | |
1250 | ||
1251 | /* | |
1252 | * This function will be called in the cyapa_gen3_set_power_mode function, | |
1253 | * and it's known that it may failed in some situation after the set power | |
1254 | * mode command was sent. So this function is aimed to avoid the knwon | |
1255 | * and unwanted output I2C and data parse error messages. | |
1256 | */ | |
1257 | static int cyapa_gen3_try_poll_handler(struct cyapa *cyapa) | |
1258 | { | |
1259 | struct cyapa_reg_data data; | |
1260 | int ret; | |
1261 | ||
1262 | ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_DATA, (u8 *)&data); | |
1263 | if (ret != sizeof(data)) | |
1264 | return -EINVAL; | |
1265 | ||
1266 | if ((data.device_status & OP_STATUS_SRC) != OP_STATUS_SRC || | |
1267 | (data.device_status & OP_STATUS_DEV) != CYAPA_DEV_NORMAL || | |
1268 | (data.finger_btn & OP_DATA_VALID) != OP_DATA_VALID) | |
1269 | return -EINVAL; | |
1270 | ||
1271 | return cyapa_gen3_event_process(cyapa, &data); | |
1272 | ||
1273 | } | |
1274 | ||
9f1cd857 | 1275 | static int cyapa_gen3_initialize(struct cyapa *cyapa) { return 0; } |
87b26d72 DD |
1276 | static int cyapa_gen3_bl_initiate(struct cyapa *cyapa, |
1277 | const struct firmware *fw) { return 0; } | |
9f1cd857 DD |
1278 | static int cyapa_gen3_empty_output_data(struct cyapa *cyapa, |
1279 | u8 *buf, int *len, cb_sort func) { return 0; } | |
1280 | ||
1281 | const struct cyapa_dev_ops cyapa_gen3_ops = { | |
87b26d72 DD |
1282 | .check_fw = cyapa_gen3_check_fw, |
1283 | .bl_enter = cyapa_gen3_bl_enter, | |
1284 | .bl_activate = cyapa_gen3_bl_activate, | |
1285 | .update_fw = cyapa_gen3_do_fw_update, | |
1286 | .bl_deactivate = cyapa_gen3_bl_deactivate, | |
1287 | .bl_initiate = cyapa_gen3_bl_initiate, | |
1288 | ||
f50efd06 | 1289 | .show_baseline = cyapa_gen3_show_baseline, |
e0f79cb7 | 1290 | .calibrate_store = cyapa_gen3_do_calibrate, |
f50efd06 | 1291 | |
9f1cd857 DD |
1292 | .initialize = cyapa_gen3_initialize, |
1293 | ||
1294 | .state_parse = cyapa_gen3_state_parse, | |
1295 | .operational_check = cyapa_gen3_do_operational_check, | |
1296 | ||
1297 | .irq_handler = cyapa_gen3_irq_handler, | |
1298 | .irq_cmd_handler = cyapa_gen3_irq_cmd_handler, | |
1299 | .sort_empty_output_data = cyapa_gen3_empty_output_data, | |
1300 | .set_power_mode = cyapa_gen3_set_power_mode, | |
945525ee DD |
1301 | |
1302 | .set_proximity = cyapa_gen3_set_proximity, | |
9f1cd857 | 1303 | }; |