root/drivers/input/touchscreen/iqs5xx.c

DEFINITIONS

1. iqs5xx_read_burst
2. iqs5xx_read_word
3. iqs5xx_read_byte
4. iqs5xx_write_burst
5. iqs5xx_write_word
6. iqs5xx_write_byte
7. iqs5xx_reset
8. iqs5xx_bl_cmd
9. iqs5xx_bl_open
10. iqs5xx_bl_write
11. iqs5xx_bl_verify
12. iqs5xx_set_state
13. iqs5xx_open
14. iqs5xx_close
15. iqs5xx_axis_init
16. iqs5xx_dev_init
17. iqs5xx_irq
18. iqs5xx_fw_file_parse
19. iqs5xx_fw_file_write
20. fw_file_store
21. iqs5xx_suspend
22. iqs5xx_resume
23. iqs5xx_probe

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Azoteq IQS550/572/525 Trackpad/Touchscreen Controller
   4  *
   5  * Copyright (C) 2018
   6  * Author: Jeff LaBundy <jeff@labundy.com>
   7  *
   8  * These devices require firmware exported from a PC-based configuration tool
   9  * made available by the vendor. Firmware files may be pushed to the device's
  10  * nonvolatile memory by writing the filename to the 'fw_file' sysfs control.
  11  *
  12  * Link to PC-based configuration tool and data sheet: http://www.azoteq.com/
  13  */
  14 
  15 #include <linux/delay.h>
  16 #include <linux/device.h>
  17 #include <linux/err.h>
  18 #include <linux/firmware.h>
  19 #include <linux/gpio/consumer.h>
  20 #include <linux/i2c.h>
  21 #include <linux/input.h>
  22 #include <linux/input/mt.h>
  23 #include <linux/input/touchscreen.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/kernel.h>
  26 #include <linux/module.h>
  27 #include <linux/of_device.h>
  28 #include <linux/slab.h>
  29 #include <asm/unaligned.h>
  30 
  31 #define IQS5XX_FW_FILE_LEN      64
  32 #define IQS5XX_NUM_RETRIES      10
  33 #define IQS5XX_NUM_POINTS       256
  34 #define IQS5XX_NUM_CONTACTS     5
  35 #define IQS5XX_WR_BYTES_MAX     2
  36 
  37 #define IQS5XX_PROD_NUM_IQS550  40
  38 #define IQS5XX_PROD_NUM_IQS572  58
  39 #define IQS5XX_PROD_NUM_IQS525  52
  40 #define IQS5XX_PROJ_NUM_A000    0
  41 #define IQS5XX_PROJ_NUM_B000    15
  42 #define IQS5XX_MAJOR_VER_MIN    2
  43 
  44 #define IQS5XX_RESUME           0x00
  45 #define IQS5XX_SUSPEND          0x01
  46 
  47 #define IQS5XX_SW_INPUT_EVENT   0x10
  48 #define IQS5XX_SETUP_COMPLETE   0x40
  49 #define IQS5XX_EVENT_MODE       0x01
  50 #define IQS5XX_TP_EVENT         0x04
  51 
  52 #define IQS5XX_FLIP_X           0x01
  53 #define IQS5XX_FLIP_Y           0x02
  54 #define IQS5XX_SWITCH_XY_AXIS   0x04
  55 
  56 #define IQS5XX_PROD_NUM         0x0000
  57 #define IQS5XX_ABS_X            0x0016
  58 #define IQS5XX_ABS_Y            0x0018
  59 #define IQS5XX_SYS_CTRL0        0x0431
  60 #define IQS5XX_SYS_CTRL1        0x0432
  61 #define IQS5XX_SYS_CFG0         0x058E
  62 #define IQS5XX_SYS_CFG1         0x058F
  63 #define IQS5XX_TOTAL_RX         0x063D
  64 #define IQS5XX_TOTAL_TX         0x063E
  65 #define IQS5XX_XY_CFG0          0x0669
  66 #define IQS5XX_X_RES            0x066E
  67 #define IQS5XX_Y_RES            0x0670
  68 #define IQS5XX_CHKSM            0x83C0
  69 #define IQS5XX_APP              0x8400
  70 #define IQS5XX_CSTM             0xBE00
  71 #define IQS5XX_PMAP_END         0xBFFF
  72 #define IQS5XX_END_COMM         0xEEEE
  73 
  74 #define IQS5XX_CHKSM_LEN        (IQS5XX_APP - IQS5XX_CHKSM)
  75 #define IQS5XX_APP_LEN          (IQS5XX_CSTM - IQS5XX_APP)
  76 #define IQS5XX_CSTM_LEN         (IQS5XX_PMAP_END + 1 - IQS5XX_CSTM)
  77 #define IQS5XX_PMAP_LEN         (IQS5XX_PMAP_END + 1 - IQS5XX_CHKSM)
  78 
  79 #define IQS5XX_REC_HDR_LEN      4
  80 #define IQS5XX_REC_LEN_MAX      255
  81 #define IQS5XX_REC_TYPE_DATA    0x00
  82 #define IQS5XX_REC_TYPE_EOF     0x01
  83 
  84 #define IQS5XX_BL_ADDR_MASK     0x40
  85 #define IQS5XX_BL_CMD_VER       0x00
  86 #define IQS5XX_BL_CMD_READ      0x01
  87 #define IQS5XX_BL_CMD_EXEC      0x02
  88 #define IQS5XX_BL_CMD_CRC       0x03
  89 #define IQS5XX_BL_BLK_LEN_MAX   64
  90 #define IQS5XX_BL_ID            0x0200
  91 #define IQS5XX_BL_STATUS_RESET  0x00
  92 #define IQS5XX_BL_STATUS_AVAIL  0xA5
  93 #define IQS5XX_BL_STATUS_NONE   0xEE
  94 #define IQS5XX_BL_CRC_PASS      0x00
  95 #define IQS5XX_BL_CRC_FAIL      0x01
  96 #define IQS5XX_BL_ATTEMPTS      3
  97 
  98 struct iqs5xx_private {
  99         struct i2c_client *client;
 100         struct input_dev *input;
 101         struct gpio_desc *reset_gpio;
 102         struct mutex lock;
 103         u8 bl_status;
 104 };
 105 
 106 struct iqs5xx_dev_id_info {
 107         __be16 prod_num;
 108         __be16 proj_num;
 109         u8 major_ver;
 110         u8 minor_ver;
 111         u8 bl_status;
 112 } __packed;
 113 
 114 struct iqs5xx_ihex_rec {
 115         char start;
 116         char len[2];
 117         char addr[4];
 118         char type[2];
 119         char data[2];
 120 } __packed;
 121 
 122 struct iqs5xx_touch_data {
 123         __be16 abs_x;
 124         __be16 abs_y;
 125         __be16 strength;
 126         u8 area;
 127 } __packed;
 128 
 129 static int iqs5xx_read_burst(struct i2c_client *client,
 130                              u16 reg, void *val, u16 len)
 131 {
 132         __be16 reg_buf = cpu_to_be16(reg);
 133         int ret, i;
 134         struct i2c_msg msg[] = {
 135                 {
 136                         .addr = client->addr,
 137                         .flags = 0,
 138                         .len = sizeof(reg_buf),
 139                         .buf = (u8 *)&reg_buf,
 140                 },
 141                 {
 142                         .addr = client->addr,
 143                         .flags = I2C_M_RD,
 144                         .len = len,
 145                         .buf = (u8 *)val,
 146                 },
 147         };
 148 
 149         /*
 150          * The first addressing attempt outside of a communication window fails
 151          * and must be retried, after which the device clock stretches until it
 152          * is available.
 153          */
 154         for (i = 0; i < IQS5XX_NUM_RETRIES; i++) {
 155                 ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
 156                 if (ret == ARRAY_SIZE(msg))
 157                         return 0;
 158 
 159                 usleep_range(200, 300);
 160         }
 161 
 162         if (ret >= 0)
 163                 ret = -EIO;
 164 
 165         dev_err(&client->dev, "Failed to read from address 0x%04X: %d\n",
 166                 reg, ret);
 167 
 168         return ret;
 169 }
 170 
 171 static int iqs5xx_read_word(struct i2c_client *client, u16 reg, u16 *val)
 172 {
 173         __be16 val_buf;
 174         int error;
 175 
 176         error = iqs5xx_read_burst(client, reg, &val_buf, sizeof(val_buf));
 177         if (error)
 178                 return error;
 179 
 180         *val = be16_to_cpu(val_buf);
 181 
 182         return 0;
 183 }
 184 
 185 static int iqs5xx_read_byte(struct i2c_client *client, u16 reg, u8 *val)
 186 {
 187         return iqs5xx_read_burst(client, reg, val, sizeof(*val));
 188 }
 189 
 190 static int iqs5xx_write_burst(struct i2c_client *client,
 191                               u16 reg, const void *val, u16 len)
 192 {
 193         int ret, i;
 194         u16 mlen = sizeof(reg) + len;
 195         u8 mbuf[sizeof(reg) + IQS5XX_WR_BYTES_MAX];
 196 
 197         if (len > IQS5XX_WR_BYTES_MAX)
 198                 return -EINVAL;
 199 
 200         put_unaligned_be16(reg, mbuf);
 201         memcpy(mbuf + sizeof(reg), val, len);
 202 
 203         /*
 204          * The first addressing attempt outside of a communication window fails
 205          * and must be retried, after which the device clock stretches until it
 206          * is available.
 207          */
 208         for (i = 0; i < IQS5XX_NUM_RETRIES; i++) {
 209                 ret = i2c_master_send(client, mbuf, mlen);
 210                 if (ret == mlen)
 211                         return 0;
 212 
 213                 usleep_range(200, 300);
 214         }
 215 
 216         if (ret >= 0)
 217                 ret = -EIO;
 218 
 219         dev_err(&client->dev, "Failed to write to address 0x%04X: %d\n",
 220                 reg, ret);
 221 
 222         return ret;
 223 }
 224 
 225 static int iqs5xx_write_word(struct i2c_client *client, u16 reg, u16 val)
 226 {
 227         __be16 val_buf = cpu_to_be16(val);
 228 
 229         return iqs5xx_write_burst(client, reg, &val_buf, sizeof(val_buf));
 230 }
 231 
 232 static int iqs5xx_write_byte(struct i2c_client *client, u16 reg, u8 val)
 233 {
 234         return iqs5xx_write_burst(client, reg, &val, sizeof(val));
 235 }
 236 
 237 static void iqs5xx_reset(struct i2c_client *client)
 238 {
 239         struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client);
 240 
 241         gpiod_set_value_cansleep(iqs5xx->reset_gpio, 1);
 242         usleep_range(200, 300);
 243 
 244         gpiod_set_value_cansleep(iqs5xx->reset_gpio, 0);
 245 }
 246 
 247 static int iqs5xx_bl_cmd(struct i2c_client *client, u8 bl_cmd, u16 bl_addr)
 248 {
 249         struct i2c_msg msg;
 250         int ret;
 251         u8 mbuf[sizeof(bl_cmd) + sizeof(bl_addr)];
 252 
 253         msg.addr = client->addr ^ IQS5XX_BL_ADDR_MASK;
 254         msg.flags = 0;
 255         msg.len = sizeof(bl_cmd);
 256         msg.buf = mbuf;
 257 
 258         *mbuf = bl_cmd;
 259 
 260         switch (bl_cmd) {
 261         case IQS5XX_BL_CMD_VER:
 262         case IQS5XX_BL_CMD_CRC:
 263         case IQS5XX_BL_CMD_EXEC:
 264                 break;
 265         case IQS5XX_BL_CMD_READ:
 266                 msg.len += sizeof(bl_addr);
 267                 put_unaligned_be16(bl_addr, mbuf + sizeof(bl_cmd));
 268                 break;
 269         default:
 270                 return -EINVAL;
 271         }
 272 
 273         ret = i2c_transfer(client->adapter, &msg, 1);
 274         if (ret != 1)
 275                 goto msg_fail;
 276 
 277         switch (bl_cmd) {
 278         case IQS5XX_BL_CMD_VER:
 279                 msg.len = sizeof(u16);
 280                 break;
 281         case IQS5XX_BL_CMD_CRC:
 282                 msg.len = sizeof(u8);
 283                 /*
 284                  * This delay saves the bus controller the trouble of having to
 285                  * tolerate a relatively long clock-stretching period while the
 286                  * CRC is calculated.
 287                  */
 288                 msleep(50);
 289                 break;
 290         case IQS5XX_BL_CMD_EXEC:
 291                 usleep_range(10000, 10100);
 292                 /* fall through */
 293         default:
 294                 return 0;
 295         }
 296 
 297         msg.flags = I2C_M_RD;
 298 
 299         ret = i2c_transfer(client->adapter, &msg, 1);
 300         if (ret != 1)
 301                 goto msg_fail;
 302 
 303         if (bl_cmd == IQS5XX_BL_CMD_VER &&
 304             get_unaligned_be16(mbuf) != IQS5XX_BL_ID) {
 305                 dev_err(&client->dev, "Unrecognized bootloader ID: 0x%04X\n",
 306                         get_unaligned_be16(mbuf));
 307                 return -EINVAL;
 308         }
 309 
 310         if (bl_cmd == IQS5XX_BL_CMD_CRC && *mbuf != IQS5XX_BL_CRC_PASS) {
 311                 dev_err(&client->dev, "Bootloader CRC failed\n");
 312                 return -EIO;
 313         }
 314 
 315         return 0;
 316 
 317 msg_fail:
 318         if (ret >= 0)
 319                 ret = -EIO;
 320 
 321         if (bl_cmd != IQS5XX_BL_CMD_VER)
 322                 dev_err(&client->dev,
 323                         "Unsuccessful bootloader command 0x%02X: %d\n",
 324                         bl_cmd, ret);
 325 
 326         return ret;
 327 }
 328 
 329 static int iqs5xx_bl_open(struct i2c_client *client)
 330 {
 331         int error, i, j;
 332 
 333         /*
 334          * The device opens a bootloader polling window for 2 ms following the
 335          * release of reset. If the host cannot establish communication during
 336          * this time frame, it must cycle reset again.
 337          */
 338         for (i = 0; i < IQS5XX_BL_ATTEMPTS; i++) {
 339                 iqs5xx_reset(client);
 340 
 341                 for (j = 0; j < IQS5XX_NUM_RETRIES; j++) {
 342                         error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_VER, 0);
 343                         if (!error || error == -EINVAL)
 344                                 return error;
 345                 }
 346         }
 347 
 348         dev_err(&client->dev, "Failed to open bootloader: %d\n", error);
 349 
 350         return error;
 351 }
 352 
 353 static int iqs5xx_bl_write(struct i2c_client *client,
 354                            u16 bl_addr, u8 *pmap_data, u16 pmap_len)
 355 {
 356         struct i2c_msg msg;
 357         int ret, i;
 358         u8 mbuf[sizeof(bl_addr) + IQS5XX_BL_BLK_LEN_MAX];
 359 
 360         if (pmap_len % IQS5XX_BL_BLK_LEN_MAX)
 361                 return -EINVAL;
 362 
 363         msg.addr = client->addr ^ IQS5XX_BL_ADDR_MASK;
 364         msg.flags = 0;
 365         msg.len = sizeof(mbuf);
 366         msg.buf = mbuf;
 367 
 368         for (i = 0; i < pmap_len; i += IQS5XX_BL_BLK_LEN_MAX) {
 369                 put_unaligned_be16(bl_addr + i, mbuf);
 370                 memcpy(mbuf + sizeof(bl_addr), pmap_data + i,
 371                        sizeof(mbuf) - sizeof(bl_addr));
 372 
 373                 ret = i2c_transfer(client->adapter, &msg, 1);
 374                 if (ret != 1)
 375                         goto msg_fail;
 376 
 377                 usleep_range(10000, 10100);
 378         }
 379 
 380         return 0;
 381 
 382 msg_fail:
 383         if (ret >= 0)
 384                 ret = -EIO;
 385 
 386         dev_err(&client->dev, "Failed to write block at address 0x%04X: %d\n",
 387                 bl_addr + i, ret);
 388 
 389         return ret;
 390 }
 391 
 392 static int iqs5xx_bl_verify(struct i2c_client *client,
 393                             u16 bl_addr, u8 *pmap_data, u16 pmap_len)
 394 {
 395         struct i2c_msg msg;
 396         int ret, i;
 397         u8 bl_data[IQS5XX_BL_BLK_LEN_MAX];
 398 
 399         if (pmap_len % IQS5XX_BL_BLK_LEN_MAX)
 400                 return -EINVAL;
 401 
 402         msg.addr = client->addr ^ IQS5XX_BL_ADDR_MASK;
 403         msg.flags = I2C_M_RD;
 404         msg.len = sizeof(bl_data);
 405         msg.buf = bl_data;
 406 
 407         for (i = 0; i < pmap_len; i += IQS5XX_BL_BLK_LEN_MAX) {
 408                 ret = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_READ, bl_addr + i);
 409                 if (ret)
 410                         return ret;
 411 
 412                 ret = i2c_transfer(client->adapter, &msg, 1);
 413                 if (ret != 1)
 414                         goto msg_fail;
 415 
 416                 if (memcmp(bl_data, pmap_data + i, sizeof(bl_data))) {
 417                         dev_err(&client->dev,
 418                                 "Failed to verify block at address 0x%04X\n",
 419                                 bl_addr + i);
 420                         return -EIO;
 421                 }
 422         }
 423 
 424         return 0;
 425 
 426 msg_fail:
 427         if (ret >= 0)
 428                 ret = -EIO;
 429 
 430         dev_err(&client->dev, "Failed to read block at address 0x%04X: %d\n",
 431                 bl_addr + i, ret);
 432 
 433         return ret;
 434 }
 435 
 436 static int iqs5xx_set_state(struct i2c_client *client, u8 state)
 437 {
 438         struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client);
 439         int error1, error2;
 440 
 441         if (iqs5xx->bl_status == IQS5XX_BL_STATUS_RESET)
 442                 return 0;
 443 
 444         mutex_lock(&iqs5xx->lock);
 445 
 446         /*
 447          * Addressing the device outside of a communication window prompts it
 448          * to assert the RDY output, so disable the interrupt line to prevent
 449          * the handler from servicing a false interrupt.
 450          */
 451         disable_irq(client->irq);
 452 
 453         error1 = iqs5xx_write_byte(client, IQS5XX_SYS_CTRL1, state);
 454         error2 = iqs5xx_write_byte(client, IQS5XX_END_COMM, 0);
 455 
 456         usleep_range(50, 100);
 457         enable_irq(client->irq);
 458 
 459         mutex_unlock(&iqs5xx->lock);
 460 
 461         if (error1)
 462                 return error1;
 463 
 464         return error2;
 465 }
 466 
 467 static int iqs5xx_open(struct input_dev *input)
 468 {
 469         struct iqs5xx_private *iqs5xx = input_get_drvdata(input);
 470 
 471         return iqs5xx_set_state(iqs5xx->client, IQS5XX_RESUME);
 472 }
 473 
 474 static void iqs5xx_close(struct input_dev *input)
 475 {
 476         struct iqs5xx_private *iqs5xx = input_get_drvdata(input);
 477 
 478         iqs5xx_set_state(iqs5xx->client, IQS5XX_SUSPEND);
 479 }
 480 
 481 static int iqs5xx_axis_init(struct i2c_client *client)
 482 {
 483         struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client);
 484         struct touchscreen_properties prop;
 485         struct input_dev *input;
 486         int error;
 487         u16 max_x, max_x_hw;
 488         u16 max_y, max_y_hw;
 489         u8 val;
 490 
 491         if (!iqs5xx->input) {
 492                 input = devm_input_allocate_device(&client->dev);
 493                 if (!input)
 494                         return -ENOMEM;
 495 
 496                 input->name = client->name;
 497                 input->id.bustype = BUS_I2C;
 498                 input->open = iqs5xx_open;
 499                 input->close = iqs5xx_close;
 500 
 501                 input_set_capability(input, EV_ABS, ABS_MT_POSITION_X);
 502                 input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y);
 503                 input_set_capability(input, EV_ABS, ABS_MT_PRESSURE);
 504 
 505                 input_set_drvdata(input, iqs5xx);
 506                 iqs5xx->input = input;
 507         }
 508 
 509         touchscreen_parse_properties(iqs5xx->input, true, &prop);
 510 
 511         error = iqs5xx_read_byte(client, IQS5XX_TOTAL_RX, &val);
 512         if (error)
 513                 return error;
 514         max_x_hw = (val - 1) * IQS5XX_NUM_POINTS;
 515 
 516         error = iqs5xx_read_byte(client, IQS5XX_TOTAL_TX, &val);
 517         if (error)
 518                 return error;
 519         max_y_hw = (val - 1) * IQS5XX_NUM_POINTS;
 520 
 521         error = iqs5xx_read_byte(client, IQS5XX_XY_CFG0, &val);
 522         if (error)
 523                 return error;
 524 
 525         if (val & IQS5XX_SWITCH_XY_AXIS)
 526                 swap(max_x_hw, max_y_hw);
 527 
 528         if (prop.swap_x_y)
 529                 val ^= IQS5XX_SWITCH_XY_AXIS;
 530 
 531         if (prop.invert_x)
 532                 val ^= prop.swap_x_y ? IQS5XX_FLIP_Y : IQS5XX_FLIP_X;
 533 
 534         if (prop.invert_y)
 535                 val ^= prop.swap_x_y ? IQS5XX_FLIP_X : IQS5XX_FLIP_Y;
 536 
 537         error = iqs5xx_write_byte(client, IQS5XX_XY_CFG0, val);
 538         if (error)
 539                 return error;
 540 
 541         if (prop.max_x > max_x_hw) {
 542                 dev_err(&client->dev, "Invalid maximum x-coordinate: %u > %u\n",
 543                         prop.max_x, max_x_hw);
 544                 return -EINVAL;
 545         } else if (prop.max_x == 0) {
 546                 error = iqs5xx_read_word(client, IQS5XX_X_RES, &max_x);
 547                 if (error)
 548                         return error;
 549 
 550                 input_abs_set_max(iqs5xx->input,
 551                                   prop.swap_x_y ? ABS_MT_POSITION_Y :
 552                                                   ABS_MT_POSITION_X,
 553                                   max_x);
 554         } else {
 555                 max_x = (u16)prop.max_x;
 556         }
 557 
 558         if (prop.max_y > max_y_hw) {
 559                 dev_err(&client->dev, "Invalid maximum y-coordinate: %u > %u\n",
 560                         prop.max_y, max_y_hw);
 561                 return -EINVAL;
 562         } else if (prop.max_y == 0) {
 563                 error = iqs5xx_read_word(client, IQS5XX_Y_RES, &max_y);
 564                 if (error)
 565                         return error;
 566 
 567                 input_abs_set_max(iqs5xx->input,
 568                                   prop.swap_x_y ? ABS_MT_POSITION_X :
 569                                                   ABS_MT_POSITION_Y,
 570                                   max_y);
 571         } else {
 572                 max_y = (u16)prop.max_y;
 573         }
 574 
 575         /*
 576          * Write horizontal and vertical resolution to the device in case its
 577          * original defaults were overridden or swapped as per the properties
 578          * specified in the device tree.
 579          */
 580         error = iqs5xx_write_word(client,
 581                                   prop.swap_x_y ? IQS5XX_Y_RES : IQS5XX_X_RES,
 582                                   max_x);
 583         if (error)
 584                 return error;
 585 
 586         error = iqs5xx_write_word(client,
 587                                   prop.swap_x_y ? IQS5XX_X_RES : IQS5XX_Y_RES,
 588                                   max_y);
 589         if (error)
 590                 return error;
 591 
 592         error = input_mt_init_slots(iqs5xx->input, IQS5XX_NUM_CONTACTS,
 593                                     INPUT_MT_DIRECT);
 594         if (error)
 595                 dev_err(&client->dev, "Failed to initialize slots: %d\n",
 596                         error);
 597 
 598         return error;
 599 }
 600 
 601 static int iqs5xx_dev_init(struct i2c_client *client)
 602 {
 603         struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client);
 604         struct iqs5xx_dev_id_info *dev_id_info;
 605         int error;
 606         u8 val;
 607         u8 buf[sizeof(*dev_id_info) + 1];
 608 
 609         error = iqs5xx_read_burst(client, IQS5XX_PROD_NUM,
 610                                   &buf[1], sizeof(*dev_id_info));
 611         if (error)
 612                 return iqs5xx_bl_open(client);
 613 
 614         /*
 615          * A000 and B000 devices use 8-bit and 16-bit addressing, respectively.
 616          * Querying an A000 device's version information with 16-bit addressing
 617          * gives the appearance that the data is shifted by one byte; a nonzero
 618          * leading array element suggests this could be the case (in which case
 619          * the missing zero is prepended).
 620          */
 621         buf[0] = 0;
 622         dev_id_info = (struct iqs5xx_dev_id_info *)&buf[(buf[1] > 0) ? 0 : 1];
 623 
 624         switch (be16_to_cpu(dev_id_info->prod_num)) {
 625         case IQS5XX_PROD_NUM_IQS550:
 626         case IQS5XX_PROD_NUM_IQS572:
 627         case IQS5XX_PROD_NUM_IQS525:
 628                 break;
 629         default:
 630                 dev_err(&client->dev, "Unrecognized product number: %u\n",
 631                         be16_to_cpu(dev_id_info->prod_num));
 632                 return -EINVAL;
 633         }
 634 
 635         switch (be16_to_cpu(dev_id_info->proj_num)) {
 636         case IQS5XX_PROJ_NUM_A000:
 637                 dev_err(&client->dev, "Unsupported project number: %u\n",
 638                         be16_to_cpu(dev_id_info->proj_num));
 639                 return iqs5xx_bl_open(client);
 640         case IQS5XX_PROJ_NUM_B000:
 641                 break;
 642         default:
 643                 dev_err(&client->dev, "Unrecognized project number: %u\n",
 644                         be16_to_cpu(dev_id_info->proj_num));
 645                 return -EINVAL;
 646         }
 647 
 648         if (dev_id_info->major_ver < IQS5XX_MAJOR_VER_MIN) {
 649                 dev_err(&client->dev, "Unsupported major version: %u\n",
 650                         dev_id_info->major_ver);
 651                 return iqs5xx_bl_open(client);
 652         }
 653 
 654         switch (dev_id_info->bl_status) {
 655         case IQS5XX_BL_STATUS_AVAIL:
 656         case IQS5XX_BL_STATUS_NONE:
 657                 break;
 658         default:
 659                 dev_err(&client->dev,
 660                         "Unrecognized bootloader status: 0x%02X\n",
 661                         dev_id_info->bl_status);
 662                 return -EINVAL;
 663         }
 664 
 665         error = iqs5xx_axis_init(client);
 666         if (error)
 667                 return error;
 668 
 669         error = iqs5xx_read_byte(client, IQS5XX_SYS_CFG0, &val);
 670         if (error)
 671                 return error;
 672 
 673         val |= IQS5XX_SETUP_COMPLETE;
 674         val &= ~IQS5XX_SW_INPUT_EVENT;
 675         error = iqs5xx_write_byte(client, IQS5XX_SYS_CFG0, val);
 676         if (error)
 677                 return error;
 678 
 679         val = IQS5XX_TP_EVENT | IQS5XX_EVENT_MODE;
 680         error = iqs5xx_write_byte(client, IQS5XX_SYS_CFG1, val);
 681         if (error)
 682                 return error;
 683 
 684         error = iqs5xx_write_byte(client, IQS5XX_END_COMM, 0);
 685         if (error)
 686                 return error;
 687 
 688         iqs5xx->bl_status = dev_id_info->bl_status;
 689 
 690         /*
 691          * Closure of the first communication window that appears following the
 692          * release of reset appears to kick off an initialization period during
 693          * which further communication is met with clock stretching. The return
 694          * from this function is delayed so that further communication attempts
 695          * avoid this period.
 696          */
 697         msleep(100);
 698 
 699         return 0;
 700 }
 701 
 702 static irqreturn_t iqs5xx_irq(int irq, void *data)
 703 {
 704         struct iqs5xx_private *iqs5xx = data;
 705         struct iqs5xx_touch_data touch_data[IQS5XX_NUM_CONTACTS];
 706         struct i2c_client *client = iqs5xx->client;
 707         struct input_dev *input = iqs5xx->input;
 708         int error, i;
 709 
 710         /*
 711          * This check is purely a precaution, as the device does not assert the
 712          * RDY output during bootloader mode. If the device operates outside of
 713          * bootloader mode, the input device is guaranteed to be allocated.
 714          */
 715         if (iqs5xx->bl_status == IQS5XX_BL_STATUS_RESET)
 716                 return IRQ_NONE;
 717 
 718         error = iqs5xx_read_burst(client, IQS5XX_ABS_X,
 719                                   touch_data, sizeof(touch_data));
 720         if (error)
 721                 return IRQ_NONE;
 722 
 723         for (i = 0; i < ARRAY_SIZE(touch_data); i++) {
 724                 u16 pressure = be16_to_cpu(touch_data[i].strength);
 725 
 726                 input_mt_slot(input, i);
 727                 if (input_mt_report_slot_state(input, MT_TOOL_FINGER,
 728                                                pressure != 0)) {
 729                         input_report_abs(input, ABS_MT_POSITION_X,
 730                                          be16_to_cpu(touch_data[i].abs_x));
 731                         input_report_abs(input, ABS_MT_POSITION_Y,
 732                                          be16_to_cpu(touch_data[i].abs_y));
 733                         input_report_abs(input, ABS_MT_PRESSURE, pressure);
 734                 }
 735         }
 736 
 737         input_mt_sync_frame(input);
 738         input_sync(input);
 739 
 740         error = iqs5xx_write_byte(client, IQS5XX_END_COMM, 0);
 741         if (error)
 742                 return IRQ_NONE;
 743 
 744         /*
 745          * Once the communication window is closed, a small delay is added to
 746          * ensure the device's RDY output has been deasserted by the time the
 747          * interrupt handler returns.
 748          */
 749         usleep_range(50, 100);
 750 
 751         return IRQ_HANDLED;
 752 }
 753 
 754 static int iqs5xx_fw_file_parse(struct i2c_client *client,
 755                                 const char *fw_file, u8 *pmap)
 756 {
 757         const struct firmware *fw;
 758         struct iqs5xx_ihex_rec *rec;
 759         size_t pos = 0;
 760         int error, i;
 761         u16 rec_num = 1;
 762         u16 rec_addr;
 763         u8 rec_len, rec_type, rec_chksm, chksm;
 764         u8 rec_hdr[IQS5XX_REC_HDR_LEN];
 765         u8 rec_data[IQS5XX_REC_LEN_MAX];
 766 
 767         /*
 768          * Firmware exported from the vendor's configuration tool deviates from
 769          * standard ihex as follows: (1) the checksum for records corresponding
 770          * to user-exported settings is not recalculated, and (2) an address of
 771          * 0xFFFF is used for the EOF record.
 772          *
 773          * Because the ihex2fw tool tolerates neither (1) nor (2), the slightly
 774          * nonstandard ihex firmware is parsed directly by the driver.
 775          */
 776         error = request_firmware(&fw, fw_file, &client->dev);
 777         if (error) {
 778                 dev_err(&client->dev, "Failed to request firmware %s: %d\n",
 779                         fw_file, error);
 780                 return error;
 781         }
 782 
 783         do {
 784                 if (pos + sizeof(*rec) > fw->size) {
 785                         dev_err(&client->dev, "Insufficient firmware size\n");
 786                         error = -EINVAL;
 787                         break;
 788                 }
 789                 rec = (struct iqs5xx_ihex_rec *)(fw->data + pos);
 790                 pos += sizeof(*rec);
 791 
 792                 if (rec->start != ':') {
 793                         dev_err(&client->dev, "Invalid start at record %u\n",
 794                                 rec_num);
 795                         error = -EINVAL;
 796                         break;
 797                 }
 798 
 799                 error = hex2bin(rec_hdr, rec->len, sizeof(rec_hdr));
 800                 if (error) {
 801                         dev_err(&client->dev, "Invalid header at record %u\n",
 802                                 rec_num);
 803                         break;
 804                 }
 805 
 806                 rec_len = *rec_hdr;
 807                 rec_addr = get_unaligned_be16(rec_hdr + sizeof(rec_len));
 808                 rec_type = *(rec_hdr + sizeof(rec_len) + sizeof(rec_addr));
 809 
 810                 if (pos + rec_len * 2 > fw->size) {
 811                         dev_err(&client->dev, "Insufficient firmware size\n");
 812                         error = -EINVAL;
 813                         break;
 814                 }
 815                 pos += (rec_len * 2);
 816 
 817                 error = hex2bin(rec_data, rec->data, rec_len);
 818                 if (error) {
 819                         dev_err(&client->dev, "Invalid data at record %u\n",
 820                                 rec_num);
 821                         break;
 822                 }
 823 
 824                 error = hex2bin(&rec_chksm,
 825                                 rec->data + rec_len * 2, sizeof(rec_chksm));
 826                 if (error) {
 827                         dev_err(&client->dev, "Invalid checksum at record %u\n",
 828                                 rec_num);
 829                         break;
 830                 }
 831 
 832                 chksm = 0;
 833                 for (i = 0; i < sizeof(rec_hdr); i++)
 834                         chksm += rec_hdr[i];
 835                 for (i = 0; i < rec_len; i++)
 836                         chksm += rec_data[i];
 837                 chksm = ~chksm + 1;
 838 
 839                 if (chksm != rec_chksm && rec_addr < IQS5XX_CSTM) {
 840                         dev_err(&client->dev,
 841                                 "Incorrect checksum at record %u\n",
 842                                 rec_num);
 843                         error = -EINVAL;
 844                         break;
 845                 }
 846 
 847                 switch (rec_type) {
 848                 case IQS5XX_REC_TYPE_DATA:
 849                         if (rec_addr < IQS5XX_CHKSM ||
 850                             rec_addr > IQS5XX_PMAP_END) {
 851                                 dev_err(&client->dev,
 852                                         "Invalid address at record %u\n",
 853                                         rec_num);
 854                                 error = -EINVAL;
 855                         } else {
 856                                 memcpy(pmap + rec_addr - IQS5XX_CHKSM,
 857                                        rec_data, rec_len);
 858                         }
 859                         break;
 860                 case IQS5XX_REC_TYPE_EOF:
 861                         break;
 862                 default:
 863                         dev_err(&client->dev, "Invalid type at record %u\n",
 864                                 rec_num);
 865                         error = -EINVAL;
 866                 }
 867 
 868                 if (error)
 869                         break;
 870 
 871                 rec_num++;
 872                 while (pos < fw->size) {
 873                         if (*(fw->data + pos) == ':')
 874                                 break;
 875                         pos++;
 876                 }
 877         } while (rec_type != IQS5XX_REC_TYPE_EOF);
 878 
 879         release_firmware(fw);
 880 
 881         return error;
 882 }
 883 
 884 static int iqs5xx_fw_file_write(struct i2c_client *client, const char *fw_file)
 885 {
 886         struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client);
 887         int error;
 888         u8 *pmap;
 889 
 890         if (iqs5xx->bl_status == IQS5XX_BL_STATUS_NONE)
 891                 return -EPERM;
 892 
 893         pmap = kzalloc(IQS5XX_PMAP_LEN, GFP_KERNEL);
 894         if (!pmap)
 895                 return -ENOMEM;
 896 
 897         error = iqs5xx_fw_file_parse(client, fw_file, pmap);
 898         if (error)
 899                 goto err_kfree;
 900 
 901         mutex_lock(&iqs5xx->lock);
 902 
 903         /*
 904          * Disable the interrupt line in case the first attempt(s) to enter the
 905          * bootloader don't happen quickly enough, in which case the device may
 906          * assert the RDY output until the next attempt.
 907          */
 908         disable_irq(client->irq);
 909 
 910         iqs5xx->bl_status = IQS5XX_BL_STATUS_RESET;
 911 
 912         error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_VER, 0);
 913         if (error) {
 914                 error = iqs5xx_bl_open(client);
 915                 if (error)
 916                         goto err_reset;
 917         }
 918 
 919         error = iqs5xx_bl_write(client, IQS5XX_CHKSM, pmap, IQS5XX_PMAP_LEN);
 920         if (error)
 921                 goto err_reset;
 922 
 923         error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_CRC, 0);
 924         if (error)
 925                 goto err_reset;
 926 
 927         error = iqs5xx_bl_verify(client, IQS5XX_CSTM,
 928                                  pmap + IQS5XX_CHKSM_LEN + IQS5XX_APP_LEN,
 929                                  IQS5XX_CSTM_LEN);
 930         if (error)
 931                 goto err_reset;
 932 
 933         error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_EXEC, 0);
 934 
 935 err_reset:
 936         if (error) {
 937                 iqs5xx_reset(client);
 938                 usleep_range(10000, 10100);
 939         }
 940 
 941         error = iqs5xx_dev_init(client);
 942         if (!error && iqs5xx->bl_status == IQS5XX_BL_STATUS_RESET)
 943                 error = -EINVAL;
 944 
 945         enable_irq(client->irq);
 946 
 947         mutex_unlock(&iqs5xx->lock);
 948 
 949 err_kfree:
 950         kfree(pmap);
 951 
 952         return error;
 953 }
 954 
 955 static ssize_t fw_file_store(struct device *dev, struct device_attribute *attr,
 956                                 const char *buf, size_t count)
 957 {
 958         struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev);
 959         struct i2c_client *client = iqs5xx->client;
 960         size_t len = count;
 961         bool input_reg = !iqs5xx->input;
 962         char fw_file[IQS5XX_FW_FILE_LEN + 1];
 963         int error;
 964 
 965         if (!len)
 966                 return -EINVAL;
 967 
 968         if (buf[len - 1] == '\n')
 969                 len--;
 970 
 971         if (len > IQS5XX_FW_FILE_LEN)
 972                 return -ENAMETOOLONG;
 973 
 974         memcpy(fw_file, buf, len);
 975         fw_file[len] = '\0';
 976 
 977         error = iqs5xx_fw_file_write(client, fw_file);
 978         if (error)
 979                 return error;
 980 
 981         /*
 982          * If the input device was not allocated already, it is guaranteed to
 983          * be allocated by this point and can finally be registered.
 984          */
 985         if (input_reg) {
 986                 error = input_register_device(iqs5xx->input);
 987                 if (error) {
 988                         dev_err(&client->dev,
 989                                 "Failed to register device: %d\n",
 990                                 error);
 991                         return error;
 992                 }
 993         }
 994 
 995         return count;
 996 }
 997 
 998 static DEVICE_ATTR_WO(fw_file);
 999 
1000 static struct attribute *iqs5xx_attrs[] = {
1001         &dev_attr_fw_file.attr,
1002         NULL,
1003 };
1004 
1005 static const struct attribute_group iqs5xx_attr_group = {
1006         .attrs = iqs5xx_attrs,
1007 };
1008 
1009 static int __maybe_unused iqs5xx_suspend(struct device *dev)
1010 {
1011         struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev);
1012         struct input_dev *input = iqs5xx->input;
1013         int error = 0;
1014 
1015         if (!input)
1016                 return error;
1017 
1018         mutex_lock(&input->mutex);
1019 
1020         if (input->users)
1021                 error = iqs5xx_set_state(iqs5xx->client, IQS5XX_SUSPEND);
1022 
1023         mutex_unlock(&input->mutex);
1024 
1025         return error;
1026 }
1027 
1028 static int __maybe_unused iqs5xx_resume(struct device *dev)
1029 {
1030         struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev);
1031         struct input_dev *input = iqs5xx->input;
1032         int error = 0;
1033 
1034         if (!input)
1035                 return error;
1036 
1037         mutex_lock(&input->mutex);
1038 
1039         if (input->users)
1040                 error = iqs5xx_set_state(iqs5xx->client, IQS5XX_RESUME);
1041 
1042         mutex_unlock(&input->mutex);
1043 
1044         return error;
1045 }
1046 
1047 static SIMPLE_DEV_PM_OPS(iqs5xx_pm, iqs5xx_suspend, iqs5xx_resume);
1048 
1049 static int iqs5xx_probe(struct i2c_client *client,
1050                         const struct i2c_device_id *id)
1051 {
1052         struct iqs5xx_private *iqs5xx;
1053         int error;
1054 
1055         iqs5xx = devm_kzalloc(&client->dev, sizeof(*iqs5xx), GFP_KERNEL);
1056         if (!iqs5xx)
1057                 return -ENOMEM;
1058 
1059         i2c_set_clientdata(client, iqs5xx);
1060         iqs5xx->client = client;
1061 
1062         iqs5xx->reset_gpio = devm_gpiod_get(&client->dev,
1063                                             "reset", GPIOD_OUT_LOW);
1064         if (IS_ERR(iqs5xx->reset_gpio)) {
1065                 error = PTR_ERR(iqs5xx->reset_gpio);
1066                 dev_err(&client->dev, "Failed to request GPIO: %d\n", error);
1067                 return error;
1068         }
1069 
1070         mutex_init(&iqs5xx->lock);
1071 
1072         iqs5xx_reset(client);
1073         usleep_range(10000, 10100);
1074 
1075         error = iqs5xx_dev_init(client);
1076         if (error)
1077                 return error;
1078 
1079         error = devm_request_threaded_irq(&client->dev, client->irq,
1080                                           NULL, iqs5xx_irq, IRQF_ONESHOT,
1081                                           client->name, iqs5xx);
1082         if (error) {
1083                 dev_err(&client->dev, "Failed to request IRQ: %d\n", error);
1084                 return error;
1085         }
1086 
1087         error = devm_device_add_group(&client->dev, &iqs5xx_attr_group);
1088         if (error) {
1089                 dev_err(&client->dev, "Failed to add attributes: %d\n", error);
1090                 return error;
1091         }
1092 
1093         if (iqs5xx->input) {
1094                 error = input_register_device(iqs5xx->input);
1095                 if (error)
1096                         dev_err(&client->dev,
1097                                 "Failed to register device: %d\n",
1098                                 error);
1099         }
1100 
1101         return error;
1102 }
1103 
1104 static const struct i2c_device_id iqs5xx_id[] = {
1105         { "iqs550", 0 },
1106         { "iqs572", 1 },
1107         { "iqs525", 2 },
1108         { }
1109 };
1110 MODULE_DEVICE_TABLE(i2c, iqs5xx_id);
1111 
1112 static const struct of_device_id iqs5xx_of_match[] = {
1113         { .compatible = "azoteq,iqs550" },
1114         { .compatible = "azoteq,iqs572" },
1115         { .compatible = "azoteq,iqs525" },
1116         { }
1117 };
1118 MODULE_DEVICE_TABLE(of, iqs5xx_of_match);
1119 
1120 static struct i2c_driver iqs5xx_i2c_driver = {
1121         .driver = {
1122                 .name           = "iqs5xx",
1123                 .of_match_table = iqs5xx_of_match,
1124                 .pm             = &iqs5xx_pm,
1125         },
1126         .id_table       = iqs5xx_id,
1127         .probe          = iqs5xx_probe,
1128 };
1129 module_i2c_driver(iqs5xx_i2c_driver);
1130 
1131 MODULE_AUTHOR("Jeff LaBundy <jeff@labundy.com>");
1132 MODULE_DESCRIPTION("Azoteq IQS550/572/525 Trackpad/Touchscreen Controller");
1133 MODULE_LICENSE("GPL");