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
iqs269_slider_type(struct iqs269_private * iqs269,int slider_num)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
iqs269_ati_mode_set(struct iqs269_private * iqs269,unsigned int ch_num,unsigned int mode)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
iqs269_ati_mode_get(struct iqs269_private * iqs269,unsigned int ch_num,unsigned int * mode)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
iqs269_ati_base_set(struct iqs269_private * iqs269,unsigned int ch_num,unsigned int base)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
iqs269_ati_base_get(struct iqs269_private * iqs269,unsigned int ch_num,unsigned int * base)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
iqs269_ati_target_set(struct iqs269_private * iqs269,unsigned int ch_num,unsigned int target)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
iqs269_ati_target_get(struct iqs269_private * iqs269,unsigned int ch_num,unsigned int * target)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
iqs269_parse_mask(const struct fwnode_handle * fwnode,const char * propname,u8 * mask)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
iqs269_parse_chan(struct iqs269_private * iqs269,const struct fwnode_handle * ch_node)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
iqs269_parse_prop(struct iqs269_private * iqs269)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
iqs269_dev_init(struct iqs269_private * iqs269)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
iqs269_input_init(struct iqs269_private * iqs269)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
iqs269_report(struct iqs269_private * iqs269)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
iqs269_irq(int irq,void * context)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
counts_show(struct device * dev,struct device_attribute * attr,char * buf)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
hall_bin_show(struct device * dev,struct device_attribute * attr,char * buf)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
hall_enable_show(struct device * dev,struct device_attribute * attr,char * buf)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
hall_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
ch_number_show(struct device * dev,struct device_attribute * attr,char * buf)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
ch_number_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
rx_enable_show(struct device * dev,struct device_attribute * attr,char * buf)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
rx_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
ati_mode_show(struct device * dev,struct device_attribute * attr,char * buf)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
ati_mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
ati_base_show(struct device * dev,struct device_attribute * attr,char * buf)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
ati_base_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
ati_target_show(struct device * dev,struct device_attribute * attr,char * buf)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
ati_target_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
ati_trigger_show(struct device * dev,struct device_attribute * attr,char * buf)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
ati_trigger_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
iqs269_probe(struct i2c_client * client)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
iqs269_general_get(struct iqs269_private * iqs269)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
iqs269_suspend(struct device * dev)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
iqs269_resume(struct device * dev)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