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