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(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 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 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 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 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(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 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 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 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 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, "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 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 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 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 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 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