drivers/input/mouse/elan_i2c_smbus.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Elan I2C/SMBus Touchpad driver - SMBus interface
   4  *
   5  * Copyright (c) 2013 ELAN Microelectronics Corp.
   6  *
   7  * Author: 林政維 (Duson Lin) <[email protected]>
   8  *
   9  * Based on cyapa driver:
  10  * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
  11  * copyright (c) 2011-2012 Google, Inc.
  12  *
  13  * Trademarks are the property of their respective owners.
  14  */
  15
  16 #include <linux/delay.h>
  17 #include <linux/i2c.h>
  18 #include <linux/init.h>
  19 #include <linux/kernel.h>
  20
  21 #include "elan_i2c.h"
  22
  23 /* Elan SMbus commands */
  24 #define ETP_SMBUS_IAP_CMD               0x00
  25 #define ETP_SMBUS_ENABLE_TP             0x20
  26 #define ETP_SMBUS_SLEEP_CMD             0x21
  27 #define ETP_SMBUS_IAP_PASSWORD_WRITE    0x29
  28 #define ETP_SMBUS_IAP_PASSWORD_READ     0x80
  29 #define ETP_SMBUS_WRITE_FW_BLOCK        0x2A
  30 #define ETP_SMBUS_IAP_RESET_CMD         0x2B
  31 #define ETP_SMBUS_RANGE_CMD             0xA0
  32 #define ETP_SMBUS_FW_VERSION_CMD        0xA1
  33 #define ETP_SMBUS_XY_TRACENUM_CMD       0xA2
  34 #define ETP_SMBUS_SM_VERSION_CMD        0xA3
  35 #define ETP_SMBUS_UNIQUEID_CMD          0xA3
  36 #define ETP_SMBUS_RESOLUTION_CMD        0xA4
  37 #define ETP_SMBUS_HELLOPACKET_CMD       0xA7
  38 #define ETP_SMBUS_PACKET_QUERY          0xA8
  39 #define ETP_SMBUS_IAP_VERSION_CMD       0xAC
  40 #define ETP_SMBUS_IAP_CTRL_CMD          0xAD
  41 #define ETP_SMBUS_IAP_CHECKSUM_CMD      0xAE
  42 #define ETP_SMBUS_FW_CHECKSUM_CMD       0xAF
  43 #define ETP_SMBUS_MAX_BASELINE_CMD      0xC3
  44 #define ETP_SMBUS_MIN_BASELINE_CMD      0xC4
  45 #define ETP_SMBUS_CALIBRATE_QUERY       0xC5
  46
  47 #define ETP_SMBUS_REPORT_LEN            32
  48 #define ETP_SMBUS_REPORT_OFFSET         2
  49 #define ETP_SMBUS_HELLOPACKET_LEN       5
  50 #define ETP_SMBUS_IAP_PASSWORD          0x1234
  51 #define ETP_SMBUS_IAP_MODE_ON           (1 << 6)
  52
  53 static int elan_smbus_initialize(struct i2c_client *client)
  54 {
  55         u8 check[ETP_SMBUS_HELLOPACKET_LEN] = { 0x55, 0x55, 0x55, 0x55, 0x55 };
  56         u8 values[I2C_SMBUS_BLOCK_MAX] = {0};
  57         int len, error;
  58
  59         /* Get hello packet */
  60         len = i2c_smbus_read_block_data(client,
  61                                         ETP_SMBUS_HELLOPACKET_CMD, values);
  62         if (len != ETP_SMBUS_HELLOPACKET_LEN) {
  63                 dev_err(&client->dev, "hello packet length fail: %d\n", len);
  64                 error = len < 0 ? len : -EIO;
  65                 return error;
  66         }
  67
  68         /* compare hello packet */
  69         if (memcmp(values, check, ETP_SMBUS_HELLOPACKET_LEN)) {
  70                 dev_err(&client->dev, "hello packet fail [%*ph]\n",
  71                         ETP_SMBUS_HELLOPACKET_LEN, values);
  72                 return -ENXIO;
  73         }
  74
  75         /* enable tp */
  76         error = i2c_smbus_write_byte(client, ETP_SMBUS_ENABLE_TP);
  77         if (error) {
  78                 dev_err(&client->dev, "failed to enable touchpad: %d\n", error);
  79                 return error;
  80         }
  81
  82         return 0;
  83 }
  84
  85 static int elan_smbus_set_mode(struct i2c_client *client, u8 mode)
  86 {
  87         u8 cmd[4] = { 0x00, 0x07, 0x00, mode };
  88
  89         return i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
  90                                           sizeof(cmd), cmd);
  91 }
  92
  93 static int elan_smbus_sleep_control(struct i2c_client *client, bool sleep)
  94 {
  95         if (sleep)
  96                 return i2c_smbus_write_byte(client, ETP_SMBUS_SLEEP_CMD);
  97         else
  98                 return 0; /* XXX should we send ETP_SMBUS_ENABLE_TP here? */
  99 }
 100
 101 static int elan_smbus_power_control(struct i2c_client *client, bool enable)
 102 {
 103         return 0; /* A no-op */
 104 }
 105
 106 static int elan_smbus_calibrate(struct i2c_client *client)
 107 {
 108         u8 cmd[4] = { 0x00, 0x08, 0x00, 0x01 };
 109
 110         return i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
 111                                           sizeof(cmd), cmd);
 112 }
 113
 114 static int elan_smbus_calibrate_result(struct i2c_client *client, u8 *val)
 115 {
 116         int error;
 117         u8 buf[I2C_SMBUS_BLOCK_MAX] = {0};
 118
 119         BUILD_BUG_ON(ETP_CALIBRATE_MAX_LEN > sizeof(buf));
 120
 121         error = i2c_smbus_read_block_data(client,
 122                                           ETP_SMBUS_CALIBRATE_QUERY, buf);
 123         if (error < 0)
 124                 return error;
 125
 126         memcpy(val, buf, ETP_CALIBRATE_MAX_LEN);
 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[I2C_SMBUS_BLOCK_MAX] = {0};
 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                                   u8 pattern, bool iap, u8 *version)
 151 {
 152         int error;
 153         u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
 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 pattern,
 170                                      u16 *ic_type, u8 *version, u8 *clickpad)
 171 {
 172         int error;
 173         u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
 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[I2C_SMBUS_BLOCK_MAX] = {0};
 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[I2C_SMBUS_BLOCK_MAX] = {0};
 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[I2C_SMBUS_BLOCK_MAX] = {0};
 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[I2C_SMBUS_BLOCK_MAX] = {0};
 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[I2C_SMBUS_BLOCK_MAX] = {0};
 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[I2C_SMBUS_BLOCK_MAX] = {0};
 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, u16 ic_type,
 343                                         u8 iap_version)
 344 {
 345         struct device *dev = &client->dev;
 346         int len;
 347         int error;
 348         enum tp_mode mode;
 349         u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
 350         u8 cmd[4] = {0x0F, 0x78, 0x00, 0x06};
 351         u16 password;
 352
 353         /* Get FW in which mode (IAP_MODE/MAIN_MODE)  */
 354         error = elan_smbus_iap_get_mode(client, &mode);
 355         if (error)
 356                 return error;
 357
 358         if (mode == MAIN_MODE) {
 359
 360                 /* set flash key */
 361                 error = elan_smbus_set_flash_key(client);
 362                 if (error)
 363                         return error;
 364
 365                 /* write iap password */
 366                 if (i2c_smbus_write_byte(client,
 367                                          ETP_SMBUS_IAP_PASSWORD_WRITE) < 0) {
 368                         dev_err(dev, "cannot write iap password\n");
 369                         return -EIO;
 370                 }
 371
 372                 error = i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
 373                                                    sizeof(cmd), cmd);
 374                 if (error) {
 375                         dev_err(dev, "failed to write iap password: %d\n",
 376                                 error);
 377                         return error;
 378                 }
 379
 380                 /*
 381                  * Read back password to make sure we enabled flash
 382                  * successfully.
 383                  */
 384                 len = i2c_smbus_read_block_data(client,
 385                                                 ETP_SMBUS_IAP_PASSWORD_READ,
 386                                                 val);
 387                 if (len < (int)sizeof(u16)) {
 388                         error = len < 0 ? len : -EIO;
 389                         dev_err(dev, "failed to read iap password: %d\n",
 390                                 error);
 391                         return error;
 392                 }
 393
 394                 password = be16_to_cpup((__be16 *)val);
 395                 if (password != ETP_SMBUS_IAP_PASSWORD) {
 396                         dev_err(dev, "wrong iap password = 0x%X\n", password);
 397                         return -EIO;
 398                 }
 399
 400                 /* Wait 30ms for MAIN_MODE change to IAP_MODE */
 401                 msleep(30);
 402         }
 403
 404         error = elan_smbus_set_flash_key(client);
 405         if (error)
 406                 return error;
 407
 408         /* Reset IC */
 409         error = elan_smbus_iap_reset(client);
 410         if (error)
 411                 return error;
 412
 413         return 0;
 414 }
 415
 416
 417 static int elan_smbus_write_fw_block(struct i2c_client *client, u16 fw_page_size,
 418                                      const u8 *page, u16 checksum, int idx)
 419 {
 420         struct device *dev = &client->dev;
 421         int error;
 422         u16 result;
 423         u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
 424
 425         /*
 426          * Due to the limitation of smbus protocol limiting
 427          * transfer to 32 bytes at a time, we must split block
 428          * in 2 transfers.
 429          */
 430         error = i2c_smbus_write_block_data(client,
 431                                            ETP_SMBUS_WRITE_FW_BLOCK,
 432                                            fw_page_size / 2,
 433                                            page);
 434         if (error) {
 435                 dev_err(dev, "Failed to write page %d (part %d): %d\n",
 436                         idx, 1, error);
 437                 return error;
 438         }
 439
 440         error = i2c_smbus_write_block_data(client,
 441                                            ETP_SMBUS_WRITE_FW_BLOCK,
 442                                            fw_page_size / 2,
 443                                            page + fw_page_size / 2);
 444         if (error) {
 445                 dev_err(dev, "Failed to write page %d (part %d): %d\n",
 446                         idx, 2, error);
 447                 return error;
 448         }
 449
 450
 451         /* Wait for F/W to update one page ROM data. */
 452         usleep_range(8000, 10000);
 453
 454         error = i2c_smbus_read_block_data(client,
 455                                           ETP_SMBUS_IAP_CTRL_CMD, val);
 456         if (error < 0) {
 457                 dev_err(dev, "Failed to read IAP write result: %d\n",
 458                         error);
 459                 return error;
 460         }
 461
 462         result = be16_to_cpup((__be16 *)val);
 463         if (result & (ETP_FW_IAP_PAGE_ERR | ETP_FW_IAP_INTF_ERR)) {
 464                 dev_err(dev, "IAP reports failed write: %04hx\n",
 465                         result);
 466                 return -EIO;
 467         }
 468
 469         return 0;
 470 }
 471
 472 static int elan_smbus_get_report_features(struct i2c_client *client, u8 pattern,
 473                                           unsigned int *features,
 474                                           unsigned int *report_len)
 475 {
 476         /*
 477          * SMBus controllers with pattern 2 lack area info, as newer
 478          * high-precision packets use that space for coordinates.
 479          */
 480         *features = pattern <= 0x01 ? ETP_FEATURE_REPORT_MK : 0;
 481         *report_len = ETP_SMBUS_REPORT_LEN;
 482         return 0;
 483 }
 484
 485 static int elan_smbus_get_report(struct i2c_client *client,
 486                                  u8 *report, unsigned int report_len)
 487 {
 488         int len;
 489
 490         BUILD_BUG_ON(I2C_SMBUS_BLOCK_MAX > ETP_SMBUS_REPORT_LEN);
 491
 492         len = i2c_smbus_read_block_data(client,
 493                                         ETP_SMBUS_PACKET_QUERY,
 494                                         &report[ETP_SMBUS_REPORT_OFFSET]);
 495         if (len < 0) {
 496                 dev_err(&client->dev, "failed to read report data: %d\n", len);
 497                 return len;
 498         }
 499
 500         if (len != ETP_SMBUS_REPORT_LEN) {
 501                 dev_err(&client->dev,
 502                         "wrong report length (%d vs %d expected)\n",
 503                         len, ETP_SMBUS_REPORT_LEN);
 504                 return -EIO;
 505         }
 506
 507         return 0;
 508 }
 509
 510 static int elan_smbus_finish_fw_update(struct i2c_client *client,
 511                                        struct completion *fw_completion)
 512 {
 513         /* No special handling unlike I2C transport */
 514         return 0;
 515 }
 516
 517 static int elan_smbus_get_pattern(struct i2c_client *client, u8 *pattern)
 518 {
 519         *pattern = 0;
 520         return 0;
 521 }
 522
 523 const struct elan_transport_ops elan_smbus_ops = {
 524         .initialize             = elan_smbus_initialize,
 525         .sleep_control          = elan_smbus_sleep_control,
 526         .power_control          = elan_smbus_power_control,
 527         .set_mode               = elan_smbus_set_mode,
 528
 529         .calibrate              = elan_smbus_calibrate,
 530         .calibrate_result       = elan_smbus_calibrate_result,
 531
 532         .get_baseline_data      = elan_smbus_get_baseline_data,
 533
 534         .get_version            = elan_smbus_get_version,
 535         .get_sm_version         = elan_smbus_get_sm_version,
 536         .get_product_id         = elan_smbus_get_product_id,
 537         .get_checksum           = elan_smbus_get_checksum,
 538         .get_pressure_adjustment = elan_smbus_get_pressure_adjustment,
 539
 540         .get_max                = elan_smbus_get_max,
 541         .get_resolution         = elan_smbus_get_resolution,
 542         .get_num_traces         = elan_smbus_get_num_traces,
 543
 544         .iap_get_mode           = elan_smbus_iap_get_mode,
 545         .iap_reset              = elan_smbus_iap_reset,
 546
 547         .prepare_fw_update      = elan_smbus_prepare_fw_update,
 548         .write_fw_block         = elan_smbus_write_fw_block,
 549         .finish_fw_update       = elan_smbus_finish_fw_update,
 550
 551         .get_report_features    = elan_smbus_get_report_features,
 552         .get_report             = elan_smbus_get_report,
 553         .get_pattern            = elan_smbus_get_pattern,
 554 };