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