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, u8 *version)
 169 {
 170         int error;
 171         u8 val[3];
 172
 173         error = i2c_smbus_read_block_data(client,
 174                                           ETP_SMBUS_SM_VERSION_CMD, val);
 175         if (error < 0) {
 176                 dev_err(&client->dev, "failed to get SM version: %d\n", error);
 177                 return error;
 178         }
 179
 180         *version = val[0]; /* XXX Why 0 and not 2 as in IAP/FW versions? */
 181         return 0;
 182 }
 183
 184 static int elan_smbus_get_product_id(struct i2c_client *client, u8 *id)
 185 {
 186         int error;
 187         u8 val[3];
 188
 189         error = i2c_smbus_read_block_data(client,
 190                                           ETP_SMBUS_UNIQUEID_CMD, val);
 191         if (error < 0) {
 192                 dev_err(&client->dev, "failed to get product ID: %d\n", error);
 193                 return error;
 194         }
 195
 196         *id = val[1];
 197         return 0;
 198 }
 199
 200 static int elan_smbus_get_checksum(struct i2c_client *client,
 201                                    bool iap, u16 *csum)
 202 {
 203         int error;
 204         u8 val[3];
 205
 206         error = i2c_smbus_read_block_data(client,
 207                                           iap ? ETP_SMBUS_FW_CHECKSUM_CMD :
 208                                                 ETP_SMBUS_IAP_CHECKSUM_CMD,
 209                                           val);
 210         if (error < 0) {
 211                 dev_err(&client->dev, "failed to get %s checksum: %d\n",
 212                         iap ? "IAP" : "FW", error);
 213                 return error;
 214         }
 215
 216         *csum = be16_to_cpup((__be16 *)val);
 217         return 0;
 218 }
 219
 220 static int elan_smbus_get_max(struct i2c_client *client,
 221                               unsigned int *max_x, unsigned int *max_y)
 222 {
 223         int error;
 224         u8 val[3];
 225
 226         error = i2c_smbus_read_block_data(client, ETP_SMBUS_RANGE_CMD, val);
 227         if (error) {
 228                 dev_err(&client->dev, "failed to get dimensions: %d\n", error);
 229                 return error;
 230         }
 231
 232         *max_x = (0x0f & val[0]) << 8 | val[1];
 233         *max_y = (0xf0 & val[0]) << 4 | val[2];
 234
 235         return 0;
 236 }
 237
 238 static int elan_smbus_get_resolution(struct i2c_client *client,
 239                                      u8 *hw_res_x, u8 *hw_res_y)
 240 {
 241         int error;
 242         u8 val[3];
 243
 244         error = i2c_smbus_read_block_data(client,
 245                                           ETP_SMBUS_RESOLUTION_CMD, val);
 246         if (error) {
 247                 dev_err(&client->dev, "failed to get resolution: %d\n", error);
 248                 return error;
 249         }
 250
 251         *hw_res_x = val[1] & 0x0F;
 252         *hw_res_y = (val[1] & 0xF0) >> 4;
 253
 254         return 0;
 255 }
 256
 257 static int elan_smbus_get_num_traces(struct i2c_client *client,
 258                                      unsigned int *x_traces,
 259                                      unsigned int *y_traces)
 260 {
 261         int error;
 262         u8 val[3];
 263
 264         error = i2c_smbus_read_block_data(client,
 265                                           ETP_SMBUS_XY_TRACENUM_CMD, val);
 266         if (error) {
 267                 dev_err(&client->dev, "failed to get trace info: %d\n", error);
 268                 return error;
 269         }
 270
 271         *x_traces = val[1] - 1;
 272         *y_traces = val[2] - 1;
 273
 274         return 0;
 275 }
 276
 277 static int elan_smbus_iap_get_mode(struct i2c_client *client,
 278                                    enum tp_mode *mode)
 279 {
 280         int error;
 281         u16 constant;
 282         u8 val[3];
 283
 284         error = i2c_smbus_read_block_data(client, ETP_SMBUS_IAP_CTRL_CMD, val);
 285         if (error < 0) {
 286                 dev_err(&client->dev, "failed to read iap ctrol register: %d\n",
 287                         error);
 288                 return error;
 289         }
 290
 291         constant = be16_to_cpup((__be16 *)val);
 292         dev_dbg(&client->dev, "iap control reg: 0x%04x.\n", constant);
 293
 294         *mode = (constant & ETP_SMBUS_IAP_MODE_ON) ? IAP_MODE : MAIN_MODE;
 295
 296         return 0;
 297 }
 298
 299 static int elan_smbus_iap_reset(struct i2c_client *client)
 300 {
 301         int error;
 302
 303         error = i2c_smbus_write_byte(client, ETP_SMBUS_IAP_RESET_CMD);
 304         if (error) {
 305                 dev_err(&client->dev, "cannot reset IC: %d\n", error);
 306                 return error;
 307         }
 308
 309         return 0;
 310 }
 311
 312 static int elan_smbus_set_flash_key(struct i2c_client *client)
 313 {
 314         int error;
 315         u8 cmd[4] = { 0x00, 0x0B, 0x00, 0x5A };
 316
 317         error = i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
 318                                            sizeof(cmd), cmd);
 319         if (error) {
 320                 dev_err(&client->dev, "cannot set flash key: %d\n", error);
 321                 return error;
 322         }
 323
 324         return 0;
 325 }
 326
 327 static int elan_smbus_prepare_fw_update(struct i2c_client *client)
 328 {
 329         struct device *dev = &client->dev;
 330         int len;
 331         int error;
 332         enum tp_mode mode;
 333         u8 val[3];
 334         u8 cmd[4] = {0x0F, 0x78, 0x00, 0x06};
 335         u16 password;
 336
 337         /* Get FW in which mode (IAP_MODE/MAIN_MODE)  */
 338         error = elan_smbus_iap_get_mode(client, &mode);
 339         if (error)
 340                 return error;
 341
 342         if (mode == MAIN_MODE) {
 343
 344                 /* set flash key */
 345                 error = elan_smbus_set_flash_key(client);
 346                 if (error)
 347                         return error;
 348
 349                 /* write iap password */
 350                 if (i2c_smbus_write_byte(client,
 351                                          ETP_SMBUS_IAP_PASSWORD_WRITE) < 0) {
 352                         dev_err(dev, "cannot write iap password\n");
 353                         return -EIO;
 354                 }
 355
 356                 error = i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
 357                                                    sizeof(cmd), cmd);
 358                 if (error) {
 359                         dev_err(dev, "failed to write iap password: %d\n",
 360                                 error);
 361                         return error;
 362                 }
 363
 364                 /*
 365                  * Read back password to make sure we enabled flash
 366                  * successfully.
 367                  */
 368                 len = i2c_smbus_read_block_data(client,
 369                                                 ETP_SMBUS_IAP_PASSWORD_READ,
 370                                                 val);
 371                 if (len < sizeof(u16)) {
 372                         error = len < 0 ? len : -EIO;
 373                         dev_err(dev, "failed to read iap password: %d\n",
 374                                 error);
 375                         return error;
 376                 }
 377
 378                 password = be16_to_cpup((__be16 *)val);
 379                 if (password != ETP_SMBUS_IAP_PASSWORD) {
 380                         dev_err(dev, "wrong iap password = 0x%X\n", password);
 381                         return -EIO;
 382                 }
 383
 384                 /* Wait 30ms for MAIN_MODE change to IAP_MODE */
 385                 msleep(30);
 386         }
 387
 388         error = elan_smbus_set_flash_key(client);
 389         if (error)
 390                 return error;
 391
 392         /* Reset IC */
 393         error = elan_smbus_iap_reset(client);
 394         if (error)
 395                 return error;
 396
 397         return 0;
 398 }
 399
 400
 401 static int elan_smbus_write_fw_block(struct i2c_client *client,
 402                                      const u8 *page, u16 checksum, int idx)
 403 {
 404         struct device *dev = &client->dev;
 405         int error;
 406         u16 result;
 407         u8 val[3];
 408
 409         /*
 410          * Due to the limitation of smbus protocol limiting
 411          * transfer to 32 bytes at a time, we must split block
 412          * in 2 transfers.
 413          */
 414         error = i2c_smbus_write_block_data(client,
 415                                            ETP_SMBUS_WRITE_FW_BLOCK,
 416                                            ETP_FW_PAGE_SIZE / 2,
 417                                            page);
 418         if (error) {
 419                 dev_err(dev, "Failed to write page %d (part %d): %d\n",
 420                         idx, 1, error);
 421                 return error;
 422         }
 423
 424         error = i2c_smbus_write_block_data(client,
 425                                            ETP_SMBUS_WRITE_FW_BLOCK,
 426                                            ETP_FW_PAGE_SIZE / 2,
 427                                            page + ETP_FW_PAGE_SIZE / 2);
 428         if (error) {
 429                 dev_err(dev, "Failed to write page %d (part %d): %d\n",
 430                         idx, 2, error);
 431                 return error;
 432         }
 433
 434
 435         /* Wait for F/W to update one page ROM data. */
 436         usleep_range(8000, 10000);
 437
 438         error = i2c_smbus_read_block_data(client,
 439                                           ETP_SMBUS_IAP_CTRL_CMD, val);
 440         if (error < 0) {
 441                 dev_err(dev, "Failed to read IAP write result: %d\n",
 442                         error);
 443                 return error;
 444         }
 445
 446         result = be16_to_cpup((__be16 *)val);
 447         if (result & (ETP_FW_IAP_PAGE_ERR | ETP_FW_IAP_INTF_ERR)) {
 448                 dev_err(dev, "IAP reports failed write: %04hx\n",
 449                         result);
 450                 return -EIO;
 451         }
 452
 453         return 0;
 454 }
 455
 456 static int elan_smbus_get_report(struct i2c_client *client, u8 *report)
 457 {
 458         int len;
 459
 460         len = i2c_smbus_read_block_data(client,
 461                                         ETP_SMBUS_PACKET_QUERY,
 462                                         &report[ETP_SMBUS_REPORT_OFFSET]);
 463         if (len < 0) {
 464                 dev_err(&client->dev, "failed to read report data: %d\n", len);
 465                 return len;
 466         }
 467
 468         if (len != ETP_SMBUS_REPORT_LEN) {
 469                 dev_err(&client->dev,
 470                         "wrong report length (%d vs %d expected)\n",
 471                         len, ETP_SMBUS_REPORT_LEN);
 472                 return -EIO;
 473         }
 474
 475         return 0;
 476 }
 477
 478 static int elan_smbus_finish_fw_update(struct i2c_client *client,
 479                                        struct completion *fw_completion)
 480 {
 481         /* No special handling unlike I2C transport */
 482         return 0;
 483 }
 484
 485 const struct elan_transport_ops elan_smbus_ops = {
 486         .initialize             = elan_smbus_initialize,
 487         .sleep_control          = elan_smbus_sleep_control,
 488         .power_control          = elan_smbus_power_control,
 489         .set_mode               = elan_smbus_set_mode,
 490
 491         .calibrate              = elan_smbus_calibrate,
 492         .calibrate_result       = elan_smbus_calibrate_result,
 493
 494         .get_baseline_data      = elan_smbus_get_baseline_data,
 495
 496         .get_version            = elan_smbus_get_version,
 497         .get_sm_version         = elan_smbus_get_sm_version,
 498         .get_product_id         = elan_smbus_get_product_id,
 499         .get_checksum           = elan_smbus_get_checksum,
 500
 501         .get_max                = elan_smbus_get_max,
 502         .get_resolution         = elan_smbus_get_resolution,
 503         .get_num_traces         = elan_smbus_get_num_traces,
 504
 505         .iap_get_mode           = elan_smbus_iap_get_mode,
 506         .iap_reset              = elan_smbus_iap_reset,
 507
 508         .prepare_fw_update      = elan_smbus_prepare_fw_update,
 509         .write_fw_block         = elan_smbus_write_fw_block,
 510         .finish_fw_update       = elan_smbus_finish_fw_update,
 511
 512         .get_report             = elan_smbus_get_report,
 513 };