Input: goodix - add new ACPI id for GPD Win 2 touch screen
[muen/linux.git] / drivers / input / mouse / elan_i2c_smbus.c
1 /*
2  * Elan I2C/SMBus Touchpad driver - SMBus interface
3  *
4  * Copyright (c) 2013 ELAN Microelectronics Corp.
5  *
6  * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw>
7  *
8  * Based on cyapa driver:
9  * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
10  * copyright (c) 2011-2012 Google, Inc.
11  *
12  * This program is free software; you can redistribute it and/or modify it
13  * under the terms of the GNU General Public License version 2 as published
14  * by the Free Software Foundation.
15  *
16  * Trademarks are the property of their respective owners.
17  */
18
19 #include <linux/delay.h>
20 #include <linux/i2c.h>
21 #include <linux/init.h>
22 #include <linux/kernel.h>
23
24 #include "elan_i2c.h"
25
26 /* Elan SMbus commands */
27 #define ETP_SMBUS_IAP_CMD               0x00
28 #define ETP_SMBUS_ENABLE_TP             0x20
29 #define ETP_SMBUS_SLEEP_CMD             0x21
30 #define ETP_SMBUS_IAP_PASSWORD_WRITE    0x29
31 #define ETP_SMBUS_IAP_PASSWORD_READ     0x80
32 #define ETP_SMBUS_WRITE_FW_BLOCK        0x2A
33 #define ETP_SMBUS_IAP_RESET_CMD         0x2B
34 #define ETP_SMBUS_RANGE_CMD             0xA0
35 #define ETP_SMBUS_FW_VERSION_CMD        0xA1
36 #define ETP_SMBUS_XY_TRACENUM_CMD       0xA2
37 #define ETP_SMBUS_SM_VERSION_CMD        0xA3
38 #define ETP_SMBUS_UNIQUEID_CMD          0xA3
39 #define ETP_SMBUS_RESOLUTION_CMD        0xA4
40 #define ETP_SMBUS_HELLOPACKET_CMD       0xA7
41 #define ETP_SMBUS_PACKET_QUERY          0xA8
42 #define ETP_SMBUS_IAP_VERSION_CMD       0xAC
43 #define ETP_SMBUS_IAP_CTRL_CMD          0xAD
44 #define ETP_SMBUS_IAP_CHECKSUM_CMD      0xAE
45 #define ETP_SMBUS_FW_CHECKSUM_CMD       0xAF
46 #define ETP_SMBUS_MAX_BASELINE_CMD      0xC3
47 #define ETP_SMBUS_MIN_BASELINE_CMD      0xC4
48 #define ETP_SMBUS_CALIBRATE_QUERY       0xC5
49
50 #define ETP_SMBUS_REPORT_LEN            32
51 #define ETP_SMBUS_REPORT_OFFSET         2
52 #define ETP_SMBUS_HELLOPACKET_LEN       5
53 #define ETP_SMBUS_IAP_PASSWORD          0x1234
54 #define ETP_SMBUS_IAP_MODE_ON           (1 << 6)
55
56 static int elan_smbus_initialize(struct i2c_client *client)
57 {
58         u8 check[ETP_SMBUS_HELLOPACKET_LEN] = { 0x55, 0x55, 0x55, 0x55, 0x55 };
59         u8 values[ETP_SMBUS_HELLOPACKET_LEN] = { 0, 0, 0, 0, 0 };
60         int len, error;
61
62         /* Get hello packet */
63         len = i2c_smbus_read_block_data(client,
64                                         ETP_SMBUS_HELLOPACKET_CMD, values);
65         if (len != ETP_SMBUS_HELLOPACKET_LEN) {
66                 dev_err(&client->dev, "hello packet length fail: %d\n", len);
67                 error = len < 0 ? len : -EIO;
68                 return error;
69         }
70
71         /* compare hello packet */
72         if (memcmp(values, check, ETP_SMBUS_HELLOPACKET_LEN)) {
73                 dev_err(&client->dev, "hello packet fail [%*ph]\n",
74                         ETP_SMBUS_HELLOPACKET_LEN, values);
75                 return -ENXIO;
76         }
77
78         /* enable tp */
79         error = i2c_smbus_write_byte(client, ETP_SMBUS_ENABLE_TP);
80         if (error) {
81                 dev_err(&client->dev, "failed to enable touchpad: %d\n", error);
82                 return error;
83         }
84
85         return 0;
86 }
87
88 static int elan_smbus_set_mode(struct i2c_client *client, u8 mode)
89 {
90         u8 cmd[4] = { 0x00, 0x07, 0x00, mode };
91
92         return i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
93                                           sizeof(cmd), cmd);
94 }
95
96 static int elan_smbus_sleep_control(struct i2c_client *client, bool sleep)
97 {
98         if (sleep)
99                 return i2c_smbus_write_byte(client, ETP_SMBUS_SLEEP_CMD);
100         else
101                 return 0; /* XXX should we send ETP_SMBUS_ENABLE_TP here? */
102 }
103
104 static int elan_smbus_power_control(struct i2c_client *client, bool enable)
105 {
106         return 0; /* A no-op */
107 }
108
109 static int elan_smbus_calibrate(struct i2c_client *client)
110 {
111         u8 cmd[4] = { 0x00, 0x08, 0x00, 0x01 };
112
113         return i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
114                                           sizeof(cmd), cmd);
115 }
116
117 static int elan_smbus_calibrate_result(struct i2c_client *client, u8 *val)
118 {
119         int error;
120
121         error = i2c_smbus_read_block_data(client,
122                                           ETP_SMBUS_CALIBRATE_QUERY, val);
123         if (error < 0)
124                 return error;
125
126         return 0;
127 }
128
129 static int elan_smbus_get_baseline_data(struct i2c_client *client,
130                                         bool max_baseline, u8 *value)
131 {
132         int error;
133         u8 val[3];
134
135         error = i2c_smbus_read_block_data(client,
136                                           max_baseline ?
137                                                 ETP_SMBUS_MAX_BASELINE_CMD :
138                                                 ETP_SMBUS_MIN_BASELINE_CMD,
139                                           val);
140         if (error < 0)
141                 return error;
142
143         *value = be16_to_cpup((__be16 *)val);
144
145         return 0;
146 }
147
148 static int elan_smbus_get_version(struct i2c_client *client,
149                                   bool iap, u8 *version)
150 {
151         int error;
152         u8 val[3];
153
154         error = i2c_smbus_read_block_data(client,
155                                           iap ? ETP_SMBUS_IAP_VERSION_CMD :
156                                                 ETP_SMBUS_FW_VERSION_CMD,
157                                           val);
158         if (error < 0) {
159                 dev_err(&client->dev, "failed to get %s version: %d\n",
160                         iap ? "IAP" : "FW", error);
161                 return error;
162         }
163
164         *version = val[2];
165         return 0;
166 }
167
168 static int elan_smbus_get_sm_version(struct i2c_client *client,
169                                      u16 *ic_type, u8 *version,
170                                      u8 *clickpad)
171 {
172         int error;
173         u8 val[3];
174
175         error = i2c_smbus_read_block_data(client,
176                                           ETP_SMBUS_SM_VERSION_CMD, val);
177         if (error < 0) {
178                 dev_err(&client->dev, "failed to get SM version: %d\n", error);
179                 return error;
180         }
181
182         *version = val[0];
183         *ic_type = val[1];
184         *clickpad = val[0] & 0x10;
185         return 0;
186 }
187
188 static int elan_smbus_get_product_id(struct i2c_client *client, u16 *id)
189 {
190         int error;
191         u8 val[3];
192
193         error = i2c_smbus_read_block_data(client,
194                                           ETP_SMBUS_UNIQUEID_CMD, val);
195         if (error < 0) {
196                 dev_err(&client->dev, "failed to get product ID: %d\n", error);
197                 return error;
198         }
199
200         *id = be16_to_cpup((__be16 *)val);
201         return 0;
202 }
203
204 static int elan_smbus_get_checksum(struct i2c_client *client,
205                                    bool iap, u16 *csum)
206 {
207         int error;
208         u8 val[3];
209
210         error = i2c_smbus_read_block_data(client,
211                                           iap ? ETP_SMBUS_FW_CHECKSUM_CMD :
212                                                 ETP_SMBUS_IAP_CHECKSUM_CMD,
213                                           val);
214         if (error < 0) {
215                 dev_err(&client->dev, "failed to get %s checksum: %d\n",
216                         iap ? "IAP" : "FW", error);
217                 return error;
218         }
219
220         *csum = be16_to_cpup((__be16 *)val);
221         return 0;
222 }
223
224 static int elan_smbus_get_max(struct i2c_client *client,
225                               unsigned int *max_x, unsigned int *max_y)
226 {
227         int ret;
228         int error;
229         u8 val[3];
230
231         ret = i2c_smbus_read_block_data(client, ETP_SMBUS_RANGE_CMD, val);
232         if (ret != 3) {
233                 error = ret < 0 ? ret : -EIO;
234                 dev_err(&client->dev, "failed to get dimensions: %d\n", error);
235                 return error;
236         }
237
238         *max_x = (0x0f & val[0]) << 8 | val[1];
239         *max_y = (0xf0 & val[0]) << 4 | val[2];
240
241         return 0;
242 }
243
244 static int elan_smbus_get_resolution(struct i2c_client *client,
245                                      u8 *hw_res_x, u8 *hw_res_y)
246 {
247         int ret;
248         int error;
249         u8 val[3];
250
251         ret = i2c_smbus_read_block_data(client, ETP_SMBUS_RESOLUTION_CMD, val);
252         if (ret != 3) {
253                 error = ret < 0 ? ret : -EIO;
254                 dev_err(&client->dev, "failed to get resolution: %d\n", error);
255                 return error;
256         }
257
258         *hw_res_x = val[1] & 0x0F;
259         *hw_res_y = (val[1] & 0xF0) >> 4;
260
261         return 0;
262 }
263
264 static int elan_smbus_get_num_traces(struct i2c_client *client,
265                                      unsigned int *x_traces,
266                                      unsigned int *y_traces)
267 {
268         int ret;
269         int error;
270         u8 val[3];
271
272         ret = i2c_smbus_read_block_data(client, ETP_SMBUS_XY_TRACENUM_CMD, val);
273         if (ret != 3) {
274                 error = ret < 0 ? ret : -EIO;
275                 dev_err(&client->dev, "failed to get trace info: %d\n", error);
276                 return error;
277         }
278
279         *x_traces = val[1];
280         *y_traces = val[2];
281
282         return 0;
283 }
284
285 static int elan_smbus_get_pressure_adjustment(struct i2c_client *client,
286                                               int *adjustment)
287 {
288         *adjustment = ETP_PRESSURE_OFFSET;
289         return 0;
290 }
291
292 static int elan_smbus_iap_get_mode(struct i2c_client *client,
293                                    enum tp_mode *mode)
294 {
295         int error;
296         u16 constant;
297         u8 val[3];
298
299         error = i2c_smbus_read_block_data(client, ETP_SMBUS_IAP_CTRL_CMD, val);
300         if (error < 0) {
301                 dev_err(&client->dev, "failed to read iap ctrol register: %d\n",
302                         error);
303                 return error;
304         }
305
306         constant = be16_to_cpup((__be16 *)val);
307         dev_dbg(&client->dev, "iap control reg: 0x%04x.\n", constant);
308
309         *mode = (constant & ETP_SMBUS_IAP_MODE_ON) ? IAP_MODE : MAIN_MODE;
310
311         return 0;
312 }
313
314 static int elan_smbus_iap_reset(struct i2c_client *client)
315 {
316         int error;
317
318         error = i2c_smbus_write_byte(client, ETP_SMBUS_IAP_RESET_CMD);
319         if (error) {
320                 dev_err(&client->dev, "cannot reset IC: %d\n", error);
321                 return error;
322         }
323
324         return 0;
325 }
326
327 static int elan_smbus_set_flash_key(struct i2c_client *client)
328 {
329         int error;
330         u8 cmd[4] = { 0x00, 0x0B, 0x00, 0x5A };
331
332         error = i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
333                                            sizeof(cmd), cmd);
334         if (error) {
335                 dev_err(&client->dev, "cannot set flash key: %d\n", error);
336                 return error;
337         }
338
339         return 0;
340 }
341
342 static int elan_smbus_prepare_fw_update(struct i2c_client *client)
343 {
344         struct device *dev = &client->dev;
345         int len;
346         int error;
347         enum tp_mode mode;
348         u8 val[3];
349         u8 cmd[4] = {0x0F, 0x78, 0x00, 0x06};
350         u16 password;
351
352         /* Get FW in which mode (IAP_MODE/MAIN_MODE)  */
353         error = elan_smbus_iap_get_mode(client, &mode);
354         if (error)
355                 return error;
356
357         if (mode == MAIN_MODE) {
358
359                 /* set flash key */
360                 error = elan_smbus_set_flash_key(client);
361                 if (error)
362                         return error;
363
364                 /* write iap password */
365                 if (i2c_smbus_write_byte(client,
366                                          ETP_SMBUS_IAP_PASSWORD_WRITE) < 0) {
367                         dev_err(dev, "cannot write iap password\n");
368                         return -EIO;
369                 }
370
371                 error = i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
372                                                    sizeof(cmd), cmd);
373                 if (error) {
374                         dev_err(dev, "failed to write iap password: %d\n",
375                                 error);
376                         return error;
377                 }
378
379                 /*
380                  * Read back password to make sure we enabled flash
381                  * successfully.
382                  */
383                 len = i2c_smbus_read_block_data(client,
384                                                 ETP_SMBUS_IAP_PASSWORD_READ,
385                                                 val);
386                 if (len < sizeof(u16)) {
387                         error = len < 0 ? len : -EIO;
388                         dev_err(dev, "failed to read iap password: %d\n",
389                                 error);
390                         return error;
391                 }
392
393                 password = be16_to_cpup((__be16 *)val);
394                 if (password != ETP_SMBUS_IAP_PASSWORD) {
395                         dev_err(dev, "wrong iap password = 0x%X\n", password);
396                         return -EIO;
397                 }
398
399                 /* Wait 30ms for MAIN_MODE change to IAP_MODE */
400                 msleep(30);
401         }
402
403         error = elan_smbus_set_flash_key(client);
404         if (error)
405                 return error;
406
407         /* Reset IC */
408         error = elan_smbus_iap_reset(client);
409         if (error)
410                 return error;
411
412         return 0;
413 }
414
415
416 static int elan_smbus_write_fw_block(struct i2c_client *client,
417                                      const u8 *page, u16 checksum, int idx)
418 {
419         struct device *dev = &client->dev;
420         int error;
421         u16 result;
422         u8 val[3];
423
424         /*
425          * Due to the limitation of smbus protocol limiting
426          * transfer to 32 bytes at a time, we must split block
427          * in 2 transfers.
428          */
429         error = i2c_smbus_write_block_data(client,
430                                            ETP_SMBUS_WRITE_FW_BLOCK,
431                                            ETP_FW_PAGE_SIZE / 2,
432                                            page);
433         if (error) {
434                 dev_err(dev, "Failed to write page %d (part %d): %d\n",
435                         idx, 1, error);
436                 return error;
437         }
438
439         error = i2c_smbus_write_block_data(client,
440                                            ETP_SMBUS_WRITE_FW_BLOCK,
441                                            ETP_FW_PAGE_SIZE / 2,
442                                            page + ETP_FW_PAGE_SIZE / 2);
443         if (error) {
444                 dev_err(dev, "Failed to write page %d (part %d): %d\n",
445                         idx, 2, error);
446                 return error;
447         }
448
449
450         /* Wait for F/W to update one page ROM data. */
451         usleep_range(8000, 10000);
452
453         error = i2c_smbus_read_block_data(client,
454                                           ETP_SMBUS_IAP_CTRL_CMD, val);
455         if (error < 0) {
456                 dev_err(dev, "Failed to read IAP write result: %d\n",
457                         error);
458                 return error;
459         }
460
461         result = be16_to_cpup((__be16 *)val);
462         if (result & (ETP_FW_IAP_PAGE_ERR | ETP_FW_IAP_INTF_ERR)) {
463                 dev_err(dev, "IAP reports failed write: %04hx\n",
464                         result);
465                 return -EIO;
466         }
467
468         return 0;
469 }
470
471 static int elan_smbus_get_report(struct i2c_client *client, u8 *report)
472 {
473         int len;
474
475         len = i2c_smbus_read_block_data(client,
476                                         ETP_SMBUS_PACKET_QUERY,
477                                         &report[ETP_SMBUS_REPORT_OFFSET]);
478         if (len < 0) {
479                 dev_err(&client->dev, "failed to read report data: %d\n", len);
480                 return len;
481         }
482
483         if (len != ETP_SMBUS_REPORT_LEN) {
484                 dev_err(&client->dev,
485                         "wrong report length (%d vs %d expected)\n",
486                         len, ETP_SMBUS_REPORT_LEN);
487                 return -EIO;
488         }
489
490         return 0;
491 }
492
493 static int elan_smbus_finish_fw_update(struct i2c_client *client,
494                                        struct completion *fw_completion)
495 {
496         /* No special handling unlike I2C transport */
497         return 0;
498 }
499
500 static int elan_smbus_get_pattern(struct i2c_client *client, u8 *pattern)
501 {
502         *pattern = 0;
503         return 0;
504 }
505
506 const struct elan_transport_ops elan_smbus_ops = {
507         .initialize             = elan_smbus_initialize,
508         .sleep_control          = elan_smbus_sleep_control,
509         .power_control          = elan_smbus_power_control,
510         .set_mode               = elan_smbus_set_mode,
511
512         .calibrate              = elan_smbus_calibrate,
513         .calibrate_result       = elan_smbus_calibrate_result,
514
515         .get_baseline_data      = elan_smbus_get_baseline_data,
516
517         .get_version            = elan_smbus_get_version,
518         .get_sm_version         = elan_smbus_get_sm_version,
519         .get_product_id         = elan_smbus_get_product_id,
520         .get_checksum           = elan_smbus_get_checksum,
521         .get_pressure_adjustment = elan_smbus_get_pressure_adjustment,
522
523         .get_max                = elan_smbus_get_max,
524         .get_resolution         = elan_smbus_get_resolution,
525         .get_num_traces         = elan_smbus_get_num_traces,
526
527         .iap_get_mode           = elan_smbus_iap_get_mode,
528         .iap_reset              = elan_smbus_iap_reset,
529
530         .prepare_fw_update      = elan_smbus_prepare_fw_update,
531         .write_fw_block         = elan_smbus_write_fw_block,
532         .finish_fw_update       = elan_smbus_finish_fw_update,
533
534         .get_report             = elan_smbus_get_report,
535         .get_pattern            = elan_smbus_get_pattern,
536 };