drivers/input/misc/iqs269a.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Azoteq IQS269A Capacitive Touch Controller
   4  *
   5  * Copyright (C) 2020 Jeff LaBundy <jeff@labundy.com>
   6  *
   7  * This driver registers up to 3 input devices: one representing capacitive or
   8  * inductive keys as well as Hall-effect switches, and one for each of the two
   9  * axial sliders presented by the device.
  10  */
  11
  12 #include <linux/delay.h>
  13 #include <linux/device.h>
  14 #include <linux/err.h>
  15 #include <linux/i2c.h>
  16 #include <linux/input.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/mutex.h>
  21 #include <linux/of_device.h>
  22 #include <linux/property.h>
  23 #include <linux/regmap.h>
  24 #include <linux/slab.h>
  25
  26 #define IQS269_VER_INFO                         0x00
  27 #define IQS269_VER_INFO_PROD_NUM                0x4F
  28
  29 #define IQS269_SYS_FLAGS                        0x02
  30 #define IQS269_SYS_FLAGS_SHOW_RESET             BIT(15)
  31 #define IQS269_SYS_FLAGS_PWR_MODE_MASK          GENMASK(12, 11)
  32 #define IQS269_SYS_FLAGS_PWR_MODE_SHIFT         11
  33 #define IQS269_SYS_FLAGS_IN_ATI                 BIT(10)
  34
  35 #define IQS269_CHx_COUNTS                       0x08
  36
  37 #define IQS269_SLIDER_X                         0x30
  38
  39 #define IQS269_CAL_DATA_A                       0x35
  40 #define IQS269_CAL_DATA_A_HALL_BIN_L_MASK       GENMASK(15, 12)
  41 #define IQS269_CAL_DATA_A_HALL_BIN_L_SHIFT      12
  42 #define IQS269_CAL_DATA_A_HALL_BIN_R_MASK       GENMASK(11, 8)
  43 #define IQS269_CAL_DATA_A_HALL_BIN_R_SHIFT      8
  44
  45 #define IQS269_SYS_SETTINGS                     0x80
  46 #define IQS269_SYS_SETTINGS_CLK_DIV             BIT(15)
  47 #define IQS269_SYS_SETTINGS_ULP_AUTO            BIT(14)
  48 #define IQS269_SYS_SETTINGS_DIS_AUTO            BIT(13)
  49 #define IQS269_SYS_SETTINGS_PWR_MODE_MASK       GENMASK(12, 11)
  50 #define IQS269_SYS_SETTINGS_PWR_MODE_SHIFT      11
  51 #define IQS269_SYS_SETTINGS_PWR_MODE_MAX        3
  52 #define IQS269_SYS_SETTINGS_ULP_UPDATE_MASK     GENMASK(10, 8)
  53 #define IQS269_SYS_SETTINGS_ULP_UPDATE_SHIFT    8
  54 #define IQS269_SYS_SETTINGS_ULP_UPDATE_MAX      7
  55 #define IQS269_SYS_SETTINGS_RESEED_OFFSET       BIT(6)
  56 #define IQS269_SYS_SETTINGS_EVENT_MODE          BIT(5)
  57 #define IQS269_SYS_SETTINGS_EVENT_MODE_LP       BIT(4)
  58 #define IQS269_SYS_SETTINGS_REDO_ATI            BIT(2)
  59 #define IQS269_SYS_SETTINGS_ACK_RESET           BIT(0)
  60
  61 #define IQS269_FILT_STR_LP_LTA_MASK             GENMASK(7, 6)
  62 #define IQS269_FILT_STR_LP_LTA_SHIFT            6
  63 #define IQS269_FILT_STR_LP_CNT_MASK             GENMASK(5, 4)
  64 #define IQS269_FILT_STR_LP_CNT_SHIFT            4
  65 #define IQS269_FILT_STR_NP_LTA_MASK             GENMASK(3, 2)
  66 #define IQS269_FILT_STR_NP_LTA_SHIFT            2
  67 #define IQS269_FILT_STR_NP_CNT_MASK             GENMASK(1, 0)
  68 #define IQS269_FILT_STR_MAX                     3
  69
  70 #define IQS269_EVENT_MASK_SYS                   BIT(6)
  71 #define IQS269_EVENT_MASK_DEEP                  BIT(2)
  72 #define IQS269_EVENT_MASK_TOUCH                 BIT(1)
  73 #define IQS269_EVENT_MASK_PROX                  BIT(0)
  74
  75 #define IQS269_RATE_NP_MS_MAX                   255
  76 #define IQS269_RATE_LP_MS_MAX                   255
  77 #define IQS269_RATE_ULP_MS_MAX                  4080
  78 #define IQS269_TIMEOUT_PWR_MS_MAX               130560
  79 #define IQS269_TIMEOUT_LTA_MS_MAX               130560
  80
  81 #define IQS269_MISC_A_ATI_BAND_DISABLE          BIT(15)
  82 #define IQS269_MISC_A_ATI_LP_ONLY               BIT(14)
  83 #define IQS269_MISC_A_ATI_BAND_TIGHTEN          BIT(13)
  84 #define IQS269_MISC_A_FILT_DISABLE              BIT(12)
  85 #define IQS269_MISC_A_GPIO3_SELECT_MASK         GENMASK(10, 8)
  86 #define IQS269_MISC_A_GPIO3_SELECT_SHIFT        8
  87 #define IQS269_MISC_A_DUAL_DIR                  BIT(6)
  88 #define IQS269_MISC_A_TX_FREQ_MASK              GENMASK(5, 4)
  89 #define IQS269_MISC_A_TX_FREQ_SHIFT             4
  90 #define IQS269_MISC_A_TX_FREQ_MAX               3
  91 #define IQS269_MISC_A_GLOBAL_CAP_SIZE           BIT(0)
  92
  93 #define IQS269_MISC_B_RESEED_UI_SEL_MASK        GENMASK(7, 6)
  94 #define IQS269_MISC_B_RESEED_UI_SEL_SHIFT       6
  95 #define IQS269_MISC_B_RESEED_UI_SEL_MAX         3
  96 #define IQS269_MISC_B_TRACKING_UI_ENABLE        BIT(4)
  97 #define IQS269_MISC_B_FILT_STR_SLIDER           GENMASK(1, 0)
  98
  99 #define IQS269_CHx_SETTINGS                     0x8C
 100
 101 #define IQS269_CHx_ENG_A_MEAS_CAP_SIZE          BIT(15)
 102 #define IQS269_CHx_ENG_A_RX_GND_INACTIVE        BIT(13)
 103 #define IQS269_CHx_ENG_A_LOCAL_CAP_SIZE         BIT(12)
 104 #define IQS269_CHx_ENG_A_ATI_MODE_MASK          GENMASK(9, 8)
 105 #define IQS269_CHx_ENG_A_ATI_MODE_SHIFT         8
 106 #define IQS269_CHx_ENG_A_ATI_MODE_MAX           3
 107 #define IQS269_CHx_ENG_A_INV_LOGIC              BIT(7)
 108 #define IQS269_CHx_ENG_A_PROJ_BIAS_MASK         GENMASK(6, 5)
 109 #define IQS269_CHx_ENG_A_PROJ_BIAS_SHIFT        5
 110 #define IQS269_CHx_ENG_A_PROJ_BIAS_MAX          3
 111 #define IQS269_CHx_ENG_A_SENSE_MODE_MASK        GENMASK(3, 0)
 112 #define IQS269_CHx_ENG_A_SENSE_MODE_MAX         15
 113
 114 #define IQS269_CHx_ENG_B_LOCAL_CAP_ENABLE       BIT(13)
 115 #define IQS269_CHx_ENG_B_SENSE_FREQ_MASK        GENMASK(10, 9)
 116 #define IQS269_CHx_ENG_B_SENSE_FREQ_SHIFT       9
 117 #define IQS269_CHx_ENG_B_SENSE_FREQ_MAX         3
 118 #define IQS269_CHx_ENG_B_STATIC_ENABLE          BIT(8)
 119 #define IQS269_CHx_ENG_B_ATI_BASE_MASK          GENMASK(7, 6)
 120 #define IQS269_CHx_ENG_B_ATI_BASE_75            0x00
 121 #define IQS269_CHx_ENG_B_ATI_BASE_100           0x40
 122 #define IQS269_CHx_ENG_B_ATI_BASE_150           0x80
 123 #define IQS269_CHx_ENG_B_ATI_BASE_200           0xC0
 124 #define IQS269_CHx_ENG_B_ATI_TARGET_MASK        GENMASK(5, 0)
 125 #define IQS269_CHx_ENG_B_ATI_TARGET_MAX         2016
 126
 127 #define IQS269_CHx_WEIGHT_MAX                   255
 128 #define IQS269_CHx_THRESH_MAX                   255
 129 #define IQS269_CHx_HYST_DEEP_MASK               GENMASK(7, 4)
 130 #define IQS269_CHx_HYST_DEEP_SHIFT              4
 131 #define IQS269_CHx_HYST_TOUCH_MASK              GENMASK(3, 0)
 132 #define IQS269_CHx_HYST_MAX                     15
 133
 134 #define IQS269_CHx_HALL_INACTIVE                6
 135 #define IQS269_CHx_HALL_ACTIVE                  7
 136
 137 #define IQS269_HALL_PAD_R                       BIT(0)
 138 #define IQS269_HALL_PAD_L                       BIT(1)
 139 #define IQS269_HALL_PAD_INV                     BIT(6)
 140
 141 #define IQS269_HALL_UI                          0xF5
 142 #define IQS269_HALL_UI_ENABLE                   BIT(15)
 143
 144 #define IQS269_MAX_REG                          0xFF
 145
 146 #define IQS269_NUM_CH                           8
 147 #define IQS269_NUM_SL                           2
 148
 149 #define IQS269_ATI_POLL_SLEEP_US                (iqs269->delay_mult * 10000)
 150 #define IQS269_ATI_POLL_TIMEOUT_US              (iqs269->delay_mult * 500000)
 151 #define IQS269_ATI_STABLE_DELAY_MS              (iqs269->delay_mult * 150)
 152
 153 #define IQS269_PWR_MODE_POLL_SLEEP_US           IQS269_ATI_POLL_SLEEP_US
 154 #define IQS269_PWR_MODE_POLL_TIMEOUT_US         IQS269_ATI_POLL_TIMEOUT_US
 155
 156 #define iqs269_irq_wait()                       usleep_range(100, 150)
 157
 158 enum iqs269_local_cap_size {
 159         IQS269_LOCAL_CAP_SIZE_0,
 160         IQS269_LOCAL_CAP_SIZE_GLOBAL_ONLY,
 161         IQS269_LOCAL_CAP_SIZE_GLOBAL_0pF5,
 162 };
 163
 164 enum iqs269_st_offs {
 165         IQS269_ST_OFFS_PROX,
 166         IQS269_ST_OFFS_DIR,
 167         IQS269_ST_OFFS_TOUCH,
 168         IQS269_ST_OFFS_DEEP,
 169 };
 170
 171 enum iqs269_th_offs {
 172         IQS269_TH_OFFS_PROX,
 173         IQS269_TH_OFFS_TOUCH,
 174         IQS269_TH_OFFS_DEEP,
 175 };
 176
 177 enum iqs269_event_id {
 178         IQS269_EVENT_PROX_DN,
 179         IQS269_EVENT_PROX_UP,
 180         IQS269_EVENT_TOUCH_DN,
 181         IQS269_EVENT_TOUCH_UP,
 182         IQS269_EVENT_DEEP_DN,
 183         IQS269_EVENT_DEEP_UP,
 184 };
 185
 186 struct iqs269_switch_desc {
 187         unsigned int code;
 188         bool enabled;
 189 };
 190
 191 struct iqs269_event_desc {
 192         const char *name;
 193         enum iqs269_st_offs st_offs;
 194         enum iqs269_th_offs th_offs;
 195         bool dir_up;
 196         u8 mask;
 197 };
 198
 199 static const struct iqs269_event_desc iqs269_events[] = {
 200         [IQS269_EVENT_PROX_DN] = {
 201                 .name = "event-prox",
 202                 .st_offs = IQS269_ST_OFFS_PROX,
 203                 .th_offs = IQS269_TH_OFFS_PROX,
 204                 .mask = IQS269_EVENT_MASK_PROX,
 205         },
 206         [IQS269_EVENT_PROX_UP] = {
 207                 .name = "event-prox-alt",
 208                 .st_offs = IQS269_ST_OFFS_PROX,
 209                 .th_offs = IQS269_TH_OFFS_PROX,
 210                 .dir_up = true,
 211                 .mask = IQS269_EVENT_MASK_PROX,
 212         },
 213         [IQS269_EVENT_TOUCH_DN] = {
 214                 .name = "event-touch",
 215                 .st_offs = IQS269_ST_OFFS_TOUCH,
 216                 .th_offs = IQS269_TH_OFFS_TOUCH,
 217                 .mask = IQS269_EVENT_MASK_TOUCH,
 218         },
 219         [IQS269_EVENT_TOUCH_UP] = {
 220                 .name = "event-touch-alt",
 221                 .st_offs = IQS269_ST_OFFS_TOUCH,
 222                 .th_offs = IQS269_TH_OFFS_TOUCH,
 223                 .dir_up = true,
 224                 .mask = IQS269_EVENT_MASK_TOUCH,
 225         },
 226         [IQS269_EVENT_DEEP_DN] = {
 227                 .name = "event-deep",
 228                 .st_offs = IQS269_ST_OFFS_DEEP,
 229                 .th_offs = IQS269_TH_OFFS_DEEP,
 230                 .mask = IQS269_EVENT_MASK_DEEP,
 231         },
 232         [IQS269_EVENT_DEEP_UP] = {
 233                 .name = "event-deep-alt",
 234                 .st_offs = IQS269_ST_OFFS_DEEP,
 235                 .th_offs = IQS269_TH_OFFS_DEEP,
 236                 .dir_up = true,
 237                 .mask = IQS269_EVENT_MASK_DEEP,
 238         },
 239 };
 240
 241 struct iqs269_ver_info {
 242         u8 prod_num;
 243         u8 sw_num;
 244         u8 hw_num;
 245         u8 padding;
 246 } __packed;
 247
 248 struct iqs269_sys_reg {
 249         __be16 general;
 250         u8 active;
 251         u8 filter;
 252         u8 reseed;
 253         u8 event_mask;
 254         u8 rate_np;
 255         u8 rate_lp;
 256         u8 rate_ulp;
 257         u8 timeout_pwr;
 258         u8 timeout_rdy;
 259         u8 timeout_lta;
 260         __be16 misc_a;
 261         __be16 misc_b;
 262         u8 blocking;
 263         u8 padding;
 264         u8 slider_select[IQS269_NUM_SL];
 265         u8 timeout_tap;
 266         u8 timeout_swipe;
 267         u8 thresh_swipe;
 268         u8 redo_ati;
 269 } __packed;
 270
 271 struct iqs269_ch_reg {
 272         u8 rx_enable;
 273         u8 tx_enable;
 274         __be16 engine_a;
 275         __be16 engine_b;
 276         __be16 ati_comp;
 277         u8 thresh[3];
 278         u8 hyst;
 279         u8 assoc_select;
 280         u8 assoc_weight;
 281 } __packed;
 282
 283 struct iqs269_flags {
 284         __be16 system;
 285         u8 gesture;
 286         u8 padding;
 287         u8 states[4];
 288 } __packed;
 289
 290 struct iqs269_private {
 291         struct i2c_client *client;
 292         struct regmap *regmap;
 293         struct mutex lock;
 294         struct iqs269_switch_desc switches[ARRAY_SIZE(iqs269_events)];
 295         struct iqs269_ch_reg ch_reg[IQS269_NUM_CH];
 296         struct iqs269_sys_reg sys_reg;
 297         struct input_dev *keypad;
 298         struct input_dev *slider[IQS269_NUM_SL];
 299         unsigned int keycode[ARRAY_SIZE(iqs269_events) * IQS269_NUM_CH];
 300         unsigned int suspend_mode;
 301         unsigned int delay_mult;
 302         unsigned int ch_num;
 303         bool hall_enable;
 304         bool ati_current;
 305 };
 306
 307 static int iqs269_ati_mode_set(struct iqs269_private *iqs269,
 308                                unsigned int ch_num, unsigned int mode)
 309 {
 310         u16 engine_a;
 311
 312         if (ch_num >= IQS269_NUM_CH)
 313                 return -EINVAL;
 314
 315         if (mode > IQS269_CHx_ENG_A_ATI_MODE_MAX)
 316                 return -EINVAL;
 317
 318         mutex_lock(&iqs269->lock);
 319
 320         engine_a = be16_to_cpu(iqs269->ch_reg[ch_num].engine_a);
 321
 322         engine_a &= ~IQS269_CHx_ENG_A_ATI_MODE_MASK;
 323         engine_a |= (mode << IQS269_CHx_ENG_A_ATI_MODE_SHIFT);
 324
 325         iqs269->ch_reg[ch_num].engine_a = cpu_to_be16(engine_a);
 326         iqs269->ati_current = false;
 327
 328         mutex_unlock(&iqs269->lock);
 329
 330         return 0;
 331 }
 332
 333 static int iqs269_ati_mode_get(struct iqs269_private *iqs269,
 334                                unsigned int ch_num, unsigned int *mode)
 335 {
 336         u16 engine_a;
 337
 338         if (ch_num >= IQS269_NUM_CH)
 339                 return -EINVAL;
 340
 341         mutex_lock(&iqs269->lock);
 342         engine_a = be16_to_cpu(iqs269->ch_reg[ch_num].engine_a);
 343         mutex_unlock(&iqs269->lock);
 344
 345         engine_a &= IQS269_CHx_ENG_A_ATI_MODE_MASK;
 346         *mode = (engine_a >> IQS269_CHx_ENG_A_ATI_MODE_SHIFT);
 347
 348         return 0;
 349 }
 350
 351 static int iqs269_ati_base_set(struct iqs269_private *iqs269,
 352                                unsigned int ch_num, unsigned int base)
 353 {
 354         u16 engine_b;
 355
 356         if (ch_num >= IQS269_NUM_CH)
 357                 return -EINVAL;
 358
 359         switch (base) {
 360         case 75:
 361                 base = IQS269_CHx_ENG_B_ATI_BASE_75;
 362                 break;
 363
 364         case 100:
 365                 base = IQS269_CHx_ENG_B_ATI_BASE_100;
 366                 break;
 367
 368         case 150:
 369                 base = IQS269_CHx_ENG_B_ATI_BASE_150;
 370                 break;
 371
 372         case 200:
 373                 base = IQS269_CHx_ENG_B_ATI_BASE_200;
 374                 break;
 375
 376         default:
 377                 return -EINVAL;
 378         }
 379
 380         mutex_lock(&iqs269->lock);
 381
 382         engine_b = be16_to_cpu(iqs269->ch_reg[ch_num].engine_b);
 383
 384         engine_b &= ~IQS269_CHx_ENG_B_ATI_BASE_MASK;
 385         engine_b |= base;
 386
 387         iqs269->ch_reg[ch_num].engine_b = cpu_to_be16(engine_b);
 388         iqs269->ati_current = false;
 389
 390         mutex_unlock(&iqs269->lock);
 391
 392         return 0;
 393 }
 394
 395 static int iqs269_ati_base_get(struct iqs269_private *iqs269,
 396                                unsigned int ch_num, unsigned int *base)
 397 {
 398         u16 engine_b;
 399
 400         if (ch_num >= IQS269_NUM_CH)
 401                 return -EINVAL;
 402
 403         mutex_lock(&iqs269->lock);
 404         engine_b = be16_to_cpu(iqs269->ch_reg[ch_num].engine_b);
 405         mutex_unlock(&iqs269->lock);
 406
 407         switch (engine_b & IQS269_CHx_ENG_B_ATI_BASE_MASK) {
 408         case IQS269_CHx_ENG_B_ATI_BASE_75:
 409                 *base = 75;
 410                 return 0;
 411
 412         case IQS269_CHx_ENG_B_ATI_BASE_100:
 413                 *base = 100;
 414                 return 0;
 415
 416         case IQS269_CHx_ENG_B_ATI_BASE_150:
 417                 *base = 150;
 418                 return 0;
 419
 420         case IQS269_CHx_ENG_B_ATI_BASE_200:
 421                 *base = 200;
 422                 return 0;
 423
 424         default:
 425                 return -EINVAL;
 426         }
 427 }
 428
 429 static int iqs269_ati_target_set(struct iqs269_private *iqs269,
 430                                  unsigned int ch_num, unsigned int target)
 431 {
 432         u16 engine_b;
 433
 434         if (ch_num >= IQS269_NUM_CH)
 435                 return -EINVAL;
 436
 437         if (target > IQS269_CHx_ENG_B_ATI_TARGET_MAX)
 438                 return -EINVAL;
 439
 440         mutex_lock(&iqs269->lock);
 441
 442         engine_b = be16_to_cpu(iqs269->ch_reg[ch_num].engine_b);
 443
 444         engine_b &= ~IQS269_CHx_ENG_B_ATI_TARGET_MASK;
 445         engine_b |= target / 32;
 446
 447         iqs269->ch_reg[ch_num].engine_b = cpu_to_be16(engine_b);
 448         iqs269->ati_current = false;
 449
 450         mutex_unlock(&iqs269->lock);
 451
 452         return 0;
 453 }
 454
 455 static int iqs269_ati_target_get(struct iqs269_private *iqs269,
 456                                  unsigned int ch_num, unsigned int *target)
 457 {
 458         u16 engine_b;
 459
 460         if (ch_num >= IQS269_NUM_CH)
 461                 return -EINVAL;
 462
 463         mutex_lock(&iqs269->lock);
 464         engine_b = be16_to_cpu(iqs269->ch_reg[ch_num].engine_b);
 465         mutex_unlock(&iqs269->lock);
 466
 467         *target = (engine_b & IQS269_CHx_ENG_B_ATI_TARGET_MASK) * 32;
 468
 469         return 0;
 470 }
 471
 472 static int iqs269_parse_mask(const struct fwnode_handle *fwnode,
 473                              const char *propname, u8 *mask)
 474 {
 475         unsigned int val[IQS269_NUM_CH];
 476         int count, error, i;
 477
 478         count = fwnode_property_count_u32(fwnode, propname);
 479         if (count < 0)
 480                 return 0;
 481
 482         if (count > IQS269_NUM_CH)
 483                 return -EINVAL;
 484
 485         error = fwnode_property_read_u32_array(fwnode, propname, val, count);
 486         if (error)
 487                 return error;
 488
 489         *mask = 0;
 490
 491         for (i = 0; i < count; i++) {
 492                 if (val[i] >= IQS269_NUM_CH)
 493                         return -EINVAL;
 494
 495                 *mask |= BIT(val[i]);
 496         }
 497
 498         return 0;
 499 }
 500
 501 static int iqs269_parse_chan(struct iqs269_private *iqs269,
 502                              const struct fwnode_handle *ch_node)
 503 {
 504         struct i2c_client *client = iqs269->client;
 505         struct fwnode_handle *ev_node;
 506         struct iqs269_ch_reg *ch_reg;
 507         u16 engine_a, engine_b;
 508         unsigned int reg, val;
 509         int error, i;
 510
 511         error = fwnode_property_read_u32(ch_node, "reg", &reg);
 512         if (error) {
 513                 dev_err(&client->dev, "Failed to read channel number: %d\n",
 514                         error);
 515                 return error;
 516         } else if (reg >= IQS269_NUM_CH) {
 517                 dev_err(&client->dev, "Invalid channel number: %u\n", reg);
 518                 return -EINVAL;
 519         }
 520
 521         iqs269->sys_reg.active |= BIT(reg);
 522         if (!fwnode_property_present(ch_node, "azoteq,reseed-disable"))
 523                 iqs269->sys_reg.reseed |= BIT(reg);
 524
 525         if (fwnode_property_present(ch_node, "azoteq,blocking-enable"))
 526                 iqs269->sys_reg.blocking |= BIT(reg);
 527
 528         if (fwnode_property_present(ch_node, "azoteq,slider0-select"))
 529                 iqs269->sys_reg.slider_select[0] |= BIT(reg);
 530
 531         if (fwnode_property_present(ch_node, "azoteq,slider1-select"))
 532                 iqs269->sys_reg.slider_select[1] |= BIT(reg);
 533
 534         ch_reg = &iqs269->ch_reg[reg];
 535
 536         error = regmap_raw_read(iqs269->regmap,
 537                                 IQS269_CHx_SETTINGS + reg * sizeof(*ch_reg) / 2,
 538                                 ch_reg, sizeof(*ch_reg));
 539         if (error)
 540                 return error;
 541
 542         error = iqs269_parse_mask(ch_node, "azoteq,rx-enable",
 543                                   &ch_reg->rx_enable);
 544         if (error) {
 545                 dev_err(&client->dev, "Invalid channel %u RX enable mask: %d\n",
 546                         reg, error);
 547                 return error;
 548         }
 549
 550         error = iqs269_parse_mask(ch_node, "azoteq,tx-enable",
 551                                   &ch_reg->tx_enable);
 552         if (error) {
 553                 dev_err(&client->dev, "Invalid channel %u TX enable mask: %d\n",
 554                         reg, error);
 555                 return error;
 556         }
 557
 558         engine_a = be16_to_cpu(ch_reg->engine_a);
 559         engine_b = be16_to_cpu(ch_reg->engine_b);
 560
 561         engine_a |= IQS269_CHx_ENG_A_MEAS_CAP_SIZE;
 562         if (fwnode_property_present(ch_node, "azoteq,meas-cap-decrease"))
 563                 engine_a &= ~IQS269_CHx_ENG_A_MEAS_CAP_SIZE;
 564
 565         engine_a |= IQS269_CHx_ENG_A_RX_GND_INACTIVE;
 566         if (fwnode_property_present(ch_node, "azoteq,rx-float-inactive"))
 567                 engine_a &= ~IQS269_CHx_ENG_A_RX_GND_INACTIVE;
 568
 569         engine_a &= ~IQS269_CHx_ENG_A_LOCAL_CAP_SIZE;
 570         engine_b &= ~IQS269_CHx_ENG_B_LOCAL_CAP_ENABLE;
 571         if (!fwnode_property_read_u32(ch_node, "azoteq,local-cap-size", &val)) {
 572                 switch (val) {
 573                 case IQS269_LOCAL_CAP_SIZE_0:
 574                         break;
 575
 576                 case IQS269_LOCAL_CAP_SIZE_GLOBAL_0pF5:
 577                         engine_a |= IQS269_CHx_ENG_A_LOCAL_CAP_SIZE;
 578                         fallthrough;
 579
 580                 case IQS269_LOCAL_CAP_SIZE_GLOBAL_ONLY:
 581                         engine_b |= IQS269_CHx_ENG_B_LOCAL_CAP_ENABLE;
 582                         break;
 583
 584                 default:
 585                         dev_err(&client->dev,
 586                                 "Invalid channel %u local cap. size: %u\n", reg,
 587                                 val);
 588                         return -EINVAL;
 589                 }
 590         }
 591
 592         engine_a &= ~IQS269_CHx_ENG_A_INV_LOGIC;
 593         if (fwnode_property_present(ch_node, "azoteq,invert-enable"))
 594                 engine_a |= IQS269_CHx_ENG_A_INV_LOGIC;
 595
 596         if (!fwnode_property_read_u32(ch_node, "azoteq,proj-bias", &val)) {
 597                 if (val > IQS269_CHx_ENG_A_PROJ_BIAS_MAX) {
 598                         dev_err(&client->dev,
 599                                 "Invalid channel %u bias current: %u\n", reg,
 600                                 val);
 601                         return -EINVAL;
 602                 }
 603
 604                 engine_a &= ~IQS269_CHx_ENG_A_PROJ_BIAS_MASK;
 605                 engine_a |= (val << IQS269_CHx_ENG_A_PROJ_BIAS_SHIFT);
 606         }
 607
 608         if (!fwnode_property_read_u32(ch_node, "azoteq,sense-mode", &val)) {
 609                 if (val > IQS269_CHx_ENG_A_SENSE_MODE_MAX) {
 610                         dev_err(&client->dev,
 611                                 "Invalid channel %u sensing mode: %u\n", reg,
 612                                 val);
 613                         return -EINVAL;
 614                 }
 615
 616                 engine_a &= ~IQS269_CHx_ENG_A_SENSE_MODE_MASK;
 617                 engine_a |= val;
 618         }
 619
 620         if (!fwnode_property_read_u32(ch_node, "azoteq,sense-freq", &val)) {
 621                 if (val > IQS269_CHx_ENG_B_SENSE_FREQ_MAX) {
 622                         dev_err(&client->dev,
 623                                 "Invalid channel %u sensing frequency: %u\n",
 624                                 reg, val);
 625                         return -EINVAL;
 626                 }
 627
 628                 engine_b &= ~IQS269_CHx_ENG_B_SENSE_FREQ_MASK;
 629                 engine_b |= (val << IQS269_CHx_ENG_B_SENSE_FREQ_SHIFT);
 630         }
 631
 632         engine_b &= ~IQS269_CHx_ENG_B_STATIC_ENABLE;
 633         if (fwnode_property_present(ch_node, "azoteq,static-enable"))
 634                 engine_b |= IQS269_CHx_ENG_B_STATIC_ENABLE;
 635
 636         ch_reg->engine_a = cpu_to_be16(engine_a);
 637         ch_reg->engine_b = cpu_to_be16(engine_b);
 638
 639         if (!fwnode_property_read_u32(ch_node, "azoteq,ati-mode", &val)) {
 640                 error = iqs269_ati_mode_set(iqs269, reg, val);
 641                 if (error) {
 642                         dev_err(&client->dev,
 643                                 "Invalid channel %u ATI mode: %u\n", reg, val);
 644                         return error;
 645                 }
 646         }
 647
 648         if (!fwnode_property_read_u32(ch_node, "azoteq,ati-base", &val)) {
 649                 error = iqs269_ati_base_set(iqs269, reg, val);
 650                 if (error) {
 651                         dev_err(&client->dev,
 652                                 "Invalid channel %u ATI base: %u\n", reg, val);
 653                         return error;
 654                 }
 655         }
 656
 657         if (!fwnode_property_read_u32(ch_node, "azoteq,ati-target", &val)) {
 658                 error = iqs269_ati_target_set(iqs269, reg, val);
 659                 if (error) {
 660                         dev_err(&client->dev,
 661                                 "Invalid channel %u ATI target: %u\n", reg,
 662                                 val);
 663                         return error;
 664                 }
 665         }
 666
 667         error = iqs269_parse_mask(ch_node, "azoteq,assoc-select",
 668                                   &ch_reg->assoc_select);
 669         if (error) {
 670                 dev_err(&client->dev, "Invalid channel %u association: %d\n",
 671                         reg, error);
 672                 return error;
 673         }
 674
 675         if (!fwnode_property_read_u32(ch_node, "azoteq,assoc-weight", &val)) {
 676                 if (val > IQS269_CHx_WEIGHT_MAX) {
 677                         dev_err(&client->dev,
 678                                 "Invalid channel %u associated weight: %u\n",
 679                                 reg, val);
 680                         return -EINVAL;
 681                 }
 682
 683                 ch_reg->assoc_weight = val;
 684         }
 685
 686         for (i = 0; i < ARRAY_SIZE(iqs269_events); i++) {
 687                 ev_node = fwnode_get_named_child_node(ch_node,
 688                                                       iqs269_events[i].name);
 689                 if (!ev_node)
 690                         continue;
 691
 692                 if (!fwnode_property_read_u32(ev_node, "azoteq,thresh", &val)) {
 693                         if (val > IQS269_CHx_THRESH_MAX) {
 694                                 dev_err(&client->dev,
 695                                         "Invalid channel %u threshold: %u\n",
 696                                         reg, val);
 697                                 return -EINVAL;
 698                         }
 699
 700                         ch_reg->thresh[iqs269_events[i].th_offs] = val;
 701                 }
 702
 703                 if (!fwnode_property_read_u32(ev_node, "azoteq,hyst", &val)) {
 704                         u8 *hyst = &ch_reg->hyst;
 705
 706                         if (val > IQS269_CHx_HYST_MAX) {
 707                                 dev_err(&client->dev,
 708                                         "Invalid channel %u hysteresis: %u\n",
 709                                         reg, val);
 710                                 return -EINVAL;
 711                         }
 712
 713                         if (i == IQS269_EVENT_DEEP_DN ||
 714                             i == IQS269_EVENT_DEEP_UP) {
 715                                 *hyst &= ~IQS269_CHx_HYST_DEEP_MASK;
 716                                 *hyst |= (val << IQS269_CHx_HYST_DEEP_SHIFT);
 717                         } else if (i == IQS269_EVENT_TOUCH_DN ||
 718                                    i == IQS269_EVENT_TOUCH_UP) {
 719                                 *hyst &= ~IQS269_CHx_HYST_TOUCH_MASK;
 720                                 *hyst |= val;
 721                         }
 722                 }
 723
 724                 if (fwnode_property_read_u32(ev_node, "linux,code", &val))
 725                         continue;
 726
 727                 switch (reg) {
 728                 case IQS269_CHx_HALL_ACTIVE:
 729                         if (iqs269->hall_enable) {
 730                                 iqs269->switches[i].code = val;
 731                                 iqs269->switches[i].enabled = true;
 732                         }
 733                         fallthrough;
 734
 735                 case IQS269_CHx_HALL_INACTIVE:
 736                         if (iqs269->hall_enable)
 737                                 break;
 738                         fallthrough;
 739
 740                 default:
 741                         iqs269->keycode[i * IQS269_NUM_CH + reg] = val;
 742                 }
 743
 744                 iqs269->sys_reg.event_mask &= ~iqs269_events[i].mask;
 745         }
 746
 747         return 0;
 748 }
 749
 750 static int iqs269_parse_prop(struct iqs269_private *iqs269)
 751 {
 752         struct iqs269_sys_reg *sys_reg = &iqs269->sys_reg;
 753         struct i2c_client *client = iqs269->client;
 754         struct fwnode_handle *ch_node;
 755         u16 general, misc_a, misc_b;
 756         unsigned int val;
 757         int error;
 758
 759         iqs269->hall_enable = device_property_present(&client->dev,
 760                                                       "azoteq,hall-enable");
 761
 762         if (!device_property_read_u32(&client->dev, "azoteq,suspend-mode",
 763                                       &val)) {
 764                 if (val > IQS269_SYS_SETTINGS_PWR_MODE_MAX) {
 765                         dev_err(&client->dev, "Invalid suspend mode: %u\n",
 766                                 val);
 767                         return -EINVAL;
 768                 }
 769
 770                 iqs269->suspend_mode = val;
 771         }
 772
 773         error = regmap_raw_read(iqs269->regmap, IQS269_SYS_SETTINGS, sys_reg,
 774                                 sizeof(*sys_reg));
 775         if (error)
 776                 return error;
 777
 778         if (!device_property_read_u32(&client->dev, "azoteq,filt-str-lp-lta",
 779                                       &val)) {
 780                 if (val > IQS269_FILT_STR_MAX) {
 781                         dev_err(&client->dev, "Invalid filter strength: %u\n",
 782                                 val);
 783                         return -EINVAL;
 784                 }
 785
 786                 sys_reg->filter &= ~IQS269_FILT_STR_LP_LTA_MASK;
 787                 sys_reg->filter |= (val << IQS269_FILT_STR_LP_LTA_SHIFT);
 788         }
 789
 790         if (!device_property_read_u32(&client->dev, "azoteq,filt-str-lp-cnt",
 791                                       &val)) {
 792                 if (val > IQS269_FILT_STR_MAX) {
 793                         dev_err(&client->dev, "Invalid filter strength: %u\n",
 794                                 val);
 795                         return -EINVAL;
 796                 }
 797
 798                 sys_reg->filter &= ~IQS269_FILT_STR_LP_CNT_MASK;
 799                 sys_reg->filter |= (val << IQS269_FILT_STR_LP_CNT_SHIFT);
 800         }
 801
 802         if (!device_property_read_u32(&client->dev, "azoteq,filt-str-np-lta",
 803                                       &val)) {
 804                 if (val > IQS269_FILT_STR_MAX) {
 805                         dev_err(&client->dev, "Invalid filter strength: %u\n",
 806                                 val);
 807                         return -EINVAL;
 808                 }
 809
 810                 sys_reg->filter &= ~IQS269_FILT_STR_NP_LTA_MASK;
 811                 sys_reg->filter |= (val << IQS269_FILT_STR_NP_LTA_SHIFT);
 812         }
 813
 814         if (!device_property_read_u32(&client->dev, "azoteq,filt-str-np-cnt",
 815                                       &val)) {
 816                 if (val > IQS269_FILT_STR_MAX) {
 817                         dev_err(&client->dev, "Invalid filter strength: %u\n",
 818                                 val);
 819                         return -EINVAL;
 820                 }
 821
 822                 sys_reg->filter &= ~IQS269_FILT_STR_NP_CNT_MASK;
 823                 sys_reg->filter |= val;
 824         }
 825
 826         if (!device_property_read_u32(&client->dev, "azoteq,rate-np-ms",
 827                                       &val)) {
 828                 if (val > IQS269_RATE_NP_MS_MAX) {
 829                         dev_err(&client->dev, "Invalid report rate: %u\n", val);
 830                         return -EINVAL;
 831                 }
 832
 833                 sys_reg->rate_np = val;
 834         }
 835
 836         if (!device_property_read_u32(&client->dev, "azoteq,rate-lp-ms",
 837                                       &val)) {
 838                 if (val > IQS269_RATE_LP_MS_MAX) {
 839                         dev_err(&client->dev, "Invalid report rate: %u\n", val);
 840                         return -EINVAL;
 841                 }
 842
 843                 sys_reg->rate_lp = val;
 844         }
 845
 846         if (!device_property_read_u32(&client->dev, "azoteq,rate-ulp-ms",
 847                                       &val)) {
 848                 if (val > IQS269_RATE_ULP_MS_MAX) {
 849                         dev_err(&client->dev, "Invalid report rate: %u\n", val);
 850                         return -EINVAL;
 851                 }
 852
 853                 sys_reg->rate_ulp = val / 16;
 854         }
 855
 856         if (!device_property_read_u32(&client->dev, "azoteq,timeout-pwr-ms",
 857                                       &val)) {
 858                 if (val > IQS269_TIMEOUT_PWR_MS_MAX) {
 859                         dev_err(&client->dev, "Invalid timeout: %u\n", val);
 860                         return -EINVAL;
 861                 }
 862
 863                 sys_reg->timeout_pwr = val / 512;
 864         }
 865
 866         if (!device_property_read_u32(&client->dev, "azoteq,timeout-lta-ms",
 867                                       &val)) {
 868                 if (val > IQS269_TIMEOUT_LTA_MS_MAX) {
 869                         dev_err(&client->dev, "Invalid timeout: %u\n", val);
 870                         return -EINVAL;
 871                 }
 872
 873                 sys_reg->timeout_lta = val / 512;
 874         }
 875
 876         misc_a = be16_to_cpu(sys_reg->misc_a);
 877         misc_b = be16_to_cpu(sys_reg->misc_b);
 878
 879         misc_a &= ~IQS269_MISC_A_ATI_BAND_DISABLE;
 880         if (device_property_present(&client->dev, "azoteq,ati-band-disable"))
 881                 misc_a |= IQS269_MISC_A_ATI_BAND_DISABLE;
 882
 883         misc_a &= ~IQS269_MISC_A_ATI_LP_ONLY;
 884         if (device_property_present(&client->dev, "azoteq,ati-lp-only"))
 885                 misc_a |= IQS269_MISC_A_ATI_LP_ONLY;
 886
 887         misc_a &= ~IQS269_MISC_A_ATI_BAND_TIGHTEN;
 888         if (device_property_present(&client->dev, "azoteq,ati-band-tighten"))
 889                 misc_a |= IQS269_MISC_A_ATI_BAND_TIGHTEN;
 890
 891         misc_a &= ~IQS269_MISC_A_FILT_DISABLE;
 892         if (device_property_present(&client->dev, "azoteq,filt-disable"))
 893                 misc_a |= IQS269_MISC_A_FILT_DISABLE;
 894
 895         if (!device_property_read_u32(&client->dev, "azoteq,gpio3-select",
 896                                       &val)) {
 897                 if (val >= IQS269_NUM_CH) {
 898                         dev_err(&client->dev, "Invalid GPIO3 selection: %u\n",
 899                                 val);
 900                         return -EINVAL;
 901                 }
 902
 903                 misc_a &= ~IQS269_MISC_A_GPIO3_SELECT_MASK;
 904                 misc_a |= (val << IQS269_MISC_A_GPIO3_SELECT_SHIFT);
 905         }
 906
 907         misc_a &= ~IQS269_MISC_A_DUAL_DIR;
 908         if (device_property_present(&client->dev, "azoteq,dual-direction"))
 909                 misc_a |= IQS269_MISC_A_DUAL_DIR;
 910
 911         if (!device_property_read_u32(&client->dev, "azoteq,tx-freq", &val)) {
 912                 if (val > IQS269_MISC_A_TX_FREQ_MAX) {
 913                         dev_err(&client->dev,
 914                                 "Invalid excitation frequency: %u\n", val);
 915                         return -EINVAL;
 916                 }
 917
 918                 misc_a &= ~IQS269_MISC_A_TX_FREQ_MASK;
 919                 misc_a |= (val << IQS269_MISC_A_TX_FREQ_SHIFT);
 920         }
 921
 922         misc_a &= ~IQS269_MISC_A_GLOBAL_CAP_SIZE;
 923         if (device_property_present(&client->dev, "azoteq,global-cap-increase"))
 924                 misc_a |= IQS269_MISC_A_GLOBAL_CAP_SIZE;
 925
 926         if (!device_property_read_u32(&client->dev, "azoteq,reseed-select",
 927                                       &val)) {
 928                 if (val > IQS269_MISC_B_RESEED_UI_SEL_MAX) {
 929                         dev_err(&client->dev, "Invalid reseed selection: %u\n",
 930                                 val);
 931                         return -EINVAL;
 932                 }
 933
 934                 misc_b &= ~IQS269_MISC_B_RESEED_UI_SEL_MASK;
 935                 misc_b |= (val << IQS269_MISC_B_RESEED_UI_SEL_SHIFT);
 936         }
 937
 938         misc_b &= ~IQS269_MISC_B_TRACKING_UI_ENABLE;
 939         if (device_property_present(&client->dev, "azoteq,tracking-enable"))
 940                 misc_b |= IQS269_MISC_B_TRACKING_UI_ENABLE;
 941
 942         if (!device_property_read_u32(&client->dev, "azoteq,filt-str-slider",
 943                                       &val)) {
 944                 if (val > IQS269_FILT_STR_MAX) {
 945                         dev_err(&client->dev, "Invalid filter strength: %u\n",
 946                                 val);
 947                         return -EINVAL;
 948                 }
 949
 950                 misc_b &= ~IQS269_MISC_B_FILT_STR_SLIDER;
 951                 misc_b |= val;
 952         }
 953
 954         sys_reg->misc_a = cpu_to_be16(misc_a);
 955         sys_reg->misc_b = cpu_to_be16(misc_b);
 956
 957         sys_reg->active = 0;
 958         sys_reg->reseed = 0;
 959
 960         sys_reg->blocking = 0;
 961
 962         sys_reg->slider_select[0] = 0;
 963         sys_reg->slider_select[1] = 0;
 964
 965         sys_reg->event_mask = ~((u8)IQS269_EVENT_MASK_SYS);
 966
 967         device_for_each_child_node(&client->dev, ch_node) {
 968                 error = iqs269_parse_chan(iqs269, ch_node);
 969                 if (error) {
 970                         fwnode_handle_put(ch_node);
 971                         return error;
 972                 }
 973         }
 974
 975         /*
 976          * Volunteer all active channels to participate in ATI when REDO-ATI is
 977          * manually triggered.
 978          */
 979         sys_reg->redo_ati = sys_reg->active;
 980
 981         general = be16_to_cpu(sys_reg->general);
 982
 983         if (device_property_present(&client->dev, "azoteq,clk-div")) {
 984                 general |= IQS269_SYS_SETTINGS_CLK_DIV;
 985                 iqs269->delay_mult = 4;
 986         } else {
 987                 general &= ~IQS269_SYS_SETTINGS_CLK_DIV;
 988                 iqs269->delay_mult = 1;
 989         }
 990
 991         /*
 992          * Configure the device to automatically switch between normal and low-
 993          * power modes as a function of sensing activity. Ultra-low-power mode,
 994          * if enabled, is reserved for suspend.
 995          */
 996         general &= ~IQS269_SYS_SETTINGS_ULP_AUTO;
 997         general &= ~IQS269_SYS_SETTINGS_DIS_AUTO;
 998         general &= ~IQS269_SYS_SETTINGS_PWR_MODE_MASK;
 999
1000         if (!device_property_read_u32(&client->dev, "azoteq,ulp-update",
1001                                       &val)) {
1002                 if (val > IQS269_SYS_SETTINGS_ULP_UPDATE_MAX) {
1003                         dev_err(&client->dev, "Invalid update rate: %u\n", val);
1004                         return -EINVAL;
1005                 }
1006
1007                 general &= ~IQS269_SYS_SETTINGS_ULP_UPDATE_MASK;
1008                 general |= (val << IQS269_SYS_SETTINGS_ULP_UPDATE_SHIFT);
1009         }
1010
1011         general &= ~IQS269_SYS_SETTINGS_RESEED_OFFSET;
1012         if (device_property_present(&client->dev, "azoteq,reseed-offset"))
1013                 general |= IQS269_SYS_SETTINGS_RESEED_OFFSET;
1014
1015         general |= IQS269_SYS_SETTINGS_EVENT_MODE;
1016
1017         /*
1018          * As per the datasheet, enable streaming during normal-power mode if
1019          * either slider is in use. In that case, the device returns to event
1020          * mode during low-power mode.
1021          */
1022         if (sys_reg->slider_select[0] || sys_reg->slider_select[1])
1023                 general |= IQS269_SYS_SETTINGS_EVENT_MODE_LP;
1024
1025         general |= IQS269_SYS_SETTINGS_REDO_ATI;
1026         general |= IQS269_SYS_SETTINGS_ACK_RESET;
1027
1028         sys_reg->general = cpu_to_be16(general);
1029
1030         return 0;
1031 }
1032
1033 static int iqs269_dev_init(struct iqs269_private *iqs269)
1034 {
1035         struct iqs269_sys_reg *sys_reg = &iqs269->sys_reg;
1036         struct iqs269_ch_reg *ch_reg;
1037         unsigned int val;
1038         int error, i;
1039
1040         mutex_lock(&iqs269->lock);
1041
1042         error = regmap_update_bits(iqs269->regmap, IQS269_HALL_UI,
1043                                    IQS269_HALL_UI_ENABLE,
1044                                    iqs269->hall_enable ? ~0 : 0);
1045         if (error)
1046                 goto err_mutex;
1047
1048         for (i = 0; i < IQS269_NUM_CH; i++) {
1049                 if (!(sys_reg->active & BIT(i)))
1050                         continue;
1051
1052                 ch_reg = &iqs269->ch_reg[i];
1053
1054                 error = regmap_raw_write(iqs269->regmap,
1055                                          IQS269_CHx_SETTINGS + i *
1056                                          sizeof(*ch_reg) / 2, ch_reg,
1057                                          sizeof(*ch_reg));
1058                 if (error)
1059                         goto err_mutex;
1060         }
1061
1062         /*
1063          * The REDO-ATI and ATI channel selection fields must be written in the
1064          * same block write, so every field between registers 0x80 through 0x8B
1065          * (inclusive) must be written as well.
1066          */
1067         error = regmap_raw_write(iqs269->regmap, IQS269_SYS_SETTINGS, sys_reg,
1068                                  sizeof(*sys_reg));
1069         if (error)
1070                 goto err_mutex;
1071
1072         error = regmap_read_poll_timeout(iqs269->regmap, IQS269_SYS_FLAGS, val,
1073                                         !(val & IQS269_SYS_FLAGS_IN_ATI),
1074                                          IQS269_ATI_POLL_SLEEP_US,
1075                                          IQS269_ATI_POLL_TIMEOUT_US);
1076         if (error)
1077                 goto err_mutex;
1078
1079         msleep(IQS269_ATI_STABLE_DELAY_MS);
1080         iqs269->ati_current = true;
1081
1082 err_mutex:
1083         mutex_unlock(&iqs269->lock);
1084
1085         return error;
1086 }
1087
1088 static int iqs269_input_init(struct iqs269_private *iqs269)
1089 {
1090         struct i2c_client *client = iqs269->client;
1091         struct iqs269_flags flags;
1092         unsigned int sw_code, keycode;
1093         int error, i, j;
1094         u8 dir_mask, state;
1095
1096         iqs269->keypad = devm_input_allocate_device(&client->dev);
1097         if (!iqs269->keypad)
1098                 return -ENOMEM;
1099
1100         iqs269->keypad->keycodemax = ARRAY_SIZE(iqs269->keycode);
1101         iqs269->keypad->keycode = iqs269->keycode;
1102         iqs269->keypad->keycodesize = sizeof(*iqs269->keycode);
1103
1104         iqs269->keypad->name = "iqs269a_keypad";
1105         iqs269->keypad->id.bustype = BUS_I2C;
1106
1107         if (iqs269->hall_enable) {
1108                 error = regmap_raw_read(iqs269->regmap, IQS269_SYS_FLAGS,
1109                                         &flags, sizeof(flags));
1110                 if (error) {
1111                         dev_err(&client->dev,
1112                                 "Failed to read initial status: %d\n", error);
1113                         return error;
1114                 }
1115         }
1116
1117         for (i = 0; i < ARRAY_SIZE(iqs269_events); i++) {
1118                 dir_mask = flags.states[IQS269_ST_OFFS_DIR];
1119                 if (!iqs269_events[i].dir_up)
1120                         dir_mask = ~dir_mask;
1121
1122                 state = flags.states[iqs269_events[i].st_offs] & dir_mask;
1123
1124                 sw_code = iqs269->switches[i].code;
1125
1126                 for (j = 0; j < IQS269_NUM_CH; j++) {
1127                         keycode = iqs269->keycode[i * IQS269_NUM_CH + j];
1128
1129                         /*
1130                          * Hall-effect sensing repurposes a pair of dedicated
1131                          * channels, only one of which reports events.
1132                          */
1133                         switch (j) {
1134                         case IQS269_CHx_HALL_ACTIVE:
1135                                 if (iqs269->hall_enable &&
1136                                     iqs269->switches[i].enabled) {
1137                                         input_set_capability(iqs269->keypad,
1138                                                              EV_SW, sw_code);
1139                                         input_report_switch(iqs269->keypad,
1140                                                             sw_code,
1141                                                             state & BIT(j));
1142                                 }
1143                                 fallthrough;
1144
1145                         case IQS269_CHx_HALL_INACTIVE:
1146                                 if (iqs269->hall_enable)
1147                                         continue;
1148                                 fallthrough;
1149
1150                         default:
1151                                 if (keycode != KEY_RESERVED)
1152                                         input_set_capability(iqs269->keypad,
1153                                                              EV_KEY, keycode);
1154                         }
1155                 }
1156         }
1157
1158         input_sync(iqs269->keypad);
1159
1160         error = input_register_device(iqs269->keypad);
1161         if (error) {
1162                 dev_err(&client->dev, "Failed to register keypad: %d\n", error);
1163                 return error;
1164         }
1165
1166         for (i = 0; i < IQS269_NUM_SL; i++) {
1167                 if (!iqs269->sys_reg.slider_select[i])
1168                         continue;
1169
1170                 iqs269->slider[i] = devm_input_allocate_device(&client->dev);
1171                 if (!iqs269->slider[i])
1172                         return -ENOMEM;
1173
1174                 iqs269->slider[i]->name = i ? "iqs269a_slider_1"
1175                                             : "iqs269a_slider_0";
1176                 iqs269->slider[i]->id.bustype = BUS_I2C;
1177
1178                 input_set_capability(iqs269->slider[i], EV_KEY, BTN_TOUCH);
1179                 input_set_abs_params(iqs269->slider[i], ABS_X, 0, 255, 0, 0);
1180
1181                 error = input_register_device(iqs269->slider[i]);
1182                 if (error) {
1183                         dev_err(&client->dev,
1184                                 "Failed to register slider %d: %d\n", i, error);
1185                         return error;
1186                 }
1187         }
1188
1189         return 0;
1190 }
1191
1192 static int iqs269_report(struct iqs269_private *iqs269)
1193 {
1194         struct i2c_client *client = iqs269->client;
1195         struct iqs269_flags flags;
1196         unsigned int sw_code, keycode;
1197         int error, i, j;
1198         u8 slider_x[IQS269_NUM_SL];
1199         u8 dir_mask, state;
1200
1201         error = regmap_raw_read(iqs269->regmap, IQS269_SYS_FLAGS, &flags,
1202                                 sizeof(flags));
1203         if (error) {
1204                 dev_err(&client->dev, "Failed to read device status: %d\n",
1205                         error);
1206                 return error;
1207         }
1208
1209         /*
1210          * The device resets itself if its own watchdog bites, which can happen
1211          * in the event of an I2C communication error. In this case, the device
1212          * asserts a SHOW_RESET interrupt and all registers must be restored.
1213          */
1214         if (be16_to_cpu(flags.system) & IQS269_SYS_FLAGS_SHOW_RESET) {
1215                 dev_err(&client->dev, "Unexpected device reset\n");
1216
1217                 error = iqs269_dev_init(iqs269);
1218                 if (error)
1219                         dev_err(&client->dev,
1220                                 "Failed to re-initialize device: %d\n", error);
1221
1222                 return error;
1223         }
1224
1225         error = regmap_raw_read(iqs269->regmap, IQS269_SLIDER_X, slider_x,
1226                                 sizeof(slider_x));
1227         if (error) {
1228                 dev_err(&client->dev, "Failed to read slider position: %d\n",
1229                         error);
1230                 return error;
1231         }
1232
1233         for (i = 0; i < IQS269_NUM_SL; i++) {
1234                 if (!iqs269->sys_reg.slider_select[i])
1235                         continue;
1236
1237                 /*
1238                  * Report BTN_TOUCH if any channel that participates in the
1239                  * slider is in a state of touch.
1240                  */
1241                 if (flags.states[IQS269_ST_OFFS_TOUCH] &
1242                     iqs269->sys_reg.slider_select[i]) {
1243                         input_report_key(iqs269->slider[i], BTN_TOUCH, 1);
1244                         input_report_abs(iqs269->slider[i], ABS_X, slider_x[i]);
1245                 } else {
1246                         input_report_key(iqs269->slider[i], BTN_TOUCH, 0);
1247                 }
1248
1249                 input_sync(iqs269->slider[i]);
1250         }
1251
1252         for (i = 0; i < ARRAY_SIZE(iqs269_events); i++) {
1253                 dir_mask = flags.states[IQS269_ST_OFFS_DIR];
1254                 if (!iqs269_events[i].dir_up)
1255                         dir_mask = ~dir_mask;
1256
1257                 state = flags.states[iqs269_events[i].st_offs] & dir_mask;
1258
1259                 sw_code = iqs269->switches[i].code;
1260
1261                 for (j = 0; j < IQS269_NUM_CH; j++) {
1262                         keycode = iqs269->keycode[i * IQS269_NUM_CH + j];
1263
1264                         switch (j) {
1265                         case IQS269_CHx_HALL_ACTIVE:
1266                                 if (iqs269->hall_enable &&
1267                                     iqs269->switches[i].enabled)
1268                                         input_report_switch(iqs269->keypad,
1269                                                             sw_code,
1270                                                             state & BIT(j));
1271                                 fallthrough;
1272
1273                         case IQS269_CHx_HALL_INACTIVE:
1274                                 if (iqs269->hall_enable)
1275                                         continue;
1276                                 fallthrough;
1277
1278                         default:
1279                                 input_report_key(iqs269->keypad, keycode,
1280                                                  state & BIT(j));
1281                         }
1282                 }
1283         }
1284
1285         input_sync(iqs269->keypad);
1286
1287         return 0;
1288 }
1289
1290 static irqreturn_t iqs269_irq(int irq, void *context)
1291 {
1292         struct iqs269_private *iqs269 = context;
1293
1294         if (iqs269_report(iqs269))
1295                 return IRQ_NONE;
1296
1297         /*
1298          * The device does not deassert its interrupt (RDY) pin until shortly
1299          * after receiving an I2C stop condition; the following delay ensures
1300          * the interrupt handler does not return before this time.
1301          */
1302         iqs269_irq_wait();
1303
1304         return IRQ_HANDLED;
1305 }
1306
1307 static ssize_t counts_show(struct device *dev,
1308                            struct device_attribute *attr, char *buf)
1309 {
1310         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1311         struct i2c_client *client = iqs269->client;
1312         __le16 counts;
1313         int error;
1314
1315         if (!iqs269->ati_current || iqs269->hall_enable)
1316                 return -EPERM;
1317
1318         /*
1319          * Unsolicited I2C communication prompts the device to assert its RDY
1320          * pin, so disable the interrupt line until the operation is finished
1321          * and RDY has been deasserted.
1322          */
1323         disable_irq(client->irq);
1324
1325         error = regmap_raw_read(iqs269->regmap,
1326                                 IQS269_CHx_COUNTS + iqs269->ch_num * 2,
1327                                 &counts, sizeof(counts));
1328
1329         iqs269_irq_wait();
1330         enable_irq(client->irq);
1331
1332         if (error)
1333                 return error;
1334
1335         return scnprintf(buf, PAGE_SIZE, "%u\n", le16_to_cpu(counts));
1336 }
1337
1338 static ssize_t hall_bin_show(struct device *dev,
1339                              struct device_attribute *attr, char *buf)
1340 {
1341         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1342         struct i2c_client *client = iqs269->client;
1343         unsigned int val;
1344         int error;
1345
1346         disable_irq(client->irq);
1347
1348         error = regmap_read(iqs269->regmap, IQS269_CAL_DATA_A, &val);
1349
1350         iqs269_irq_wait();
1351         enable_irq(client->irq);
1352
1353         if (error)
1354                 return error;
1355
1356         switch (iqs269->ch_reg[IQS269_CHx_HALL_ACTIVE].rx_enable &
1357                 iqs269->ch_reg[IQS269_CHx_HALL_INACTIVE].rx_enable) {
1358         case IQS269_HALL_PAD_R:
1359                 val &= IQS269_CAL_DATA_A_HALL_BIN_R_MASK;
1360                 val >>= IQS269_CAL_DATA_A_HALL_BIN_R_SHIFT;
1361                 break;
1362
1363         case IQS269_HALL_PAD_L:
1364                 val &= IQS269_CAL_DATA_A_HALL_BIN_L_MASK;
1365                 val >>= IQS269_CAL_DATA_A_HALL_BIN_L_SHIFT;
1366                 break;
1367
1368         default:
1369                 return -EINVAL;
1370         }
1371
1372         return scnprintf(buf, PAGE_SIZE, "%u\n", val);
1373 }
1374
1375 static ssize_t hall_enable_show(struct device *dev,
1376                                 struct device_attribute *attr, char *buf)
1377 {
1378         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1379
1380         return scnprintf(buf, PAGE_SIZE, "%u\n", iqs269->hall_enable);
1381 }
1382
1383 static ssize_t hall_enable_store(struct device *dev,
1384                                  struct device_attribute *attr, const char *buf,
1385                                  size_t count)
1386 {
1387         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1388         unsigned int val;
1389         int error;
1390
1391         error = kstrtouint(buf, 10, &val);
1392         if (error)
1393                 return error;
1394
1395         mutex_lock(&iqs269->lock);
1396
1397         iqs269->hall_enable = val;
1398         iqs269->ati_current = false;
1399
1400         mutex_unlock(&iqs269->lock);
1401
1402         return count;
1403 }
1404
1405 static ssize_t ch_number_show(struct device *dev,
1406                               struct device_attribute *attr, char *buf)
1407 {
1408         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1409
1410         return scnprintf(buf, PAGE_SIZE, "%u\n", iqs269->ch_num);
1411 }
1412
1413 static ssize_t ch_number_store(struct device *dev,
1414                                struct device_attribute *attr, const char *buf,
1415                                size_t count)
1416 {
1417         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1418         unsigned int val;
1419         int error;
1420
1421         error = kstrtouint(buf, 10, &val);
1422         if (error)
1423                 return error;
1424
1425         if (val >= IQS269_NUM_CH)
1426                 return -EINVAL;
1427
1428         iqs269->ch_num = val;
1429
1430         return count;
1431 }
1432
1433 static ssize_t rx_enable_show(struct device *dev,
1434                               struct device_attribute *attr, char *buf)
1435 {
1436         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1437
1438         return scnprintf(buf, PAGE_SIZE, "%u\n",
1439                          iqs269->ch_reg[iqs269->ch_num].rx_enable);
1440 }
1441
1442 static ssize_t rx_enable_store(struct device *dev,
1443                                struct device_attribute *attr, const char *buf,
1444                                size_t count)
1445 {
1446         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1447         unsigned int val;
1448         int error;
1449
1450         error = kstrtouint(buf, 10, &val);
1451         if (error)
1452                 return error;
1453
1454         if (val > 0xFF)
1455                 return -EINVAL;
1456
1457         mutex_lock(&iqs269->lock);
1458
1459         iqs269->ch_reg[iqs269->ch_num].rx_enable = val;
1460         iqs269->ati_current = false;
1461
1462         mutex_unlock(&iqs269->lock);
1463
1464         return count;
1465 }
1466
1467 static ssize_t ati_mode_show(struct device *dev,
1468                              struct device_attribute *attr, char *buf)
1469 {
1470         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1471         unsigned int val;
1472         int error;
1473
1474         error = iqs269_ati_mode_get(iqs269, iqs269->ch_num, &val);
1475         if (error)
1476                 return error;
1477
1478         return scnprintf(buf, PAGE_SIZE, "%u\n", val);
1479 }
1480
1481 static ssize_t ati_mode_store(struct device *dev,
1482                               struct device_attribute *attr, const char *buf,
1483                               size_t count)
1484 {
1485         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1486         unsigned int val;
1487         int error;
1488
1489         error = kstrtouint(buf, 10, &val);
1490         if (error)
1491                 return error;
1492
1493         error = iqs269_ati_mode_set(iqs269, iqs269->ch_num, val);
1494         if (error)
1495                 return error;
1496
1497         return count;
1498 }
1499
1500 static ssize_t ati_base_show(struct device *dev,
1501                              struct device_attribute *attr, char *buf)
1502 {
1503         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1504         unsigned int val;
1505         int error;
1506
1507         error = iqs269_ati_base_get(iqs269, iqs269->ch_num, &val);
1508         if (error)
1509                 return error;
1510
1511         return scnprintf(buf, PAGE_SIZE, "%u\n", val);
1512 }
1513
1514 static ssize_t ati_base_store(struct device *dev,
1515                               struct device_attribute *attr, const char *buf,
1516                               size_t count)
1517 {
1518         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1519         unsigned int val;
1520         int error;
1521
1522         error = kstrtouint(buf, 10, &val);
1523         if (error)
1524                 return error;
1525
1526         error = iqs269_ati_base_set(iqs269, iqs269->ch_num, val);
1527         if (error)
1528                 return error;
1529
1530         return count;
1531 }
1532
1533 static ssize_t ati_target_show(struct device *dev,
1534                                struct device_attribute *attr, char *buf)
1535 {
1536         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1537         unsigned int val;
1538         int error;
1539
1540         error = iqs269_ati_target_get(iqs269, iqs269->ch_num, &val);
1541         if (error)
1542                 return error;
1543
1544         return scnprintf(buf, PAGE_SIZE, "%u\n", val);
1545 }
1546
1547 static ssize_t ati_target_store(struct device *dev,
1548                                 struct device_attribute *attr, const char *buf,
1549                                 size_t count)
1550 {
1551         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1552         unsigned int val;
1553         int error;
1554
1555         error = kstrtouint(buf, 10, &val);
1556         if (error)
1557                 return error;
1558
1559         error = iqs269_ati_target_set(iqs269, iqs269->ch_num, val);
1560         if (error)
1561                 return error;
1562
1563         return count;
1564 }
1565
1566 static ssize_t ati_trigger_show(struct device *dev,
1567                                 struct device_attribute *attr, char *buf)
1568 {
1569         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1570
1571         return scnprintf(buf, PAGE_SIZE, "%u\n", iqs269->ati_current);
1572 }
1573
1574 static ssize_t ati_trigger_store(struct device *dev,
1575                                  struct device_attribute *attr, const char *buf,
1576                                  size_t count)
1577 {
1578         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1579         struct i2c_client *client = iqs269->client;
1580         unsigned int val;
1581         int error;
1582
1583         error = kstrtouint(buf, 10, &val);
1584         if (error)
1585                 return error;
1586
1587         if (!val)
1588                 return count;
1589
1590         disable_irq(client->irq);
1591
1592         error = iqs269_dev_init(iqs269);
1593
1594         iqs269_irq_wait();
1595         enable_irq(client->irq);
1596
1597         if (error)
1598                 return error;
1599
1600         return count;
1601 }
1602
1603 static DEVICE_ATTR_RO(counts);
1604 static DEVICE_ATTR_RO(hall_bin);
1605 static DEVICE_ATTR_RW(hall_enable);
1606 static DEVICE_ATTR_RW(ch_number);
1607 static DEVICE_ATTR_RW(rx_enable);
1608 static DEVICE_ATTR_RW(ati_mode);
1609 static DEVICE_ATTR_RW(ati_base);
1610 static DEVICE_ATTR_RW(ati_target);
1611 static DEVICE_ATTR_RW(ati_trigger);
1612
1613 static struct attribute *iqs269_attrs[] = {
1614         &dev_attr_counts.attr,
1615         &dev_attr_hall_bin.attr,
1616         &dev_attr_hall_enable.attr,
1617         &dev_attr_ch_number.attr,
1618         &dev_attr_rx_enable.attr,
1619         &dev_attr_ati_mode.attr,
1620         &dev_attr_ati_base.attr,
1621         &dev_attr_ati_target.attr,
1622         &dev_attr_ati_trigger.attr,
1623         NULL,
1624 };
1625
1626 static const struct attribute_group iqs269_attr_group = {
1627         .attrs = iqs269_attrs,
1628 };
1629
1630 static const struct regmap_config iqs269_regmap_config = {
1631         .reg_bits = 8,
1632         .val_bits = 16,
1633         .max_register = IQS269_MAX_REG,
1634 };
1635
1636 static int iqs269_probe(struct i2c_client *client)
1637 {
1638         struct iqs269_ver_info ver_info;
1639         struct iqs269_private *iqs269;
1640         int error;
1641
1642         iqs269 = devm_kzalloc(&client->dev, sizeof(*iqs269), GFP_KERNEL);
1643         if (!iqs269)
1644                 return -ENOMEM;
1645
1646         i2c_set_clientdata(client, iqs269);
1647         iqs269->client = client;
1648
1649         iqs269->regmap = devm_regmap_init_i2c(client, &iqs269_regmap_config);
1650         if (IS_ERR(iqs269->regmap)) {
1651                 error = PTR_ERR(iqs269->regmap);
1652                 dev_err(&client->dev, "Failed to initialize register map: %d\n",
1653                         error);
1654                 return error;
1655         }
1656
1657         mutex_init(&iqs269->lock);
1658
1659         error = regmap_raw_read(iqs269->regmap, IQS269_VER_INFO, &ver_info,
1660                                 sizeof(ver_info));
1661         if (error)
1662                 return error;
1663
1664         if (ver_info.prod_num != IQS269_VER_INFO_PROD_NUM) {
1665                 dev_err(&client->dev, "Unrecognized product number: 0x%02X\n",
1666                         ver_info.prod_num);
1667                 return -EINVAL;
1668         }
1669
1670         error = iqs269_parse_prop(iqs269);
1671         if (error)
1672                 return error;
1673
1674         error = iqs269_dev_init(iqs269);
1675         if (error) {
1676                 dev_err(&client->dev, "Failed to initialize device: %d\n",
1677                         error);
1678                 return error;
1679         }
1680
1681         error = iqs269_input_init(iqs269);
1682         if (error)
1683                 return error;
1684
1685         error = devm_request_threaded_irq(&client->dev, client->irq,
1686                                           NULL, iqs269_irq, IRQF_ONESHOT,
1687                                           client->name, iqs269);
1688         if (error) {
1689                 dev_err(&client->dev, "Failed to request IRQ: %d\n", error);
1690                 return error;
1691         }
1692
1693         error = devm_device_add_group(&client->dev, &iqs269_attr_group);
1694         if (error)
1695                 dev_err(&client->dev, "Failed to add attributes: %d\n", error);
1696
1697         return error;
1698 }
1699
1700 static int __maybe_unused iqs269_suspend(struct device *dev)
1701 {
1702         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1703         struct i2c_client *client = iqs269->client;
1704         unsigned int val;
1705         int error;
1706
1707         if (!iqs269->suspend_mode)
1708                 return 0;
1709
1710         disable_irq(client->irq);
1711
1712         /*
1713          * Automatic power mode switching must be disabled before the device is
1714          * forced into any particular power mode. In this case, the device will
1715          * transition into normal-power mode.
1716          */
1717         error = regmap_update_bits(iqs269->regmap, IQS269_SYS_SETTINGS,
1718                                    IQS269_SYS_SETTINGS_DIS_AUTO, ~0);
1719         if (error)
1720                 goto err_irq;
1721
1722         /*
1723          * The following check ensures the device has completed its transition
1724          * into normal-power mode before a manual mode switch is performed.
1725          */
1726         error = regmap_read_poll_timeout(iqs269->regmap, IQS269_SYS_FLAGS, val,
1727                                         !(val & IQS269_SYS_FLAGS_PWR_MODE_MASK),
1728                                          IQS269_PWR_MODE_POLL_SLEEP_US,
1729                                          IQS269_PWR_MODE_POLL_TIMEOUT_US);
1730         if (error)
1731                 goto err_irq;
1732
1733         error = regmap_update_bits(iqs269->regmap, IQS269_SYS_SETTINGS,
1734                                    IQS269_SYS_SETTINGS_PWR_MODE_MASK,
1735                                    iqs269->suspend_mode <<
1736                                    IQS269_SYS_SETTINGS_PWR_MODE_SHIFT);
1737         if (error)
1738                 goto err_irq;
1739
1740         /*
1741          * This last check ensures the device has completed its transition into
1742          * the desired power mode to prevent any spurious interrupts from being
1743          * triggered after iqs269_suspend has already returned.
1744          */
1745         error = regmap_read_poll_timeout(iqs269->regmap, IQS269_SYS_FLAGS, val,
1746                                          (val & IQS269_SYS_FLAGS_PWR_MODE_MASK)
1747                                          == (iqs269->suspend_mode <<
1748                                              IQS269_SYS_FLAGS_PWR_MODE_SHIFT),
1749                                          IQS269_PWR_MODE_POLL_SLEEP_US,
1750                                          IQS269_PWR_MODE_POLL_TIMEOUT_US);
1751
1752 err_irq:
1753         iqs269_irq_wait();
1754         enable_irq(client->irq);
1755
1756         return error;
1757 }
1758
1759 static int __maybe_unused iqs269_resume(struct device *dev)
1760 {
1761         struct iqs269_private *iqs269 = dev_get_drvdata(dev);
1762         struct i2c_client *client = iqs269->client;
1763         unsigned int val;
1764         int error;
1765
1766         if (!iqs269->suspend_mode)
1767                 return 0;
1768
1769         disable_irq(client->irq);
1770
1771         error = regmap_update_bits(iqs269->regmap, IQS269_SYS_SETTINGS,
1772                                    IQS269_SYS_SETTINGS_PWR_MODE_MASK, 0);
1773         if (error)
1774                 goto err_irq;
1775
1776         /*
1777          * This check ensures the device has returned to normal-power mode
1778          * before automatic power mode switching is re-enabled.
1779          */
1780         error = regmap_read_poll_timeout(iqs269->regmap, IQS269_SYS_FLAGS, val,
1781                                         !(val & IQS269_SYS_FLAGS_PWR_MODE_MASK),
1782                                          IQS269_PWR_MODE_POLL_SLEEP_US,
1783                                          IQS269_PWR_MODE_POLL_TIMEOUT_US);
1784         if (error)
1785                 goto err_irq;
1786
1787         error = regmap_update_bits(iqs269->regmap, IQS269_SYS_SETTINGS,
1788                                    IQS269_SYS_SETTINGS_DIS_AUTO, 0);
1789         if (error)
1790                 goto err_irq;
1791
1792         /*
1793          * This step reports any events that may have been "swallowed" as a
1794          * result of polling PWR_MODE (which automatically acknowledges any
1795          * pending interrupts).
1796          */
1797         error = iqs269_report(iqs269);
1798
1799 err_irq:
1800         iqs269_irq_wait();
1801         enable_irq(client->irq);
1802
1803         return error;
1804 }
1805
1806 static SIMPLE_DEV_PM_OPS(iqs269_pm, iqs269_suspend, iqs269_resume);
1807
1808 static const struct of_device_id iqs269_of_match[] = {
1809         { .compatible = "azoteq,iqs269a" },
1810         { }
1811 };
1812 MODULE_DEVICE_TABLE(of, iqs269_of_match);
1813
1814 static struct i2c_driver iqs269_i2c_driver = {
1815         .driver = {
1816                 .name = "iqs269a",
1817                 .of_match_table = iqs269_of_match,
1818                 .pm = &iqs269_pm,
1819         },
1820         .probe_new = iqs269_probe,
1821 };
1822 module_i2c_driver(iqs269_i2c_driver);
1823
1824 MODULE_AUTHOR("Jeff LaBundy <jeff@labundy.com>");
1825 MODULE_DESCRIPTION("Azoteq IQS269A Capacitive Touch Controller");
1826 MODULE_LICENSE("GPL");