drivers/input/misc/drv260x.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * DRV260X haptics driver family
   4  *
   5  * Author: Dan Murphy <dmurphy@ti.com>
   6  *
   7  * Copyright:   (C) 2014 Texas Instruments, Inc.
   8  */
   9
  10 #include <linux/i2c.h>
  11 #include <linux/input.h>
  12 #include <linux/module.h>
  13 #include <linux/regmap.h>
  14 #include <linux/slab.h>
  15 #include <linux/delay.h>
  16 #include <linux/gpio/consumer.h>
  17 #include <linux/regulator/consumer.h>
  18
  19 #include <dt-bindings/input/ti-drv260x.h>
  20
  21 #define DRV260X_STATUS          0x0
  22 #define DRV260X_MODE            0x1
  23 #define DRV260X_RT_PB_IN        0x2
  24 #define DRV260X_LIB_SEL         0x3
  25 #define DRV260X_WV_SEQ_1        0x4
  26 #define DRV260X_WV_SEQ_2        0x5
  27 #define DRV260X_WV_SEQ_3        0x6
  28 #define DRV260X_WV_SEQ_4        0x7
  29 #define DRV260X_WV_SEQ_5        0x8
  30 #define DRV260X_WV_SEQ_6        0x9
  31 #define DRV260X_WV_SEQ_7        0xa
  32 #define DRV260X_WV_SEQ_8        0xb
  33 #define DRV260X_GO                              0xc
  34 #define DRV260X_OVERDRIVE_OFF   0xd
  35 #define DRV260X_SUSTAIN_P_OFF   0xe
  36 #define DRV260X_SUSTAIN_N_OFF   0xf
  37 #define DRV260X_BRAKE_OFF               0x10
  38 #define DRV260X_A_TO_V_CTRL             0x11
  39 #define DRV260X_A_TO_V_MIN_INPUT        0x12
  40 #define DRV260X_A_TO_V_MAX_INPUT        0x13
  41 #define DRV260X_A_TO_V_MIN_OUT  0x14
  42 #define DRV260X_A_TO_V_MAX_OUT  0x15
  43 #define DRV260X_RATED_VOLT              0x16
  44 #define DRV260X_OD_CLAMP_VOLT   0x17
  45 #define DRV260X_CAL_COMP                0x18
  46 #define DRV260X_CAL_BACK_EMF    0x19
  47 #define DRV260X_FEEDBACK_CTRL   0x1a
  48 #define DRV260X_CTRL1                   0x1b
  49 #define DRV260X_CTRL2                   0x1c
  50 #define DRV260X_CTRL3                   0x1d
  51 #define DRV260X_CTRL4                   0x1e
  52 #define DRV260X_CTRL5                   0x1f
  53 #define DRV260X_LRA_LOOP_PERIOD 0x20
  54 #define DRV260X_VBAT_MON                0x21
  55 #define DRV260X_LRA_RES_PERIOD  0x22
  56 #define DRV260X_MAX_REG                 0x23
  57
  58 #define DRV260X_GO_BIT                          0x01
  59
  60 /* Library Selection */
  61 #define DRV260X_LIB_SEL_MASK            0x07
  62 #define DRV260X_LIB_SEL_RAM                     0x0
  63 #define DRV260X_LIB_SEL_OD                      0x1
  64 #define DRV260X_LIB_SEL_40_60           0x2
  65 #define DRV260X_LIB_SEL_60_80           0x3
  66 #define DRV260X_LIB_SEL_100_140         0x4
  67 #define DRV260X_LIB_SEL_140_PLUS        0x5
  68
  69 #define DRV260X_LIB_SEL_HIZ_MASK        0x10
  70 #define DRV260X_LIB_SEL_HIZ_EN          0x01
  71 #define DRV260X_LIB_SEL_HIZ_DIS         0
  72
  73 /* Mode register */
  74 #define DRV260X_STANDBY                         (1 << 6)
  75 #define DRV260X_STANDBY_MASK            0x40
  76 #define DRV260X_INTERNAL_TRIGGER        0x00
  77 #define DRV260X_EXT_TRIGGER_EDGE        0x01
  78 #define DRV260X_EXT_TRIGGER_LEVEL       0x02
  79 #define DRV260X_PWM_ANALOG_IN           0x03
  80 #define DRV260X_AUDIOHAPTIC                     0x04
  81 #define DRV260X_RT_PLAYBACK                     0x05
  82 #define DRV260X_DIAGNOSTICS                     0x06
  83 #define DRV260X_AUTO_CAL                        0x07
  84
  85 /* Audio to Haptics Control */
  86 #define DRV260X_AUDIO_HAPTICS_PEAK_10MS         (0 << 2)
  87 #define DRV260X_AUDIO_HAPTICS_PEAK_20MS         (1 << 2)
  88 #define DRV260X_AUDIO_HAPTICS_PEAK_30MS         (2 << 2)
  89 #define DRV260X_AUDIO_HAPTICS_PEAK_40MS         (3 << 2)
  90
  91 #define DRV260X_AUDIO_HAPTICS_FILTER_100HZ      0x00
  92 #define DRV260X_AUDIO_HAPTICS_FILTER_125HZ      0x01
  93 #define DRV260X_AUDIO_HAPTICS_FILTER_150HZ      0x02
  94 #define DRV260X_AUDIO_HAPTICS_FILTER_200HZ      0x03
  95
  96 /* Min/Max Input/Output Voltages */
  97 #define DRV260X_AUDIO_HAPTICS_MIN_IN_VOLT       0x19
  98 #define DRV260X_AUDIO_HAPTICS_MAX_IN_VOLT       0x64
  99 #define DRV260X_AUDIO_HAPTICS_MIN_OUT_VOLT      0x19
 100 #define DRV260X_AUDIO_HAPTICS_MAX_OUT_VOLT      0xFF
 101
 102 /* Feedback register */
 103 #define DRV260X_FB_REG_ERM_MODE                 0x7f
 104 #define DRV260X_FB_REG_LRA_MODE                 (1 << 7)
 105
 106 #define DRV260X_BRAKE_FACTOR_MASK       0x1f
 107 #define DRV260X_BRAKE_FACTOR_2X         (1 << 0)
 108 #define DRV260X_BRAKE_FACTOR_3X         (2 << 4)
 109 #define DRV260X_BRAKE_FACTOR_4X         (3 << 4)
 110 #define DRV260X_BRAKE_FACTOR_6X         (4 << 4)
 111 #define DRV260X_BRAKE_FACTOR_8X         (5 << 4)
 112 #define DRV260X_BRAKE_FACTOR_16         (6 << 4)
 113 #define DRV260X_BRAKE_FACTOR_DIS        (7 << 4)
 114
 115 #define DRV260X_LOOP_GAIN_LOW           0xf3
 116 #define DRV260X_LOOP_GAIN_MED           (1 << 2)
 117 #define DRV260X_LOOP_GAIN_HIGH          (2 << 2)
 118 #define DRV260X_LOOP_GAIN_VERY_HIGH     (3 << 2)
 119
 120 #define DRV260X_BEMF_GAIN_0                     0xfc
 121 #define DRV260X_BEMF_GAIN_1             (1 << 0)
 122 #define DRV260X_BEMF_GAIN_2             (2 << 0)
 123 #define DRV260X_BEMF_GAIN_3             (3 << 0)
 124
 125 /* Control 1 register */
 126 #define DRV260X_AC_CPLE_EN                      (1 << 5)
 127 #define DRV260X_STARTUP_BOOST           (1 << 7)
 128
 129 /* Control 2 register */
 130
 131 #define DRV260X_IDISS_TIME_45           0
 132 #define DRV260X_IDISS_TIME_75           (1 << 0)
 133 #define DRV260X_IDISS_TIME_150          (1 << 1)
 134 #define DRV260X_IDISS_TIME_225          0x03
 135
 136 #define DRV260X_BLANK_TIME_45   (0 << 2)
 137 #define DRV260X_BLANK_TIME_75   (1 << 2)
 138 #define DRV260X_BLANK_TIME_150  (2 << 2)
 139 #define DRV260X_BLANK_TIME_225  (3 << 2)
 140
 141 #define DRV260X_SAMP_TIME_150   (0 << 4)
 142 #define DRV260X_SAMP_TIME_200   (1 << 4)
 143 #define DRV260X_SAMP_TIME_250   (2 << 4)
 144 #define DRV260X_SAMP_TIME_300   (3 << 4)
 145
 146 #define DRV260X_BRAKE_STABILIZER        (1 << 6)
 147 #define DRV260X_UNIDIR_IN                       (0 << 7)
 148 #define DRV260X_BIDIR_IN                        (1 << 7)
 149
 150 /* Control 3 Register */
 151 #define DRV260X_LRA_OPEN_LOOP           (1 << 0)
 152 #define DRV260X_ANALOG_IN                       (1 << 1)
 153 #define DRV260X_LRA_DRV_MODE            (1 << 2)
 154 #define DRV260X_RTP_UNSIGNED_DATA       (1 << 3)
 155 #define DRV260X_SUPPLY_COMP_DIS         (1 << 4)
 156 #define DRV260X_ERM_OPEN_LOOP           (1 << 5)
 157 #define DRV260X_NG_THRESH_0                     (0 << 6)
 158 #define DRV260X_NG_THRESH_2                     (1 << 6)
 159 #define DRV260X_NG_THRESH_4                     (2 << 6)
 160 #define DRV260X_NG_THRESH_8                     (3 << 6)
 161
 162 /* Control 4 Register */
 163 #define DRV260X_AUTOCAL_TIME_150MS              (0 << 4)
 164 #define DRV260X_AUTOCAL_TIME_250MS              (1 << 4)
 165 #define DRV260X_AUTOCAL_TIME_500MS              (2 << 4)
 166 #define DRV260X_AUTOCAL_TIME_1000MS             (3 << 4)
 167
 168 /**
 169  * struct drv260x_data -
 170  * @input_dev: Pointer to the input device
 171  * @client: Pointer to the I2C client
 172  * @regmap: Register map of the device
 173  * @work: Work item used to off load the enable/disable of the vibration
 174  * @enable_gpio: Pointer to the gpio used for enable/disabling
 175  * @regulator: Pointer to the regulator for the IC
 176  * @magnitude: Magnitude of the vibration event
 177  * @mode: The operating mode of the IC (LRA_NO_CAL, ERM or LRA)
 178  * @library: The vibration library to be used
 179  * @rated_voltage: The rated_voltage of the actuator
 180  * @overdrive_voltage: The over drive voltage of the actuator
 181 **/
 182 struct drv260x_data {
 183         struct input_dev *input_dev;
 184         struct i2c_client *client;
 185         struct regmap *regmap;
 186         struct work_struct work;
 187         struct gpio_desc *enable_gpio;
 188         struct regulator *regulator;
 189         u8 magnitude;
 190         u32 mode;
 191         u32 library;
 192         int rated_voltage;
 193         int overdrive_voltage;
 194 };
 195
 196 #define DRV260X_DEF_RATED_VOLT          0x90
 197 #define DRV260X_DEF_OD_CLAMP_VOLT       0x90
 198
 199 /*
 200  * Rated and Overdriver Voltages:
 201  * Calculated using the formula r = v * 255 / 5.6
 202  * where r is what will be written to the register
 203  * and v is the rated or overdriver voltage of the actuator
 204  */
 205 static int drv260x_calculate_voltage(unsigned int voltage)
 206 {
 207         return (voltage * 255 / 5600);
 208 }
 209
 210 static void drv260x_worker(struct work_struct *work)
 211 {
 212         struct drv260x_data *haptics = container_of(work, struct drv260x_data, work);
 213         int error;
 214
 215         gpiod_set_value(haptics->enable_gpio, 1);
 216         /* Data sheet says to wait 250us before trying to communicate */
 217         udelay(250);
 218
 219         error = regmap_write(haptics->regmap,
 220                              DRV260X_MODE, DRV260X_RT_PLAYBACK);
 221         if (error) {
 222                 dev_err(&haptics->client->dev,
 223                         "Failed to write set mode: %d\n", error);
 224         } else {
 225                 error = regmap_write(haptics->regmap,
 226                                      DRV260X_RT_PB_IN, haptics->magnitude);
 227                 if (error)
 228                         dev_err(&haptics->client->dev,
 229                                 "Failed to set magnitude: %d\n", error);
 230         }
 231 }
 232
 233 static int drv260x_haptics_play(struct input_dev *input, void *data,
 234                                 struct ff_effect *effect)
 235 {
 236         struct drv260x_data *haptics = input_get_drvdata(input);
 237
 238         haptics->mode = DRV260X_LRA_NO_CAL_MODE;
 239
 240         /* Scale u16 magnitude into u8 register value */
 241         if (effect->u.rumble.strong_magnitude > 0)
 242                 haptics->magnitude = effect->u.rumble.strong_magnitude >> 8;
 243         else if (effect->u.rumble.weak_magnitude > 0)
 244                 haptics->magnitude = effect->u.rumble.weak_magnitude >> 8;
 245         else
 246                 haptics->magnitude = 0;
 247
 248         schedule_work(&haptics->work);
 249
 250         return 0;
 251 }
 252
 253 static void drv260x_close(struct input_dev *input)
 254 {
 255         struct drv260x_data *haptics = input_get_drvdata(input);
 256         int error;
 257
 258         cancel_work_sync(&haptics->work);
 259
 260         error = regmap_write(haptics->regmap, DRV260X_MODE, DRV260X_STANDBY);
 261         if (error)
 262                 dev_err(&haptics->client->dev,
 263                         "Failed to enter standby mode: %d\n", error);
 264
 265         gpiod_set_value(haptics->enable_gpio, 0);
 266 }
 267
 268 static const struct reg_sequence drv260x_lra_cal_regs[] = {
 269         { DRV260X_MODE, DRV260X_AUTO_CAL },
 270         { DRV260X_CTRL3, DRV260X_NG_THRESH_2 | DRV260X_RTP_UNSIGNED_DATA },
 271         { DRV260X_FEEDBACK_CTRL, DRV260X_FB_REG_LRA_MODE |
 272                 DRV260X_BRAKE_FACTOR_4X | DRV260X_LOOP_GAIN_HIGH },
 273 };
 274
 275 static const struct reg_sequence drv260x_lra_init_regs[] = {
 276         { DRV260X_MODE, DRV260X_RT_PLAYBACK },
 277         { DRV260X_A_TO_V_CTRL, DRV260X_AUDIO_HAPTICS_PEAK_20MS |
 278                 DRV260X_AUDIO_HAPTICS_FILTER_125HZ },
 279         { DRV260X_A_TO_V_MIN_INPUT, DRV260X_AUDIO_HAPTICS_MIN_IN_VOLT },
 280         { DRV260X_A_TO_V_MAX_INPUT, DRV260X_AUDIO_HAPTICS_MAX_IN_VOLT },
 281         { DRV260X_A_TO_V_MIN_OUT, DRV260X_AUDIO_HAPTICS_MIN_OUT_VOLT },
 282         { DRV260X_A_TO_V_MAX_OUT, DRV260X_AUDIO_HAPTICS_MAX_OUT_VOLT },
 283         { DRV260X_FEEDBACK_CTRL, DRV260X_FB_REG_LRA_MODE |
 284                 DRV260X_BRAKE_FACTOR_2X | DRV260X_LOOP_GAIN_MED |
 285                 DRV260X_BEMF_GAIN_3 },
 286         { DRV260X_CTRL1, DRV260X_STARTUP_BOOST },
 287         { DRV260X_CTRL2, DRV260X_SAMP_TIME_250 },
 288         { DRV260X_CTRL3, DRV260X_NG_THRESH_2 | DRV260X_RTP_UNSIGNED_DATA | DRV260X_ANALOG_IN },
 289         { DRV260X_CTRL4, DRV260X_AUTOCAL_TIME_500MS },
 290 };
 291
 292 static const struct reg_sequence drv260x_erm_cal_regs[] = {
 293         { DRV260X_MODE, DRV260X_AUTO_CAL },
 294         { DRV260X_A_TO_V_MIN_INPUT, DRV260X_AUDIO_HAPTICS_MIN_IN_VOLT },
 295         { DRV260X_A_TO_V_MAX_INPUT, DRV260X_AUDIO_HAPTICS_MAX_IN_VOLT },
 296         { DRV260X_A_TO_V_MIN_OUT, DRV260X_AUDIO_HAPTICS_MIN_OUT_VOLT },
 297         { DRV260X_A_TO_V_MAX_OUT, DRV260X_AUDIO_HAPTICS_MAX_OUT_VOLT },
 298         { DRV260X_FEEDBACK_CTRL, DRV260X_BRAKE_FACTOR_3X |
 299                 DRV260X_LOOP_GAIN_MED | DRV260X_BEMF_GAIN_2 },
 300         { DRV260X_CTRL1, DRV260X_STARTUP_BOOST },
 301         { DRV260X_CTRL2, DRV260X_SAMP_TIME_250 | DRV260X_BLANK_TIME_75 |
 302                 DRV260X_IDISS_TIME_75 },
 303         { DRV260X_CTRL3, DRV260X_NG_THRESH_2 | DRV260X_RTP_UNSIGNED_DATA },
 304         { DRV260X_CTRL4, DRV260X_AUTOCAL_TIME_500MS },
 305 };
 306
 307 static int drv260x_init(struct drv260x_data *haptics)
 308 {
 309         int error;
 310         unsigned int cal_buf;
 311
 312         error = regmap_write(haptics->regmap,
 313                              DRV260X_RATED_VOLT, haptics->rated_voltage);
 314         if (error) {
 315                 dev_err(&haptics->client->dev,
 316                         "Failed to write DRV260X_RATED_VOLT register: %d\n",
 317                         error);
 318                 return error;
 319         }
 320
 321         error = regmap_write(haptics->regmap,
 322                              DRV260X_OD_CLAMP_VOLT, haptics->overdrive_voltage);
 323         if (error) {
 324                 dev_err(&haptics->client->dev,
 325                         "Failed to write DRV260X_OD_CLAMP_VOLT register: %d\n",
 326                         error);
 327                 return error;
 328         }
 329
 330         switch (haptics->mode) {
 331         case DRV260X_LRA_MODE:
 332                 error = regmap_register_patch(haptics->regmap,
 333                                               drv260x_lra_cal_regs,
 334                                               ARRAY_SIZE(drv260x_lra_cal_regs));
 335                 if (error) {
 336                         dev_err(&haptics->client->dev,
 337                                 "Failed to write LRA calibration registers: %d\n",
 338                                 error);
 339                         return error;
 340                 }
 341
 342                 break;
 343
 344         case DRV260X_ERM_MODE:
 345                 error = regmap_register_patch(haptics->regmap,
 346                                               drv260x_erm_cal_regs,
 347                                               ARRAY_SIZE(drv260x_erm_cal_regs));
 348                 if (error) {
 349                         dev_err(&haptics->client->dev,
 350                                 "Failed to write ERM calibration registers: %d\n",
 351                                 error);
 352                         return error;
 353                 }
 354
 355                 error = regmap_update_bits(haptics->regmap, DRV260X_LIB_SEL,
 356                                            DRV260X_LIB_SEL_MASK,
 357                                            haptics->library);
 358                 if (error) {
 359                         dev_err(&haptics->client->dev,
 360                                 "Failed to write DRV260X_LIB_SEL register: %d\n",
 361                                 error);
 362                         return error;
 363                 }
 364
 365                 break;
 366
 367         default:
 368                 error = regmap_register_patch(haptics->regmap,
 369                                               drv260x_lra_init_regs,
 370                                               ARRAY_SIZE(drv260x_lra_init_regs));
 371                 if (error) {
 372                         dev_err(&haptics->client->dev,
 373                                 "Failed to write LRA init registers: %d\n",
 374                                 error);
 375                         return error;
 376                 }
 377
 378                 error = regmap_update_bits(haptics->regmap, DRV260X_LIB_SEL,
 379                                            DRV260X_LIB_SEL_MASK,
 380                                            haptics->library);
 381                 if (error) {
 382                         dev_err(&haptics->client->dev,
 383                                 "Failed to write DRV260X_LIB_SEL register: %d\n",
 384                                 error);
 385                         return error;
 386                 }
 387
 388                 /* No need to set GO bit here */
 389                 return 0;
 390         }
 391
 392         error = regmap_write(haptics->regmap, DRV260X_GO, DRV260X_GO_BIT);
 393         if (error) {
 394                 dev_err(&haptics->client->dev,
 395                         "Failed to write GO register: %d\n",
 396                         error);
 397                 return error;
 398         }
 399
 400         do {
 401                 usleep_range(15000, 15500);
 402                 error = regmap_read(haptics->regmap, DRV260X_GO, &cal_buf);
 403                 if (error) {
 404                         dev_err(&haptics->client->dev,
 405                                 "Failed to read GO register: %d\n",
 406                                 error);
 407                         return error;
 408                 }
 409         } while (cal_buf == DRV260X_GO_BIT);
 410
 411         return 0;
 412 }
 413
 414 static const struct regmap_config drv260x_regmap_config = {
 415         .reg_bits = 8,
 416         .val_bits = 8,
 417
 418         .max_register = DRV260X_MAX_REG,
 419         .cache_type = REGCACHE_NONE,
 420 };
 421
 422 static int drv260x_probe(struct i2c_client *client)
 423 {
 424         struct device *dev = &client->dev;
 425         struct drv260x_data *haptics;
 426         u32 voltage;
 427         int error;
 428
 429         haptics = devm_kzalloc(dev, sizeof(*haptics), GFP_KERNEL);
 430         if (!haptics)
 431                 return -ENOMEM;
 432
 433         error = device_property_read_u32(dev, "mode", &haptics->mode);
 434         if (error) {
 435                 dev_err(dev, "Can't fetch 'mode' property: %d\n", error);
 436                 return error;
 437         }
 438
 439         if (haptics->mode < DRV260X_LRA_MODE ||
 440             haptics->mode > DRV260X_ERM_MODE) {
 441                 dev_err(dev, "Vibrator mode is invalid: %i\n", haptics->mode);
 442                 return -EINVAL;
 443         }
 444
 445         error = device_property_read_u32(dev, "library-sel", &haptics->library);
 446         if (error) {
 447                 dev_err(dev, "Can't fetch 'library-sel' property: %d\n", error);
 448                 return error;
 449         }
 450
 451         if (haptics->library < DRV260X_LIB_EMPTY ||
 452             haptics->library > DRV260X_ERM_LIB_F) {
 453                 dev_err(dev,
 454                         "Library value is invalid: %i\n", haptics->library);
 455                 return -EINVAL;
 456         }
 457
 458         if (haptics->mode == DRV260X_LRA_MODE &&
 459             haptics->library != DRV260X_LIB_EMPTY &&
 460             haptics->library != DRV260X_LIB_LRA) {
 461                 dev_err(dev, "LRA Mode with ERM Library mismatch\n");
 462                 return -EINVAL;
 463         }
 464
 465         if (haptics->mode == DRV260X_ERM_MODE &&
 466             (haptics->library == DRV260X_LIB_EMPTY ||
 467              haptics->library == DRV260X_LIB_LRA)) {
 468                 dev_err(dev, "ERM Mode with LRA Library mismatch\n");
 469                 return -EINVAL;
 470         }
 471
 472         error = device_property_read_u32(dev, "vib-rated-mv", &voltage);
 473         haptics->rated_voltage = error ? DRV260X_DEF_RATED_VOLT :
 474                                          drv260x_calculate_voltage(voltage);
 475
 476         error = device_property_read_u32(dev, "vib-overdrive-mv", &voltage);
 477         haptics->overdrive_voltage = error ? DRV260X_DEF_OD_CLAMP_VOLT :
 478                                              drv260x_calculate_voltage(voltage);
 479
 480         haptics->regulator = devm_regulator_get(dev, "vbat");
 481         if (IS_ERR(haptics->regulator)) {
 482                 error = PTR_ERR(haptics->regulator);
 483                 dev_err(dev, "unable to get regulator, error: %d\n", error);
 484                 return error;
 485         }
 486
 487         haptics->enable_gpio = devm_gpiod_get_optional(dev, "enable",
 488                                                        GPIOD_OUT_HIGH);
 489         if (IS_ERR(haptics->enable_gpio))
 490                 return PTR_ERR(haptics->enable_gpio);
 491
 492         haptics->input_dev = devm_input_allocate_device(dev);
 493         if (!haptics->input_dev) {
 494                 dev_err(dev, "Failed to allocate input device\n");
 495                 return -ENOMEM;
 496         }
 497
 498         haptics->input_dev->name = "drv260x:haptics";
 499         haptics->input_dev->close = drv260x_close;
 500         input_set_drvdata(haptics->input_dev, haptics);
 501         input_set_capability(haptics->input_dev, EV_FF, FF_RUMBLE);
 502
 503         error = input_ff_create_memless(haptics->input_dev, NULL,
 504                                         drv260x_haptics_play);
 505         if (error) {
 506                 dev_err(dev, "input_ff_create() failed: %d\n", error);
 507                 return error;
 508         }
 509
 510         INIT_WORK(&haptics->work, drv260x_worker);
 511
 512         haptics->client = client;
 513         i2c_set_clientdata(client, haptics);
 514
 515         haptics->regmap = devm_regmap_init_i2c(client, &drv260x_regmap_config);
 516         if (IS_ERR(haptics->regmap)) {
 517                 error = PTR_ERR(haptics->regmap);
 518                 dev_err(dev, "Failed to allocate register map: %d\n", error);
 519                 return error;
 520         }
 521
 522         error = drv260x_init(haptics);
 523         if (error) {
 524                 dev_err(dev, "Device init failed: %d\n", error);
 525                 return error;
 526         }
 527
 528         error = input_register_device(haptics->input_dev);
 529         if (error) {
 530                 dev_err(dev, "couldn't register input device: %d\n", error);
 531                 return error;
 532         }
 533
 534         return 0;
 535 }
 536
 537 static int drv260x_suspend(struct device *dev)
 538 {
 539         struct drv260x_data *haptics = dev_get_drvdata(dev);
 540         int ret = 0;
 541
 542         mutex_lock(&haptics->input_dev->mutex);
 543
 544         if (input_device_enabled(haptics->input_dev)) {
 545                 ret = regmap_update_bits(haptics->regmap,
 546                                          DRV260X_MODE,
 547                                          DRV260X_STANDBY_MASK,
 548                                          DRV260X_STANDBY);
 549                 if (ret) {
 550                         dev_err(dev, "Failed to set standby mode\n");
 551                         goto out;
 552                 }
 553
 554                 gpiod_set_value(haptics->enable_gpio, 0);
 555
 556                 ret = regulator_disable(haptics->regulator);
 557                 if (ret) {
 558                         dev_err(dev, "Failed to disable regulator\n");
 559                         regmap_update_bits(haptics->regmap,
 560                                            DRV260X_MODE,
 561                                            DRV260X_STANDBY_MASK, 0);
 562                 }
 563         }
 564 out:
 565         mutex_unlock(&haptics->input_dev->mutex);
 566         return ret;
 567 }
 568
 569 static int drv260x_resume(struct device *dev)
 570 {
 571         struct drv260x_data *haptics = dev_get_drvdata(dev);
 572         int ret = 0;
 573
 574         mutex_lock(&haptics->input_dev->mutex);
 575
 576         if (input_device_enabled(haptics->input_dev)) {
 577                 ret = regulator_enable(haptics->regulator);
 578                 if (ret) {
 579                         dev_err(dev, "Failed to enable regulator\n");
 580                         goto out;
 581                 }
 582
 583                 ret = regmap_update_bits(haptics->regmap,
 584                                          DRV260X_MODE,
 585                                          DRV260X_STANDBY_MASK, 0);
 586                 if (ret) {
 587                         dev_err(dev, "Failed to unset standby mode\n");
 588                         regulator_disable(haptics->regulator);
 589                         goto out;
 590                 }
 591
 592                 gpiod_set_value(haptics->enable_gpio, 1);
 593         }
 594
 595 out:
 596         mutex_unlock(&haptics->input_dev->mutex);
 597         return ret;
 598 }
 599
 600 static DEFINE_SIMPLE_DEV_PM_OPS(drv260x_pm_ops, drv260x_suspend, drv260x_resume);
 601
 602 static const struct i2c_device_id drv260x_id[] = {
 603         { "drv2605l", 0 },
 604         { }
 605 };
 606 MODULE_DEVICE_TABLE(i2c, drv260x_id);
 607
 608 static const struct of_device_id drv260x_of_match[] = {
 609         { .compatible = "ti,drv2604", },
 610         { .compatible = "ti,drv2604l", },
 611         { .compatible = "ti,drv2605", },
 612         { .compatible = "ti,drv2605l", },
 613         { }
 614 };
 615 MODULE_DEVICE_TABLE(of, drv260x_of_match);
 616
 617 static struct i2c_driver drv260x_driver = {
 618         .probe          = drv260x_probe,
 619         .driver         = {
 620                 .name   = "drv260x-haptics",
 621                 .of_match_table = drv260x_of_match,
 622                 .pm     = pm_sleep_ptr(&drv260x_pm_ops),
 623         },
 624         .id_table = drv260x_id,
 625 };
 626 module_i2c_driver(drv260x_driver);
 627
 628 MODULE_DESCRIPTION("TI DRV260x haptics driver");
 629 MODULE_LICENSE("GPL");
 630 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");