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
da7280_volatile_register(struct device * dev,unsigned int reg)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
da7280_haptic_mem_update(struct da7280_haptic * haptics)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(haptics->regmap, DA7280_IRQ_STATUS1, &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(haptics->regmap, DA7280_MEM_CTL2, &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(haptics->regmap,
311 DA7280_TOP_CTL1,
312 DA7280_OPERATION_MODE_MASK,
313 0);
314 if (error)
315 return error;
316
317 error = regmap_read(haptics->regmap, DA7280_MEM_CTL1, &val);
318 if (error)
319 return error;
320
321 return regmap_bulk_write(haptics->regmap, val, haptics->snp_mem,
322 DA7280_SNP_MEM_MAX - val + 1);
323 }
324
da7280_haptic_set_pwm(struct da7280_haptic * haptics,bool enabled)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(haptics->pwm_dev, &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(haptics->pwm_dev, &state);
356 if (error)
357 dev_err(haptics->dev, "Failed to apply pwm state: %d\n", error);
358
359 return error;
360 }
361
da7280_haptic_activate(struct da7280_haptic * haptics)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(haptics->regmap, DA7280_TOP_CTL2,
379 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, 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(haptics->regmap,
414 DA7280_TOP_CTL1,
415 DA7280_OPERATION_MODE_MASK,
416 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(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
da7280_haptic_deactivate(struct da7280_haptic * haptics)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(haptics->regmap,
448 DA7280_TOP_CTL1,
449 DA7280_OPERATION_MODE_MASK, 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(haptics->regmap,
459 DA7280_TOP_CTL2, 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, false))
469 return;
470 break;
471
472 case DA7280_RTWM_MODE:
473 case DA7280_ETWM_MODE:
474 error = regmap_update_bits(haptics->regmap,
475 DA7280_TOP_CTL1,
476 DA7280_SEQ_START_MASK, 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
da7280_haptic_work(struct work_struct * work)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
da7280_haptics_upload_effect(struct input_dev * dev,struct ff_effect * effect,struct ff_effect * old)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(data, effect->u.periodic.custom_data,
561 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(data, effect->u.periodic.custom_data,
587 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(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(data, effect->u.periodic.custom_data,
618 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(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
da7280_haptics_playback(struct input_dev * dev,int effect_id,int val)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(&haptics->work);
672 }
673
674 return 0;
675 }
676
da7280_haptic_start(struct da7280_haptic * haptics)677 static int da7280_haptic_start(struct da7280_haptic *haptics)
678 {
679 int error;
680
681 error = regmap_update_bits(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
da7280_haptic_stop(struct da7280_haptic * haptics)693 static void da7280_haptic_stop(struct da7280_haptic *haptics)
694 {
695 int error;
696
697 cancel_work_sync(&haptics->work);
698
699
700 da7280_haptic_deactivate(haptics);
701
702 error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1,
703 DA7280_STANDBY_EN_MASK, 0);
704 if (error)
705 dev_err(haptics->dev, "Failed to disable device: %d\n", error);
706 }
707
da7280_haptic_open(struct input_dev * dev)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
da7280_haptic_close(struct input_dev * dev)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
da7280_haptic_of_mode_str(struct device * dev,const char * str)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
da7280_haptic_of_gpi_mode_str(struct device * dev,const char * str)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
da7280_haptic_of_gpi_pol_str(struct device * dev,const char * str)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
da7280_haptic_of_volt_rating_set(u32 val)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
da7280_parse_properties(struct device * dev,struct da7280_haptic * haptics)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, "dlg,actuator-type", &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, "dlg,const-op-mode", &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, "dlg,periodic-op-mode", &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, "dlg,nom-microvolt", &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, "dlg,abs-max-microvolt", &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, "dlg,imax-microamp", &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, "dlg,impd-micro-ohms", &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, "dlg,resonant-freq-hz", &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, "dlg,ps-seq-id", &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, "dlg,ps-seq-loop", &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, gpi_str1, &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, gpi_str2, &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, gpi_str3, &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, "dlg,bemf-sens-enable");
873 haptics->freq_track_en =
874 device_property_read_bool(dev, "dlg,freq-track-enable");
875 haptics->acc_en =
876 device_property_read_bool(dev, "dlg,acc-enable");
877 haptics->rapid_stop_en =
878 device_property_read_bool(dev, "dlg,rapid-stop-enable");
879 haptics->amp_pid_en =
880 device_property_read_bool(dev, "dlg,amp-pid-enable");
881
882 haptics->mem_update = false;
883 error = device_property_read_u32_array(dev, "dlg,mem-array",
884 &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
da7280_irq_handler(int irq,void * data)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(haptics->regmap, DA7280_IRQ_EVENT1,
911 events, 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(haptics->regmap, DA7280_IRQ_EVENT1, 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(haptics->regmap, DA7280_TOP_CTL1,
930 DA7280_OPERATION_MODE_MASK, 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
da7280_init(struct da7280_haptic * haptics)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(haptics->regmap, DA7280_TOP_CFG1, &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(haptics->regmap, DA7280_FRQ_LRA_PER_H,
986 haptics->resonant_freq_h);
987 if (error)
988 goto out_err;
989 error = regmap_write(haptics->regmap, DA7280_FRQ_LRA_PER_L,
990 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(haptics->regmap, DA7280_TOP_INT_CFG1,
995 DA7280_BEMF_FAULT_LIM_MASK, 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(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(haptics->regmap, DA7280_TOP_CFG1, mask, val);
1033 if (error)
1034 goto out_err;
1035
1036 error = regmap_update_bits(haptics->regmap, DA7280_TOP_CFG5,
1037 DA7280_V2I_FACTOR_OFFSET_EN_MASK,
1038 haptics->acc_en ?
1039 DA7280_V2I_FACTOR_OFFSET_EN_MASK : 0);
1040 if (error)
1041 goto out_err;
1042
1043 error = regmap_update_bits(haptics->regmap,
1044 DA7280_TOP_CFG2,
1045 DA7280_MEM_DATA_SIGNED_MASK,
1046 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(haptics->regmap, DA7280_ACTUATOR1,
1053 haptics->nommax);
1054 if (error)
1055 goto out_err;
1056 }
1057
1058 if (haptics->absmax != DA7280_SKIP_INIT) {
1059 error = regmap_write(haptics->regmap, DA7280_ACTUATOR2,
1060 haptics->absmax);
1061 if (error)
1062 goto out_err;
1063 }
1064
1065 error = regmap_update_bits(haptics->regmap, DA7280_ACTUATOR3,
1066 DA7280_IMAX_MASK, haptics->imax);
1067 if (error)
1068 goto out_err;
1069
1070 v2i_factor = haptics->impd * (haptics->imax + 4) / 1610400;
1071 error = regmap_write(haptics->regmap, DA7280_CALIB_V2I_L,
1072 v2i_factor & 0xff);
1073 if (error)
1074 goto out_err;
1075 error = regmap_write(haptics->regmap, DA7280_CALIB_V2I_H,
1076 v2i_factor >> 8);
1077 if (error)
1078 goto out_err;
1079
1080 error = regmap_update_bits(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(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(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(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(haptics->regmap, DA7280_IRQ_EVENT1, 0xff);
1124 if (error)
1125 goto out_err;
1126
1127 error = regmap_update_bits(haptics->regmap,
1128 DA7280_IRQ_MASK1,
1129 DA7280_SEQ_FAULT_M_MASK |
1130 DA7280_SEQ_DONE_M_MASK,
1131 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
da7280_probe(struct i2c_client * client)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, 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(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(haptics->pwm_dev, &state);
1177 state.enabled = false;
1178 error = pwm_apply_might_sleep(haptics->pwm_dev, &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, haptics);
1199
1200 haptics->regmap = devm_regmap_init_i2c(client,
1201 &da7280_haptic_regmap_config);
1202 error = PTR_ERR_OR_ZERO(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(input_dev, haptics);
1226 haptics->input_dev = input_dev;
1227
1228 input_set_capability(haptics->input_dev, EV_FF, FF_PERIODIC);
1229 input_set_capability(haptics->input_dev, EV_FF, FF_CUSTOM);
1230 input_set_capability(haptics->input_dev, EV_FF, FF_CONSTANT);
1231 input_set_capability(haptics->input_dev, EV_FF, FF_GAIN);
1232
1233 error = input_ff_create(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, client->irq,
1251 NULL, da7280_irq_handler,
1252 IRQF_ONESHOT,
1253 "da7280-haptics", 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
da7280_suspend(struct device * dev)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(&haptics->input_dev->event_lock);
1274 haptics->suspended = true;
1275 spin_unlock_irq(&haptics->input_dev->event_lock);
1276
1277 da7280_haptic_stop(haptics);
1278
1279 mutex_unlock(&haptics->input_dev->mutex);
1280
1281 return 0;
1282 }
1283
da7280_resume(struct device * dev)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(&haptics->input_dev->event_lock);
1294 haptics->suspended = false;
1295 spin_unlock_irq(&haptics->input_dev->event_lock);
1296 }
1297
1298 mutex_unlock(&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