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/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", ®); 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 <jeff@labundy.com>"); 1975 MODULE_DESCRIPTION("Azoteq IQS269A Capacitive Touch Controller"); 1976 MODULE_LICENSE("GPL"); 1977