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