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