1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * DA7280 Haptic device driver |
4 | * |
5 | * Copyright (c) 2020 Dialog Semiconductor. |
6 | * Author: Roy Im <Roy.Im.Opensource@diasemi.com> |
7 | */ |
8 | |
9 | #include <linux/bitfield.h> |
10 | #include <linux/bitops.h> |
11 | #include <linux/err.h> |
12 | #include <linux/i2c.h> |
13 | #include <linux/input.h> |
14 | #include <linux/interrupt.h> |
15 | #include <linux/module.h> |
16 | #include <linux/pwm.h> |
17 | #include <linux/regmap.h> |
18 | #include <linux/workqueue.h> |
19 | #include <linux/uaccess.h> |
20 | |
21 | /* Registers */ |
22 | #define DA7280_IRQ_EVENT1 0x03 |
23 | #define DA7280_IRQ_EVENT_WARNING_DIAG 0x04 |
24 | #define DA7280_IRQ_EVENT_SEQ_DIAG 0x05 |
25 | #define DA7280_IRQ_STATUS1 0x06 |
26 | #define DA7280_IRQ_MASK1 0x07 |
27 | #define DA7280_FRQ_LRA_PER_H 0x0A |
28 | #define DA7280_FRQ_LRA_PER_L 0x0B |
29 | #define DA7280_ACTUATOR1 0x0C |
30 | #define DA7280_ACTUATOR2 0x0D |
31 | #define DA7280_ACTUATOR3 0x0E |
32 | #define DA7280_CALIB_V2I_H 0x0F |
33 | #define DA7280_CALIB_V2I_L 0x10 |
34 | #define DA7280_TOP_CFG1 0x13 |
35 | #define DA7280_TOP_CFG2 0x14 |
36 | #define DA7280_TOP_CFG4 0x16 |
37 | #define DA7280_TOP_INT_CFG1 0x17 |
38 | #define DA7280_TOP_CTL1 0x22 |
39 | #define DA7280_TOP_CTL2 0x23 |
40 | #define DA7280_SEQ_CTL2 0x28 |
41 | #define DA7280_GPI_0_CTL 0x29 |
42 | #define DA7280_GPI_1_CTL 0x2A |
43 | #define DA7280_GPI_2_CTL 0x2B |
44 | #define DA7280_MEM_CTL1 0x2C |
45 | #define DA7280_MEM_CTL2 0x2D |
46 | #define DA7280_TOP_CFG5 0x6E |
47 | #define DA7280_IRQ_MASK2 0x83 |
48 | #define DA7280_SNP_MEM_99 0xE7 |
49 | |
50 | /* Register field */ |
51 | |
52 | /* DA7280_IRQ_EVENT1 (Address 0x03) */ |
53 | #define DA7280_E_SEQ_CONTINUE_MASK BIT(0) |
54 | #define DA7280_E_UVLO_MASK BIT(1) |
55 | #define DA7280_E_SEQ_DONE_MASK BIT(2) |
56 | #define DA7280_E_OVERTEMP_CRIT_MASK BIT(3) |
57 | #define DA7280_E_SEQ_FAULT_MASK BIT(4) |
58 | #define DA7280_E_WARNING_MASK BIT(5) |
59 | #define DA7280_E_ACTUATOR_FAULT_MASK BIT(6) |
60 | #define DA7280_E_OC_FAULT_MASK BIT(7) |
61 | |
62 | /* DA7280_IRQ_EVENT_WARNING_DIAG (Address 0x04) */ |
63 | #define DA7280_E_OVERTEMP_WARN_MASK BIT(3) |
64 | #define DA7280_E_MEM_TYPE_MASK BIT(4) |
65 | #define DA7280_E_LIM_DRIVE_ACC_MASK BIT(6) |
66 | #define DA7280_E_LIM_DRIVE_MASK BIT(7) |
67 | |
68 | /* DA7280_IRQ_EVENT_PAT_DIAG (Address 0x05) */ |
69 | #define DA7280_E_PWM_FAULT_MASK BIT(5) |
70 | #define DA7280_E_MEM_FAULT_MASK BIT(6) |
71 | #define DA7280_E_SEQ_ID_FAULT_MASK BIT(7) |
72 | |
73 | /* DA7280_IRQ_STATUS1 (Address 0x06) */ |
74 | #define DA7280_STA_SEQ_CONTINUE_MASK BIT(0) |
75 | #define DA7280_STA_UVLO_VBAT_OK_MASK BIT(1) |
76 | #define DA7280_STA_SEQ_DONE_MASK BIT(2) |
77 | #define DA7280_STA_OVERTEMP_CRIT_MASK BIT(3) |
78 | #define DA7280_STA_SEQ_FAULT_MASK BIT(4) |
79 | #define DA7280_STA_WARNING_MASK BIT(5) |
80 | #define DA7280_STA_ACTUATOR_MASK BIT(6) |
81 | #define DA7280_STA_OC_MASK BIT(7) |
82 | |
83 | /* DA7280_IRQ_MASK1 (Address 0x07) */ |
84 | #define DA7280_SEQ_CONTINUE_M_MASK BIT(0) |
85 | #define DA7280_E_UVLO_M_MASK BIT(1) |
86 | #define DA7280_SEQ_DONE_M_MASK BIT(2) |
87 | #define DA7280_OVERTEMP_CRIT_M_MASK BIT(3) |
88 | #define DA7280_SEQ_FAULT_M_MASK BIT(4) |
89 | #define DA7280_WARNING_M_MASK BIT(5) |
90 | #define DA7280_ACTUATOR_M_MASK BIT(6) |
91 | #define DA7280_OC_M_MASK BIT(7) |
92 | |
93 | /* DA7280_ACTUATOR3 (Address 0x0e) */ |
94 | #define DA7280_IMAX_MASK GENMASK(4, 0) |
95 | |
96 | /* DA7280_TOP_CFG1 (Address 0x13) */ |
97 | #define DA7280_AMP_PID_EN_MASK BIT(0) |
98 | #define DA7280_RAPID_STOP_EN_MASK BIT(1) |
99 | #define DA7280_ACCELERATION_EN_MASK BIT(2) |
100 | #define DA7280_FREQ_TRACK_EN_MASK BIT(3) |
101 | #define DA7280_BEMF_SENSE_EN_MASK BIT(4) |
102 | #define DA7280_ACTUATOR_TYPE_MASK BIT(5) |
103 | |
104 | /* DA7280_TOP_CFG2 (Address 0x14) */ |
105 | #define DA7280_FULL_BRAKE_THR_MASK GENMASK(3, 0) |
106 | #define DA7280_MEM_DATA_SIGNED_MASK BIT(4) |
107 | |
108 | /* DA7280_TOP_CFG4 (Address 0x16) */ |
109 | #define DA7280_TST_CALIB_IMPEDANCE_DIS_MASK BIT(6) |
110 | #define DA7280_V2I_FACTOR_FREEZE_MASK BIT(7) |
111 | |
112 | /* DA7280_TOP_INT_CFG1 (Address 0x17) */ |
113 | #define DA7280_BEMF_FAULT_LIM_MASK GENMASK(1, 0) |
114 | |
115 | /* DA7280_TOP_CTL1 (Address 0x22) */ |
116 | #define DA7280_OPERATION_MODE_MASK GENMASK(2, 0) |
117 | #define DA7280_STANDBY_EN_MASK BIT(3) |
118 | #define DA7280_SEQ_START_MASK BIT(4) |
119 | |
120 | /* DA7280_SEQ_CTL2 (Address 0x28) */ |
121 | #define DA7280_PS_SEQ_ID_MASK GENMASK(3, 0) |
122 | #define DA7280_PS_SEQ_LOOP_MASK GENMASK(7, 4) |
123 | |
124 | /* DA7280_GPIO_0_CTL (Address 0x29) */ |
125 | #define DA7280_GPI0_POLARITY_MASK GENMASK(1, 0) |
126 | #define DA7280_GPI0_MODE_MASK BIT(2) |
127 | #define DA7280_GPI0_SEQUENCE_ID_MASK GENMASK(6, 3) |
128 | |
129 | /* DA7280_GPIO_1_CTL (Address 0x2a) */ |
130 | #define DA7280_GPI1_POLARITY_MASK GENMASK(1, 0) |
131 | #define DA7280_GPI1_MODE_MASK BIT(2) |
132 | #define DA7280_GPI1_SEQUENCE_ID_MASK GENMASK(6, 3) |
133 | |
134 | /* DA7280_GPIO_2_CTL (Address 0x2b) */ |
135 | #define DA7280_GPI2_POLARITY_MASK GENMASK(1, 0) |
136 | #define DA7280_GPI2_MODE_MASK BIT(2) |
137 | #define DA7280_GPI2_SEQUENCE_ID_MASK GENMASK(6, 3) |
138 | |
139 | /* DA7280_MEM_CTL2 (Address 0x2d) */ |
140 | #define DA7280_WAV_MEM_LOCK_MASK BIT(7) |
141 | |
142 | /* DA7280_TOP_CFG5 (Address 0x6e) */ |
143 | #define DA7280_V2I_FACTOR_OFFSET_EN_MASK BIT(0) |
144 | |
145 | /* DA7280_IRQ_MASK2 (Address 0x83) */ |
146 | #define DA7280_ADC_SAT_M_MASK BIT(7) |
147 | |
148 | /* Controls */ |
149 | |
150 | #define DA7280_VOLTAGE_RATE_MAX 6000000 |
151 | #define DA7280_VOLTAGE_RATE_STEP 23400 |
152 | #define DA7280_NOMMAX_DFT 0x6B |
153 | #define DA7280_ABSMAX_DFT 0x78 |
154 | |
155 | #define DA7280_IMPD_MAX 1500000000 |
156 | #define DA7280_IMPD_DEFAULT 22000000 |
157 | |
158 | #define DA7280_IMAX_DEFAULT 0x0E |
159 | #define DA7280_IMAX_STEP 7200 |
160 | #define DA7280_IMAX_LIMIT 252000 |
161 | |
162 | #define DA7280_RESONT_FREQH_DFT 0x39 |
163 | #define DA7280_RESONT_FREQL_DFT 0x32 |
164 | #define DA7280_MIN_RESONAT_FREQ_HZ 50 |
165 | #define DA7280_MAX_RESONAT_FREQ_HZ 300 |
166 | |
167 | #define DA7280_SEQ_ID_MAX 15 |
168 | #define DA7280_SEQ_LOOP_MAX 15 |
169 | #define DA7280_GPI_SEQ_ID_DFT 0 |
170 | #define DA7280_GPI_SEQ_ID_MAX 2 |
171 | |
172 | #define DA7280_SNP_MEM_SIZE 100 |
173 | #define DA7280_SNP_MEM_MAX DA7280_SNP_MEM_99 |
174 | |
175 | #define DA7280_IRQ_NUM 3 |
176 | |
177 | #define DA7280_SKIP_INIT 0x100 |
178 | |
179 | #define DA7280_FF_EFFECT_COUNT_MAX 15 |
180 | |
181 | /* Maximum gain is 0x7fff for PWM mode */ |
182 | #define DA7280_MAX_MAGNITUDE_SHIFT 15 |
183 | |
184 | enum da7280_haptic_dev_t { |
185 | DA7280_LRA = 0, |
186 | DA7280_ERM_BAR = 1, |
187 | DA7280_ERM_COIN = 2, |
188 | DA7280_DEV_MAX, |
189 | }; |
190 | |
191 | enum da7280_op_mode { |
192 | DA7280_INACTIVE = 0, |
193 | DA7280_DRO_MODE = 1, |
194 | DA7280_PWM_MODE = 2, |
195 | DA7280_RTWM_MODE = 3, |
196 | DA7280_ETWM_MODE = 4, |
197 | DA7280_OPMODE_MAX, |
198 | }; |
199 | |
200 | #define DA7280_FF_CONSTANT_DRO 1 |
201 | #define DA7280_FF_PERIODIC_PWM 2 |
202 | #define DA7280_FF_PERIODIC_RTWM 1 |
203 | #define DA7280_FF_PERIODIC_ETWM 2 |
204 | |
205 | #define DA7280_FF_PERIODIC_MODE DA7280_RTWM_MODE |
206 | #define DA7280_FF_CONSTANT_MODE DA7280_DRO_MODE |
207 | |
208 | enum da7280_custom_effect_param { |
209 | DA7280_CUSTOM_SEQ_ID_IDX = 0, |
210 | DA7280_CUSTOM_SEQ_LOOP_IDX = 1, |
211 | DA7280_CUSTOM_DATA_LEN = 2, |
212 | }; |
213 | |
214 | enum da7280_custom_gpi_effect_param { |
215 | DA7280_CUSTOM_GPI_SEQ_ID_IDX = 0, |
216 | DA7280_CUSTOM_GPI_NUM_IDX = 2, |
217 | DA7280_CUSTOM_GP_DATA_LEN = 3, |
218 | }; |
219 | |
220 | struct da7280_gpi_ctl { |
221 | u8 seq_id; |
222 | u8 mode; |
223 | u8 polarity; |
224 | }; |
225 | |
226 | struct da7280_haptic { |
227 | struct regmap *regmap; |
228 | struct input_dev *input_dev; |
229 | struct device *dev; |
230 | struct i2c_client *client; |
231 | struct pwm_device *pwm_dev; |
232 | |
233 | bool legacy; |
234 | struct work_struct work; |
235 | int val; |
236 | u16 gain; |
237 | s16 level; |
238 | |
239 | u8 dev_type; |
240 | u8 op_mode; |
241 | u8 const_op_mode; |
242 | u8 periodic_op_mode; |
243 | u16 nommax; |
244 | u16 absmax; |
245 | u32 imax; |
246 | u32 impd; |
247 | u32 resonant_freq_h; |
248 | u32 resonant_freq_l; |
249 | bool bemf_sense_en; |
250 | bool freq_track_en; |
251 | bool acc_en; |
252 | bool rapid_stop_en; |
253 | bool amp_pid_en; |
254 | u8 ps_seq_id; |
255 | u8 ps_seq_loop; |
256 | struct da7280_gpi_ctl gpi_ctl[3]; |
257 | bool mem_update; |
258 | u8 snp_mem[DA7280_SNP_MEM_SIZE]; |
259 | bool active; |
260 | bool suspended; |
261 | }; |
262 | |
263 | static bool da7280_volatile_register(struct device *dev, unsigned int reg) |
264 | { |
265 | switch (reg) { |
266 | case DA7280_IRQ_EVENT1: |
267 | case DA7280_IRQ_EVENT_WARNING_DIAG: |
268 | case DA7280_IRQ_EVENT_SEQ_DIAG: |
269 | case DA7280_IRQ_STATUS1: |
270 | case DA7280_TOP_CTL1: |
271 | return true; |
272 | default: |
273 | return false; |
274 | } |
275 | } |
276 | |
277 | static const struct regmap_config da7280_haptic_regmap_config = { |
278 | .reg_bits = 8, |
279 | .val_bits = 8, |
280 | .max_register = DA7280_SNP_MEM_MAX, |
281 | .volatile_reg = da7280_volatile_register, |
282 | }; |
283 | |
284 | static int da7280_haptic_mem_update(struct da7280_haptic *haptics) |
285 | { |
286 | unsigned int val; |
287 | int error; |
288 | |
289 | /* The patterns should be updated when haptic is not working */ |
290 | error = regmap_read(map: haptics->regmap, DA7280_IRQ_STATUS1, val: &val); |
291 | if (error) |
292 | return error; |
293 | if (val & DA7280_STA_WARNING_MASK) { |
294 | dev_warn(haptics->dev, |
295 | "Warning! Please check HAPTIC status.\n" ); |
296 | return -EBUSY; |
297 | } |
298 | |
299 | /* Patterns are not updated if the lock bit is enabled */ |
300 | val = 0; |
301 | error = regmap_read(map: haptics->regmap, DA7280_MEM_CTL2, val: &val); |
302 | if (error) |
303 | return error; |
304 | if (~val & DA7280_WAV_MEM_LOCK_MASK) { |
305 | dev_warn(haptics->dev, "Please unlock the bit first\n" ); |
306 | return -EACCES; |
307 | } |
308 | |
309 | /* Set to Inactive mode to make sure safety */ |
310 | error = regmap_update_bits(map: haptics->regmap, |
311 | DA7280_TOP_CTL1, |
312 | DA7280_OPERATION_MODE_MASK, |
313 | val: 0); |
314 | if (error) |
315 | return error; |
316 | |
317 | error = regmap_read(map: haptics->regmap, DA7280_MEM_CTL1, val: &val); |
318 | if (error) |
319 | return error; |
320 | |
321 | return regmap_bulk_write(map: haptics->regmap, reg: val, val: haptics->snp_mem, |
322 | DA7280_SNP_MEM_MAX - val + 1); |
323 | } |
324 | |
325 | static int da7280_haptic_set_pwm(struct da7280_haptic *haptics, bool enabled) |
326 | { |
327 | struct pwm_state state; |
328 | u64 period_mag_multi; |
329 | int error; |
330 | |
331 | if (!haptics->gain && enabled) { |
332 | dev_err(haptics->dev, "Unable to enable pwm with 0 gain\n" ); |
333 | return -EINVAL; |
334 | } |
335 | |
336 | pwm_get_state(pwm: haptics->pwm_dev, state: &state); |
337 | state.enabled = enabled; |
338 | if (enabled) { |
339 | period_mag_multi = (u64)state.period * haptics->gain; |
340 | period_mag_multi >>= DA7280_MAX_MAGNITUDE_SHIFT; |
341 | |
342 | /* |
343 | * The interpretation of duty cycle depends on the acc_en, |
344 | * it should be between 50% and 100% for acc_en = 0. |
345 | * See datasheet 'PWM mode' section. |
346 | */ |
347 | if (!haptics->acc_en) { |
348 | period_mag_multi += state.period; |
349 | period_mag_multi /= 2; |
350 | } |
351 | |
352 | state.duty_cycle = period_mag_multi; |
353 | } |
354 | |
355 | error = pwm_apply_might_sleep(pwm: haptics->pwm_dev, state: &state); |
356 | if (error) |
357 | dev_err(haptics->dev, "Failed to apply pwm state: %d\n" , error); |
358 | |
359 | return error; |
360 | } |
361 | |
362 | static void da7280_haptic_activate(struct da7280_haptic *haptics) |
363 | { |
364 | int error; |
365 | |
366 | if (haptics->active) |
367 | return; |
368 | |
369 | switch (haptics->op_mode) { |
370 | case DA7280_DRO_MODE: |
371 | /* the valid range check when acc_en is enabled */ |
372 | if (haptics->acc_en && haptics->level > 0x7F) |
373 | haptics->level = 0x7F; |
374 | else if (haptics->level > 0xFF) |
375 | haptics->level = 0xFF; |
376 | |
377 | /* Set level as a % of ACTUATOR_NOMMAX (nommax) */ |
378 | error = regmap_write(map: haptics->regmap, DA7280_TOP_CTL2, |
379 | val: haptics->level); |
380 | if (error) { |
381 | dev_err(haptics->dev, |
382 | "Failed to set level to %d: %d\n" , |
383 | haptics->level, error); |
384 | return; |
385 | } |
386 | break; |
387 | |
388 | case DA7280_PWM_MODE: |
389 | if (da7280_haptic_set_pwm(haptics, enabled: true)) |
390 | return; |
391 | break; |
392 | |
393 | case DA7280_RTWM_MODE: |
394 | /* |
395 | * The pattern will be played by the PS_SEQ_ID and the |
396 | * PS_SEQ_LOOP |
397 | */ |
398 | break; |
399 | |
400 | case DA7280_ETWM_MODE: |
401 | /* |
402 | * The pattern will be played by the GPI[N] state, |
403 | * GPI(N)_SEQUENCE_ID and the PS_SEQ_LOOP. See the |
404 | * datasheet for the details. |
405 | */ |
406 | break; |
407 | |
408 | default: |
409 | dev_err(haptics->dev, "Invalid op mode %d\n" , haptics->op_mode); |
410 | return; |
411 | } |
412 | |
413 | error = regmap_update_bits(map: haptics->regmap, |
414 | DA7280_TOP_CTL1, |
415 | DA7280_OPERATION_MODE_MASK, |
416 | val: haptics->op_mode); |
417 | if (error) { |
418 | dev_err(haptics->dev, |
419 | "Failed to set operation mode: %d" , error); |
420 | return; |
421 | } |
422 | |
423 | if (haptics->op_mode == DA7280_PWM_MODE || |
424 | haptics->op_mode == DA7280_RTWM_MODE) { |
425 | error = regmap_update_bits(map: haptics->regmap, |
426 | DA7280_TOP_CTL1, |
427 | DA7280_SEQ_START_MASK, |
428 | DA7280_SEQ_START_MASK); |
429 | if (error) { |
430 | dev_err(haptics->dev, |
431 | "Failed to start sequence: %d\n" , error); |
432 | return; |
433 | } |
434 | } |
435 | |
436 | haptics->active = true; |
437 | } |
438 | |
439 | static void da7280_haptic_deactivate(struct da7280_haptic *haptics) |
440 | { |
441 | int error; |
442 | |
443 | if (!haptics->active) |
444 | return; |
445 | |
446 | /* Set to Inactive mode */ |
447 | error = regmap_update_bits(map: haptics->regmap, |
448 | DA7280_TOP_CTL1, |
449 | DA7280_OPERATION_MODE_MASK, val: 0); |
450 | if (error) { |
451 | dev_err(haptics->dev, |
452 | "Failed to clear operation mode: %d" , error); |
453 | return; |
454 | } |
455 | |
456 | switch (haptics->op_mode) { |
457 | case DA7280_DRO_MODE: |
458 | error = regmap_write(map: haptics->regmap, |
459 | DA7280_TOP_CTL2, val: 0); |
460 | if (error) { |
461 | dev_err(haptics->dev, |
462 | "Failed to disable DRO mode: %d\n" , error); |
463 | return; |
464 | } |
465 | break; |
466 | |
467 | case DA7280_PWM_MODE: |
468 | if (da7280_haptic_set_pwm(haptics, enabled: false)) |
469 | return; |
470 | break; |
471 | |
472 | case DA7280_RTWM_MODE: |
473 | case DA7280_ETWM_MODE: |
474 | error = regmap_update_bits(map: haptics->regmap, |
475 | DA7280_TOP_CTL1, |
476 | DA7280_SEQ_START_MASK, val: 0); |
477 | if (error) { |
478 | dev_err(haptics->dev, |
479 | "Failed to disable RTWM/ETWM mode: %d\n" , |
480 | error); |
481 | return; |
482 | } |
483 | break; |
484 | |
485 | default: |
486 | dev_err(haptics->dev, "Invalid op mode %d\n" , haptics->op_mode); |
487 | return; |
488 | } |
489 | |
490 | haptics->active = false; |
491 | } |
492 | |
493 | static void da7280_haptic_work(struct work_struct *work) |
494 | { |
495 | struct da7280_haptic *haptics = |
496 | container_of(work, struct da7280_haptic, work); |
497 | int val = haptics->val; |
498 | |
499 | if (val) |
500 | da7280_haptic_activate(haptics); |
501 | else |
502 | da7280_haptic_deactivate(haptics); |
503 | } |
504 | |
505 | static int da7280_haptics_upload_effect(struct input_dev *dev, |
506 | struct ff_effect *effect, |
507 | struct ff_effect *old) |
508 | { |
509 | struct da7280_haptic *haptics = input_get_drvdata(dev); |
510 | s16 data[DA7280_SNP_MEM_SIZE] = { 0 }; |
511 | unsigned int val; |
512 | int tmp, i, num; |
513 | int error; |
514 | |
515 | /* The effect should be uploaded when haptic is not working */ |
516 | if (haptics->active) |
517 | return -EBUSY; |
518 | |
519 | switch (effect->type) { |
520 | /* DRO/PWM modes support this type */ |
521 | case FF_CONSTANT: |
522 | haptics->op_mode = haptics->const_op_mode; |
523 | if (haptics->op_mode == DA7280_DRO_MODE) { |
524 | tmp = effect->u.constant.level * 254; |
525 | haptics->level = tmp / 0x7FFF; |
526 | break; |
527 | } |
528 | |
529 | haptics->gain = effect->u.constant.level <= 0 ? |
530 | 0 : effect->u.constant.level; |
531 | break; |
532 | |
533 | /* RTWM/ETWM modes support this type */ |
534 | case FF_PERIODIC: |
535 | if (effect->u.periodic.waveform != FF_CUSTOM) { |
536 | dev_err(haptics->dev, |
537 | "Device can only accept FF_CUSTOM waveform\n" ); |
538 | return -EINVAL; |
539 | } |
540 | |
541 | /* |
542 | * Load the data and check the length. |
543 | * the data will be patterns in this case: 4 < X <= 100, |
544 | * and will be saved into the waveform memory inside DA728x. |
545 | * If X = 2, the data will be PS_SEQ_ID and PS_SEQ_LOOP. |
546 | * If X = 3, the 1st data will be GPIX_SEQUENCE_ID . |
547 | */ |
548 | if (effect->u.periodic.custom_len == DA7280_CUSTOM_DATA_LEN) |
549 | goto set_seq_id_loop; |
550 | |
551 | if (effect->u.periodic.custom_len == DA7280_CUSTOM_GP_DATA_LEN) |
552 | goto set_gpix_seq_id; |
553 | |
554 | if (effect->u.periodic.custom_len < DA7280_CUSTOM_DATA_LEN || |
555 | effect->u.periodic.custom_len > DA7280_SNP_MEM_SIZE) { |
556 | dev_err(haptics->dev, "Invalid waveform data size\n" ); |
557 | return -EINVAL; |
558 | } |
559 | |
560 | if (copy_from_user(to: data, from: effect->u.periodic.custom_data, |
561 | n: sizeof(s16) * |
562 | effect->u.periodic.custom_len)) |
563 | return -EFAULT; |
564 | |
565 | memset(haptics->snp_mem, 0, DA7280_SNP_MEM_SIZE); |
566 | |
567 | for (i = 0; i < effect->u.periodic.custom_len; i++) { |
568 | if (data[i] < 0 || data[i] > 0xff) { |
569 | dev_err(haptics->dev, |
570 | "Invalid waveform data %d at offset %d\n" , |
571 | data[i], i); |
572 | return -EINVAL; |
573 | } |
574 | haptics->snp_mem[i] = (u8)data[i]; |
575 | } |
576 | |
577 | error = da7280_haptic_mem_update(haptics); |
578 | if (error) { |
579 | dev_err(haptics->dev, |
580 | "Failed to upload waveform: %d\n" , error); |
581 | return error; |
582 | } |
583 | break; |
584 | |
585 | set_seq_id_loop: |
586 | if (copy_from_user(to: data, from: effect->u.periodic.custom_data, |
587 | n: sizeof(s16) * DA7280_CUSTOM_DATA_LEN)) |
588 | return -EFAULT; |
589 | |
590 | if (data[DA7280_CUSTOM_SEQ_ID_IDX] < 0 || |
591 | data[DA7280_CUSTOM_SEQ_ID_IDX] > DA7280_SEQ_ID_MAX || |
592 | data[DA7280_CUSTOM_SEQ_LOOP_IDX] < 0 || |
593 | data[DA7280_CUSTOM_SEQ_LOOP_IDX] > DA7280_SEQ_LOOP_MAX) { |
594 | dev_err(haptics->dev, |
595 | "Invalid custom id (%d) or loop (%d)\n" , |
596 | data[DA7280_CUSTOM_SEQ_ID_IDX], |
597 | data[DA7280_CUSTOM_SEQ_LOOP_IDX]); |
598 | return -EINVAL; |
599 | } |
600 | |
601 | haptics->ps_seq_id = data[DA7280_CUSTOM_SEQ_ID_IDX] & 0x0f; |
602 | haptics->ps_seq_loop = data[DA7280_CUSTOM_SEQ_LOOP_IDX] & 0x0f; |
603 | haptics->op_mode = haptics->periodic_op_mode; |
604 | |
605 | val = FIELD_PREP(DA7280_PS_SEQ_ID_MASK, haptics->ps_seq_id) | |
606 | FIELD_PREP(DA7280_PS_SEQ_LOOP_MASK, |
607 | haptics->ps_seq_loop); |
608 | error = regmap_write(map: haptics->regmap, DA7280_SEQ_CTL2, val); |
609 | if (error) { |
610 | dev_err(haptics->dev, |
611 | "Failed to update PS sequence: %d\n" , error); |
612 | return error; |
613 | } |
614 | break; |
615 | |
616 | set_gpix_seq_id: |
617 | if (copy_from_user(to: data, from: effect->u.periodic.custom_data, |
618 | n: sizeof(s16) * DA7280_CUSTOM_GP_DATA_LEN)) |
619 | return -EFAULT; |
620 | |
621 | if (data[DA7280_CUSTOM_GPI_SEQ_ID_IDX] < 0 || |
622 | data[DA7280_CUSTOM_GPI_SEQ_ID_IDX] > DA7280_SEQ_ID_MAX || |
623 | data[DA7280_CUSTOM_GPI_NUM_IDX] < 0 || |
624 | data[DA7280_CUSTOM_GPI_NUM_IDX] > DA7280_GPI_SEQ_ID_MAX) { |
625 | dev_err(haptics->dev, |
626 | "Invalid custom GPI id (%d) or num (%d)\n" , |
627 | data[DA7280_CUSTOM_GPI_SEQ_ID_IDX], |
628 | data[DA7280_CUSTOM_GPI_NUM_IDX]); |
629 | return -EINVAL; |
630 | } |
631 | |
632 | num = data[DA7280_CUSTOM_GPI_NUM_IDX] & 0x0f; |
633 | haptics->gpi_ctl[num].seq_id = |
634 | data[DA7280_CUSTOM_GPI_SEQ_ID_IDX] & 0x0f; |
635 | haptics->op_mode = haptics->periodic_op_mode; |
636 | |
637 | val = FIELD_PREP(DA7280_GPI0_SEQUENCE_ID_MASK, |
638 | haptics->gpi_ctl[num].seq_id); |
639 | error = regmap_update_bits(map: haptics->regmap, |
640 | DA7280_GPI_0_CTL + num, |
641 | DA7280_GPI0_SEQUENCE_ID_MASK, |
642 | val); |
643 | if (error) { |
644 | dev_err(haptics->dev, |
645 | "Failed to update GPI sequence: %d\n" , error); |
646 | return error; |
647 | } |
648 | break; |
649 | |
650 | default: |
651 | dev_err(haptics->dev, "Unsupported effect type: %d\n" , |
652 | effect->type); |
653 | return -EINVAL; |
654 | } |
655 | |
656 | return 0; |
657 | } |
658 | |
659 | static int da7280_haptics_playback(struct input_dev *dev, |
660 | int effect_id, int val) |
661 | { |
662 | struct da7280_haptic *haptics = input_get_drvdata(dev); |
663 | |
664 | if (!haptics->op_mode) { |
665 | dev_warn(haptics->dev, "No effects have been uploaded\n" ); |
666 | return -EINVAL; |
667 | } |
668 | |
669 | if (likely(!haptics->suspended)) { |
670 | haptics->val = val; |
671 | schedule_work(work: &haptics->work); |
672 | } |
673 | |
674 | return 0; |
675 | } |
676 | |
677 | static int da7280_haptic_start(struct da7280_haptic *haptics) |
678 | { |
679 | int error; |
680 | |
681 | error = regmap_update_bits(map: haptics->regmap, |
682 | DA7280_TOP_CTL1, |
683 | DA7280_STANDBY_EN_MASK, |
684 | DA7280_STANDBY_EN_MASK); |
685 | if (error) { |
686 | dev_err(haptics->dev, "Unable to enable device: %d\n" , error); |
687 | return error; |
688 | } |
689 | |
690 | return 0; |
691 | } |
692 | |
693 | static void da7280_haptic_stop(struct da7280_haptic *haptics) |
694 | { |
695 | int error; |
696 | |
697 | cancel_work_sync(work: &haptics->work); |
698 | |
699 | |
700 | da7280_haptic_deactivate(haptics); |
701 | |
702 | error = regmap_update_bits(map: haptics->regmap, DA7280_TOP_CTL1, |
703 | DA7280_STANDBY_EN_MASK, val: 0); |
704 | if (error) |
705 | dev_err(haptics->dev, "Failed to disable device: %d\n" , error); |
706 | } |
707 | |
708 | static int da7280_haptic_open(struct input_dev *dev) |
709 | { |
710 | struct da7280_haptic *haptics = input_get_drvdata(dev); |
711 | |
712 | return da7280_haptic_start(haptics); |
713 | } |
714 | |
715 | static void da7280_haptic_close(struct input_dev *dev) |
716 | { |
717 | struct da7280_haptic *haptics = input_get_drvdata(dev); |
718 | |
719 | da7280_haptic_stop(haptics); |
720 | } |
721 | |
722 | static u8 da7280_haptic_of_mode_str(struct device *dev, |
723 | const char *str) |
724 | { |
725 | if (!strcmp(str, "LRA" )) { |
726 | return DA7280_LRA; |
727 | } else if (!strcmp(str, "ERM-bar" )) { |
728 | return DA7280_ERM_BAR; |
729 | } else if (!strcmp(str, "ERM-coin" )) { |
730 | return DA7280_ERM_COIN; |
731 | } else { |
732 | dev_warn(dev, "Invalid string - set to LRA\n" ); |
733 | return DA7280_LRA; |
734 | } |
735 | } |
736 | |
737 | static u8 da7280_haptic_of_gpi_mode_str(struct device *dev, |
738 | const char *str) |
739 | { |
740 | if (!strcmp(str, "Single-pattern" )) { |
741 | return 0; |
742 | } else if (!strcmp(str, "Multi-pattern" )) { |
743 | return 1; |
744 | } else { |
745 | dev_warn(dev, "Invalid string - set to Single-pattern\n" ); |
746 | return 0; |
747 | } |
748 | } |
749 | |
750 | static u8 da7280_haptic_of_gpi_pol_str(struct device *dev, |
751 | const char *str) |
752 | { |
753 | if (!strcmp(str, "Rising-edge" )) { |
754 | return 0; |
755 | } else if (!strcmp(str, "Falling-edge" )) { |
756 | return 1; |
757 | } else if (!strcmp(str, "Both-edge" )) { |
758 | return 2; |
759 | } else { |
760 | dev_warn(dev, "Invalid string - set to Rising-edge\n" ); |
761 | return 0; |
762 | } |
763 | } |
764 | |
765 | static u8 da7280_haptic_of_volt_rating_set(u32 val) |
766 | { |
767 | u32 voltage = val / DA7280_VOLTAGE_RATE_STEP + 1; |
768 | |
769 | return min_t(u32, voltage, 0xff); |
770 | } |
771 | |
772 | static void da7280_parse_properties(struct device *dev, |
773 | struct da7280_haptic *haptics) |
774 | { |
775 | unsigned int i, mem[DA7280_SNP_MEM_SIZE]; |
776 | char gpi_str1[] = "dlg,gpi0-seq-id" ; |
777 | char gpi_str2[] = "dlg,gpi0-mode" ; |
778 | char gpi_str3[] = "dlg,gpi0-polarity" ; |
779 | const char *str; |
780 | u32 val; |
781 | int error; |
782 | |
783 | /* |
784 | * If there is no property, then use the mode programmed into the chip. |
785 | */ |
786 | haptics->dev_type = DA7280_DEV_MAX; |
787 | error = device_property_read_string(dev, propname: "dlg,actuator-type" , val: &str); |
788 | if (!error) |
789 | haptics->dev_type = da7280_haptic_of_mode_str(dev, str); |
790 | |
791 | haptics->const_op_mode = DA7280_DRO_MODE; |
792 | error = device_property_read_u32(dev, propname: "dlg,const-op-mode" , val: &val); |
793 | if (!error && val == DA7280_FF_PERIODIC_PWM) |
794 | haptics->const_op_mode = DA7280_PWM_MODE; |
795 | |
796 | haptics->periodic_op_mode = DA7280_RTWM_MODE; |
797 | error = device_property_read_u32(dev, propname: "dlg,periodic-op-mode" , val: &val); |
798 | if (!error && val == DA7280_FF_PERIODIC_ETWM) |
799 | haptics->periodic_op_mode = DA7280_ETWM_MODE; |
800 | |
801 | haptics->nommax = DA7280_SKIP_INIT; |
802 | error = device_property_read_u32(dev, propname: "dlg,nom-microvolt" , val: &val); |
803 | if (!error && val < DA7280_VOLTAGE_RATE_MAX) |
804 | haptics->nommax = da7280_haptic_of_volt_rating_set(val); |
805 | |
806 | haptics->absmax = DA7280_SKIP_INIT; |
807 | error = device_property_read_u32(dev, propname: "dlg,abs-max-microvolt" , val: &val); |
808 | if (!error && val < DA7280_VOLTAGE_RATE_MAX) |
809 | haptics->absmax = da7280_haptic_of_volt_rating_set(val); |
810 | |
811 | haptics->imax = DA7280_IMAX_DEFAULT; |
812 | error = device_property_read_u32(dev, propname: "dlg,imax-microamp" , val: &val); |
813 | if (!error && val < DA7280_IMAX_LIMIT) |
814 | haptics->imax = (val - 28600) / DA7280_IMAX_STEP + 1; |
815 | |
816 | haptics->impd = DA7280_IMPD_DEFAULT; |
817 | error = device_property_read_u32(dev, propname: "dlg,impd-micro-ohms" , val: &val); |
818 | if (!error && val <= DA7280_IMPD_MAX) |
819 | haptics->impd = val; |
820 | |
821 | haptics->resonant_freq_h = DA7280_SKIP_INIT; |
822 | haptics->resonant_freq_l = DA7280_SKIP_INIT; |
823 | error = device_property_read_u32(dev, propname: "dlg,resonant-freq-hz" , val: &val); |
824 | if (!error) { |
825 | if (val < DA7280_MAX_RESONAT_FREQ_HZ && |
826 | val > DA7280_MIN_RESONAT_FREQ_HZ) { |
827 | haptics->resonant_freq_h = |
828 | ((1000000000 / (val * 1333)) >> 7) & 0xFF; |
829 | haptics->resonant_freq_l = |
830 | (1000000000 / (val * 1333)) & 0x7F; |
831 | } else { |
832 | haptics->resonant_freq_h = DA7280_RESONT_FREQH_DFT; |
833 | haptics->resonant_freq_l = DA7280_RESONT_FREQL_DFT; |
834 | } |
835 | } |
836 | |
837 | /* If no property, set to zero as default is to do nothing. */ |
838 | haptics->ps_seq_id = 0; |
839 | error = device_property_read_u32(dev, propname: "dlg,ps-seq-id" , val: &val); |
840 | if (!error && val <= DA7280_SEQ_ID_MAX) |
841 | haptics->ps_seq_id = val; |
842 | |
843 | haptics->ps_seq_loop = 0; |
844 | error = device_property_read_u32(dev, propname: "dlg,ps-seq-loop" , val: &val); |
845 | if (!error && val <= DA7280_SEQ_LOOP_MAX) |
846 | haptics->ps_seq_loop = val; |
847 | |
848 | /* GPI0~2 Control */ |
849 | for (i = 0; i <= DA7280_GPI_SEQ_ID_MAX; i++) { |
850 | gpi_str1[7] = '0' + i; |
851 | haptics->gpi_ctl[i].seq_id = DA7280_GPI_SEQ_ID_DFT + i; |
852 | error = device_property_read_u32 (dev, propname: gpi_str1, val: &val); |
853 | if (!error && val <= DA7280_SEQ_ID_MAX) |
854 | haptics->gpi_ctl[i].seq_id = val; |
855 | |
856 | gpi_str2[7] = '0' + i; |
857 | haptics->gpi_ctl[i].mode = 0; |
858 | error = device_property_read_string(dev, propname: gpi_str2, val: &str); |
859 | if (!error) |
860 | haptics->gpi_ctl[i].mode = |
861 | da7280_haptic_of_gpi_mode_str(dev, str); |
862 | |
863 | gpi_str3[7] = '0' + i; |
864 | haptics->gpi_ctl[i].polarity = 0; |
865 | error = device_property_read_string(dev, propname: gpi_str3, val: &str); |
866 | if (!error) |
867 | haptics->gpi_ctl[i].polarity = |
868 | da7280_haptic_of_gpi_pol_str(dev, str); |
869 | } |
870 | |
871 | haptics->bemf_sense_en = |
872 | device_property_read_bool(dev, propname: "dlg,bemf-sens-enable" ); |
873 | haptics->freq_track_en = |
874 | device_property_read_bool(dev, propname: "dlg,freq-track-enable" ); |
875 | haptics->acc_en = |
876 | device_property_read_bool(dev, propname: "dlg,acc-enable" ); |
877 | haptics->rapid_stop_en = |
878 | device_property_read_bool(dev, propname: "dlg,rapid-stop-enable" ); |
879 | haptics->amp_pid_en = |
880 | device_property_read_bool(dev, propname: "dlg,amp-pid-enable" ); |
881 | |
882 | haptics->mem_update = false; |
883 | error = device_property_read_u32_array(dev, propname: "dlg,mem-array" , |
884 | val: &mem[0], DA7280_SNP_MEM_SIZE); |
885 | if (!error) { |
886 | haptics->mem_update = true; |
887 | memset(haptics->snp_mem, 0, DA7280_SNP_MEM_SIZE); |
888 | for (i = 0; i < DA7280_SNP_MEM_SIZE; i++) { |
889 | if (mem[i] <= 0xff) { |
890 | haptics->snp_mem[i] = (u8)mem[i]; |
891 | } else { |
892 | dev_err(haptics->dev, |
893 | "Invalid data in mem-array at %d: %x\n" , |
894 | i, mem[i]); |
895 | haptics->mem_update = false; |
896 | break; |
897 | } |
898 | } |
899 | } |
900 | } |
901 | |
902 | static irqreturn_t da7280_irq_handler(int irq, void *data) |
903 | { |
904 | struct da7280_haptic *haptics = data; |
905 | struct device *dev = haptics->dev; |
906 | u8 events[DA7280_IRQ_NUM]; |
907 | int error; |
908 | |
909 | /* Check what events have happened */ |
910 | error = regmap_bulk_read(map: haptics->regmap, DA7280_IRQ_EVENT1, |
911 | val: events, val_count: sizeof(events)); |
912 | if (error) { |
913 | dev_err(dev, "failed to read interrupt data: %d\n" , error); |
914 | goto out; |
915 | } |
916 | |
917 | /* Clear events */ |
918 | error = regmap_write(map: haptics->regmap, DA7280_IRQ_EVENT1, val: events[0]); |
919 | if (error) { |
920 | dev_err(dev, "failed to clear interrupts: %d\n" , error); |
921 | goto out; |
922 | } |
923 | |
924 | if (events[0] & DA7280_E_SEQ_FAULT_MASK) { |
925 | /* |
926 | * Stop first if haptic is active, otherwise, the fault may |
927 | * happen continually even though the bit is cleared. |
928 | */ |
929 | error = regmap_update_bits(map: haptics->regmap, DA7280_TOP_CTL1, |
930 | DA7280_OPERATION_MODE_MASK, val: 0); |
931 | if (error) |
932 | dev_err(dev, "failed to clear op mode on fault: %d\n" , |
933 | error); |
934 | } |
935 | |
936 | if (events[0] & DA7280_E_SEQ_DONE_MASK) |
937 | haptics->active = false; |
938 | |
939 | if (events[0] & DA7280_E_WARNING_MASK) { |
940 | if (events[1] & DA7280_E_LIM_DRIVE_MASK || |
941 | events[1] & DA7280_E_LIM_DRIVE_ACC_MASK) |
942 | dev_warn(dev, "Please reduce the driver level\n" ); |
943 | if (events[1] & DA7280_E_MEM_TYPE_MASK) |
944 | dev_warn(dev, "Please check the mem data format\n" ); |
945 | if (events[1] & DA7280_E_OVERTEMP_WARN_MASK) |
946 | dev_warn(dev, "Over-temperature warning\n" ); |
947 | } |
948 | |
949 | if (events[0] & DA7280_E_SEQ_FAULT_MASK) { |
950 | if (events[2] & DA7280_E_SEQ_ID_FAULT_MASK) |
951 | dev_info(dev, "Please reload PS_SEQ_ID & mem data\n" ); |
952 | if (events[2] & DA7280_E_MEM_FAULT_MASK) |
953 | dev_info(dev, "Please reload the mem data\n" ); |
954 | if (events[2] & DA7280_E_PWM_FAULT_MASK) |
955 | dev_info(dev, "Please restart PWM interface\n" ); |
956 | } |
957 | |
958 | out: |
959 | return IRQ_HANDLED; |
960 | } |
961 | |
962 | static int da7280_init(struct da7280_haptic *haptics) |
963 | { |
964 | unsigned int val = 0; |
965 | u32 v2i_factor; |
966 | int error, i; |
967 | u8 mask = 0; |
968 | |
969 | /* |
970 | * If device type is DA7280_DEV_MAX then simply use currently |
971 | * programmed mode. |
972 | */ |
973 | if (haptics->dev_type == DA7280_DEV_MAX) { |
974 | error = regmap_read(map: haptics->regmap, DA7280_TOP_CFG1, val: &val); |
975 | if (error) |
976 | goto out_err; |
977 | |
978 | haptics->dev_type = val & DA7280_ACTUATOR_TYPE_MASK ? |
979 | DA7280_ERM_COIN : DA7280_LRA; |
980 | } |
981 | |
982 | /* Apply user settings */ |
983 | if (haptics->dev_type == DA7280_LRA && |
984 | haptics->resonant_freq_l != DA7280_SKIP_INIT) { |
985 | error = regmap_write(map: haptics->regmap, DA7280_FRQ_LRA_PER_H, |
986 | val: haptics->resonant_freq_h); |
987 | if (error) |
988 | goto out_err; |
989 | error = regmap_write(map: haptics->regmap, DA7280_FRQ_LRA_PER_L, |
990 | val: haptics->resonant_freq_l); |
991 | if (error) |
992 | goto out_err; |
993 | } else if (haptics->dev_type == DA7280_ERM_COIN) { |
994 | error = regmap_update_bits(map: haptics->regmap, DA7280_TOP_INT_CFG1, |
995 | DA7280_BEMF_FAULT_LIM_MASK, val: 0); |
996 | if (error) |
997 | goto out_err; |
998 | |
999 | mask = DA7280_TST_CALIB_IMPEDANCE_DIS_MASK | |
1000 | DA7280_V2I_FACTOR_FREEZE_MASK; |
1001 | val = DA7280_TST_CALIB_IMPEDANCE_DIS_MASK | |
1002 | DA7280_V2I_FACTOR_FREEZE_MASK; |
1003 | error = regmap_update_bits(map: haptics->regmap, DA7280_TOP_CFG4, |
1004 | mask, val); |
1005 | if (error) |
1006 | goto out_err; |
1007 | |
1008 | haptics->acc_en = false; |
1009 | haptics->rapid_stop_en = false; |
1010 | haptics->amp_pid_en = false; |
1011 | } |
1012 | |
1013 | mask = DA7280_ACTUATOR_TYPE_MASK | |
1014 | DA7280_BEMF_SENSE_EN_MASK | |
1015 | DA7280_FREQ_TRACK_EN_MASK | |
1016 | DA7280_ACCELERATION_EN_MASK | |
1017 | DA7280_RAPID_STOP_EN_MASK | |
1018 | DA7280_AMP_PID_EN_MASK; |
1019 | val = FIELD_PREP(DA7280_ACTUATOR_TYPE_MASK, |
1020 | (haptics->dev_type ? 1 : 0)) | |
1021 | FIELD_PREP(DA7280_BEMF_SENSE_EN_MASK, |
1022 | (haptics->bemf_sense_en ? 1 : 0)) | |
1023 | FIELD_PREP(DA7280_FREQ_TRACK_EN_MASK, |
1024 | (haptics->freq_track_en ? 1 : 0)) | |
1025 | FIELD_PREP(DA7280_ACCELERATION_EN_MASK, |
1026 | (haptics->acc_en ? 1 : 0)) | |
1027 | FIELD_PREP(DA7280_RAPID_STOP_EN_MASK, |
1028 | (haptics->rapid_stop_en ? 1 : 0)) | |
1029 | FIELD_PREP(DA7280_AMP_PID_EN_MASK, |
1030 | (haptics->amp_pid_en ? 1 : 0)); |
1031 | |
1032 | error = regmap_update_bits(map: haptics->regmap, DA7280_TOP_CFG1, mask, val); |
1033 | if (error) |
1034 | goto out_err; |
1035 | |
1036 | error = regmap_update_bits(map: haptics->regmap, DA7280_TOP_CFG5, |
1037 | DA7280_V2I_FACTOR_OFFSET_EN_MASK, |
1038 | val: haptics->acc_en ? |
1039 | DA7280_V2I_FACTOR_OFFSET_EN_MASK : 0); |
1040 | if (error) |
1041 | goto out_err; |
1042 | |
1043 | error = regmap_update_bits(map: haptics->regmap, |
1044 | DA7280_TOP_CFG2, |
1045 | DA7280_MEM_DATA_SIGNED_MASK, |
1046 | val: haptics->acc_en ? |
1047 | 0 : DA7280_MEM_DATA_SIGNED_MASK); |
1048 | if (error) |
1049 | goto out_err; |
1050 | |
1051 | if (haptics->nommax != DA7280_SKIP_INIT) { |
1052 | error = regmap_write(map: haptics->regmap, DA7280_ACTUATOR1, |
1053 | val: haptics->nommax); |
1054 | if (error) |
1055 | goto out_err; |
1056 | } |
1057 | |
1058 | if (haptics->absmax != DA7280_SKIP_INIT) { |
1059 | error = regmap_write(map: haptics->regmap, DA7280_ACTUATOR2, |
1060 | val: haptics->absmax); |
1061 | if (error) |
1062 | goto out_err; |
1063 | } |
1064 | |
1065 | error = regmap_update_bits(map: haptics->regmap, DA7280_ACTUATOR3, |
1066 | DA7280_IMAX_MASK, val: haptics->imax); |
1067 | if (error) |
1068 | goto out_err; |
1069 | |
1070 | v2i_factor = haptics->impd * (haptics->imax + 4) / 1610400; |
1071 | error = regmap_write(map: haptics->regmap, DA7280_CALIB_V2I_L, |
1072 | val: v2i_factor & 0xff); |
1073 | if (error) |
1074 | goto out_err; |
1075 | error = regmap_write(map: haptics->regmap, DA7280_CALIB_V2I_H, |
1076 | val: v2i_factor >> 8); |
1077 | if (error) |
1078 | goto out_err; |
1079 | |
1080 | error = regmap_update_bits(map: haptics->regmap, |
1081 | DA7280_TOP_CTL1, |
1082 | DA7280_STANDBY_EN_MASK, |
1083 | DA7280_STANDBY_EN_MASK); |
1084 | if (error) |
1085 | goto out_err; |
1086 | |
1087 | if (haptics->mem_update) { |
1088 | error = da7280_haptic_mem_update(haptics); |
1089 | if (error) |
1090 | goto out_err; |
1091 | } |
1092 | |
1093 | /* Set PS_SEQ_ID and PS_SEQ_LOOP */ |
1094 | val = FIELD_PREP(DA7280_PS_SEQ_ID_MASK, haptics->ps_seq_id) | |
1095 | FIELD_PREP(DA7280_PS_SEQ_LOOP_MASK, haptics->ps_seq_loop); |
1096 | error = regmap_write(map: haptics->regmap, DA7280_SEQ_CTL2, val); |
1097 | if (error) |
1098 | goto out_err; |
1099 | |
1100 | /* GPI(N) CTL */ |
1101 | for (i = 0; i < 3; i++) { |
1102 | val = FIELD_PREP(DA7280_GPI0_SEQUENCE_ID_MASK, |
1103 | haptics->gpi_ctl[i].seq_id) | |
1104 | FIELD_PREP(DA7280_GPI0_MODE_MASK, |
1105 | haptics->gpi_ctl[i].mode) | |
1106 | FIELD_PREP(DA7280_GPI0_POLARITY_MASK, |
1107 | haptics->gpi_ctl[i].polarity); |
1108 | error = regmap_write(map: haptics->regmap, |
1109 | DA7280_GPI_0_CTL + i, val); |
1110 | if (error) |
1111 | goto out_err; |
1112 | } |
1113 | |
1114 | /* Mask ADC_SAT_M bit as default */ |
1115 | error = regmap_update_bits(map: haptics->regmap, |
1116 | DA7280_IRQ_MASK2, |
1117 | DA7280_ADC_SAT_M_MASK, |
1118 | DA7280_ADC_SAT_M_MASK); |
1119 | if (error) |
1120 | goto out_err; |
1121 | |
1122 | /* Clear Interrupts */ |
1123 | error = regmap_write(map: haptics->regmap, DA7280_IRQ_EVENT1, val: 0xff); |
1124 | if (error) |
1125 | goto out_err; |
1126 | |
1127 | error = regmap_update_bits(map: haptics->regmap, |
1128 | DA7280_IRQ_MASK1, |
1129 | DA7280_SEQ_FAULT_M_MASK | |
1130 | DA7280_SEQ_DONE_M_MASK, |
1131 | val: 0); |
1132 | if (error) |
1133 | goto out_err; |
1134 | |
1135 | haptics->active = false; |
1136 | return 0; |
1137 | |
1138 | out_err: |
1139 | dev_err(haptics->dev, "chip initialization error: %d\n" , error); |
1140 | return error; |
1141 | } |
1142 | |
1143 | static int da7280_probe(struct i2c_client *client) |
1144 | { |
1145 | struct device *dev = &client->dev; |
1146 | struct da7280_haptic *haptics; |
1147 | struct input_dev *input_dev; |
1148 | struct pwm_state state; |
1149 | struct ff_device *ff; |
1150 | int error; |
1151 | |
1152 | if (!client->irq) { |
1153 | dev_err(dev, "No IRQ configured\n" ); |
1154 | return -EINVAL; |
1155 | } |
1156 | |
1157 | haptics = devm_kzalloc(dev, size: sizeof(*haptics), GFP_KERNEL); |
1158 | if (!haptics) |
1159 | return -ENOMEM; |
1160 | |
1161 | haptics->dev = dev; |
1162 | |
1163 | da7280_parse_properties(dev, haptics); |
1164 | |
1165 | if (haptics->const_op_mode == DA7280_PWM_MODE) { |
1166 | haptics->pwm_dev = devm_pwm_get(dev, NULL); |
1167 | error = PTR_ERR_OR_ZERO(ptr: haptics->pwm_dev); |
1168 | if (error) { |
1169 | if (error != -EPROBE_DEFER) |
1170 | dev_err(dev, "Unable to request PWM: %d\n" , |
1171 | error); |
1172 | return error; |
1173 | } |
1174 | |
1175 | /* Sync up PWM state and ensure it is off. */ |
1176 | pwm_init_state(pwm: haptics->pwm_dev, state: &state); |
1177 | state.enabled = false; |
1178 | error = pwm_apply_might_sleep(pwm: haptics->pwm_dev, state: &state); |
1179 | if (error) { |
1180 | dev_err(dev, "Failed to apply PWM state: %d\n" , error); |
1181 | return error; |
1182 | } |
1183 | |
1184 | /* |
1185 | * Check PWM period, PWM freq = 1000000 / state.period. |
1186 | * The valid PWM freq range: 10k ~ 250kHz. |
1187 | */ |
1188 | if (state.period > 100000 || state.period < 4000) { |
1189 | dev_err(dev, "Unsupported PWM period: %lld\n" , |
1190 | state.period); |
1191 | return -EINVAL; |
1192 | } |
1193 | } |
1194 | |
1195 | INIT_WORK(&haptics->work, da7280_haptic_work); |
1196 | |
1197 | haptics->client = client; |
1198 | i2c_set_clientdata(client, data: haptics); |
1199 | |
1200 | haptics->regmap = devm_regmap_init_i2c(client, |
1201 | &da7280_haptic_regmap_config); |
1202 | error = PTR_ERR_OR_ZERO(ptr: haptics->regmap); |
1203 | if (error) { |
1204 | dev_err(dev, "Failed to allocate register map: %d\n" , error); |
1205 | return error; |
1206 | } |
1207 | |
1208 | error = da7280_init(haptics); |
1209 | if (error) { |
1210 | dev_err(dev, "Failed to initialize device: %d\n" , error); |
1211 | return error; |
1212 | } |
1213 | |
1214 | /* Initialize input device for haptic device */ |
1215 | input_dev = devm_input_allocate_device(dev); |
1216 | if (!input_dev) { |
1217 | dev_err(dev, "Failed to allocate input device\n" ); |
1218 | return -ENOMEM; |
1219 | } |
1220 | |
1221 | input_dev->name = "da7280-haptic" ; |
1222 | input_dev->dev.parent = client->dev.parent; |
1223 | input_dev->open = da7280_haptic_open; |
1224 | input_dev->close = da7280_haptic_close; |
1225 | input_set_drvdata(dev: input_dev, data: haptics); |
1226 | haptics->input_dev = input_dev; |
1227 | |
1228 | input_set_capability(dev: haptics->input_dev, EV_FF, FF_PERIODIC); |
1229 | input_set_capability(dev: haptics->input_dev, EV_FF, FF_CUSTOM); |
1230 | input_set_capability(dev: haptics->input_dev, EV_FF, FF_CONSTANT); |
1231 | input_set_capability(dev: haptics->input_dev, EV_FF, FF_GAIN); |
1232 | |
1233 | error = input_ff_create(dev: haptics->input_dev, |
1234 | DA7280_FF_EFFECT_COUNT_MAX); |
1235 | if (error) { |
1236 | dev_err(dev, "Failed to create FF input device: %d\n" , error); |
1237 | return error; |
1238 | } |
1239 | |
1240 | ff = input_dev->ff; |
1241 | ff->upload = da7280_haptics_upload_effect; |
1242 | ff->playback = da7280_haptics_playback; |
1243 | |
1244 | error = input_register_device(input_dev); |
1245 | if (error) { |
1246 | dev_err(dev, "Failed to register input device: %d\n" , error); |
1247 | return error; |
1248 | } |
1249 | |
1250 | error = devm_request_threaded_irq(dev, irq: client->irq, |
1251 | NULL, thread_fn: da7280_irq_handler, |
1252 | IRQF_ONESHOT, |
1253 | devname: "da7280-haptics" , dev_id: haptics); |
1254 | if (error) { |
1255 | dev_err(dev, "Failed to request IRQ %d: %d\n" , |
1256 | client->irq, error); |
1257 | return error; |
1258 | } |
1259 | |
1260 | return 0; |
1261 | } |
1262 | |
1263 | static int da7280_suspend(struct device *dev) |
1264 | { |
1265 | struct da7280_haptic *haptics = dev_get_drvdata(dev); |
1266 | |
1267 | mutex_lock(&haptics->input_dev->mutex); |
1268 | |
1269 | /* |
1270 | * Make sure no new requests will be submitted while device is |
1271 | * suspended. |
1272 | */ |
1273 | spin_lock_irq(lock: &haptics->input_dev->event_lock); |
1274 | haptics->suspended = true; |
1275 | spin_unlock_irq(lock: &haptics->input_dev->event_lock); |
1276 | |
1277 | da7280_haptic_stop(haptics); |
1278 | |
1279 | mutex_unlock(lock: &haptics->input_dev->mutex); |
1280 | |
1281 | return 0; |
1282 | } |
1283 | |
1284 | static int da7280_resume(struct device *dev) |
1285 | { |
1286 | struct da7280_haptic *haptics = dev_get_drvdata(dev); |
1287 | int retval; |
1288 | |
1289 | mutex_lock(&haptics->input_dev->mutex); |
1290 | |
1291 | retval = da7280_haptic_start(haptics); |
1292 | if (!retval) { |
1293 | spin_lock_irq(lock: &haptics->input_dev->event_lock); |
1294 | haptics->suspended = false; |
1295 | spin_unlock_irq(lock: &haptics->input_dev->event_lock); |
1296 | } |
1297 | |
1298 | mutex_unlock(lock: &haptics->input_dev->mutex); |
1299 | return retval; |
1300 | } |
1301 | |
1302 | #ifdef CONFIG_OF |
1303 | static const struct of_device_id da7280_of_match[] = { |
1304 | { .compatible = "dlg,da7280" , }, |
1305 | { } |
1306 | }; |
1307 | MODULE_DEVICE_TABLE(of, da7280_of_match); |
1308 | #endif |
1309 | |
1310 | static const struct i2c_device_id da7280_i2c_id[] = { |
1311 | { "da7280" , }, |
1312 | { } |
1313 | }; |
1314 | MODULE_DEVICE_TABLE(i2c, da7280_i2c_id); |
1315 | |
1316 | static DEFINE_SIMPLE_DEV_PM_OPS(da7280_pm_ops, da7280_suspend, da7280_resume); |
1317 | |
1318 | static struct i2c_driver da7280_driver = { |
1319 | .driver = { |
1320 | .name = "da7280" , |
1321 | .of_match_table = of_match_ptr(da7280_of_match), |
1322 | .pm = pm_sleep_ptr(&da7280_pm_ops), |
1323 | }, |
1324 | .probe = da7280_probe, |
1325 | .id_table = da7280_i2c_id, |
1326 | }; |
1327 | module_i2c_driver(da7280_driver); |
1328 | |
1329 | MODULE_DESCRIPTION("DA7280 haptics driver" ); |
1330 | MODULE_AUTHOR("Roy Im <Roy.Im.Opensource@diasemi.com>" ); |
1331 | MODULE_LICENSE("GPL" ); |
1332 | |