drivers/input/misc/drv2667.c

   1 /*
   2  * DRV2667 haptics driver family
   3  *
   4  * Author: Dan Murphy <dmurphy@ti.com>
   5  *
   6  * Copyright: (C) 2014 Texas Instruments, Inc.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  */
  17
  18 #include <linux/i2c.h>
  19 #include <linux/input.h>
  20 #include <linux/module.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/regmap.h>
  23 #include <linux/slab.h>
  24 #include <linux/delay.h>
  25 #include <linux/regulator/consumer.h>
  26
  27 /* Contol registers */
  28 #define DRV2667_STATUS  0x00
  29 #define DRV2667_CTRL_1  0x01
  30 #define DRV2667_CTRL_2  0x02
  31 /* Waveform sequencer */
  32 #define DRV2667_WV_SEQ_0        0x03
  33 #define DRV2667_WV_SEQ_1        0x04
  34 #define DRV2667_WV_SEQ_2        0x05
  35 #define DRV2667_WV_SEQ_3        0x06
  36 #define DRV2667_WV_SEQ_4        0x07
  37 #define DRV2667_WV_SEQ_5        0x08
  38 #define DRV2667_WV_SEQ_6        0x09
  39 #define DRV2667_WV_SEQ_7        0x0A
  40 #define DRV2667_FIFO            0x0B
  41 #define DRV2667_PAGE            0xFF
  42 #define DRV2667_MAX_REG         DRV2667_PAGE
  43
  44 #define DRV2667_PAGE_0          0x00
  45 #define DRV2667_PAGE_1          0x01
  46 #define DRV2667_PAGE_2          0x02
  47 #define DRV2667_PAGE_3          0x03
  48 #define DRV2667_PAGE_4          0x04
  49 #define DRV2667_PAGE_5          0x05
  50 #define DRV2667_PAGE_6          0x06
  51 #define DRV2667_PAGE_7          0x07
  52 #define DRV2667_PAGE_8          0x08
  53
  54 /* RAM fields */
  55 #define DRV2667_RAM_HDR_SZ      0x0
  56 /* RAM Header addresses */
  57 #define DRV2667_RAM_START_HI    0x01
  58 #define DRV2667_RAM_START_LO    0x02
  59 #define DRV2667_RAM_STOP_HI             0x03
  60 #define DRV2667_RAM_STOP_LO             0x04
  61 #define DRV2667_RAM_REPEAT_CT   0x05
  62 /* RAM data addresses */
  63 #define DRV2667_RAM_AMP         0x06
  64 #define DRV2667_RAM_FREQ        0x07
  65 #define DRV2667_RAM_DURATION    0x08
  66 #define DRV2667_RAM_ENVELOPE    0x09
  67
  68 /* Control 1 Register */
  69 #define DRV2667_25_VPP_GAIN             0x00
  70 #define DRV2667_50_VPP_GAIN             0x01
  71 #define DRV2667_75_VPP_GAIN             0x02
  72 #define DRV2667_100_VPP_GAIN    0x03
  73 #define DRV2667_DIGITAL_IN              0xfc
  74 #define DRV2667_ANALOG_IN               (1 << 2)
  75
  76 /* Control 2 Register */
  77 #define DRV2667_GO                      (1 << 0)
  78 #define DRV2667_STANDBY         (1 << 6)
  79 #define DRV2667_DEV_RST         (1 << 7)
  80
  81 /* RAM Envelope settings */
  82 #define DRV2667_NO_ENV                  0x00
  83 #define DRV2667_32_MS_ENV               0x01
  84 #define DRV2667_64_MS_ENV               0x02
  85 #define DRV2667_96_MS_ENV               0x03
  86 #define DRV2667_128_MS_ENV              0x04
  87 #define DRV2667_160_MS_ENV              0x05
  88 #define DRV2667_192_MS_ENV              0x06
  89 #define DRV2667_224_MS_ENV              0x07
  90 #define DRV2667_256_MS_ENV              0x08
  91 #define DRV2667_512_MS_ENV              0x09
  92 #define DRV2667_768_MS_ENV              0x0a
  93 #define DRV2667_1024_MS_ENV             0x0b
  94 #define DRV2667_1280_MS_ENV             0x0c
  95 #define DRV2667_1536_MS_ENV             0x0d
  96 #define DRV2667_1792_MS_ENV             0x0e
  97 #define DRV2667_2048_MS_ENV             0x0f
  98
  99 /**
 100  * struct drv2667_data -
 101  * @input_dev - Pointer to the input device
 102  * @client - Pointer to the I2C client
 103  * @regmap - Register map of the device
 104  * @work - Work item used to off load the enable/disable of the vibration
 105  * @regulator - Pointer to the regulator for the IC
 106  * @magnitude - Magnitude of the vibration event
 107 **/
 108 struct drv2667_data {
 109         struct input_dev *input_dev;
 110         struct i2c_client *client;
 111         struct regmap *regmap;
 112         struct work_struct work;
 113         struct regulator *regulator;
 114         u32 page;
 115         u32 magnitude;
 116         u32 frequency;
 117 };
 118
 119 static const struct reg_default drv2667_reg_defs[] = {
 120         { DRV2667_STATUS, 0x02 },
 121         { DRV2667_CTRL_1, 0x28 },
 122         { DRV2667_CTRL_2, 0x40 },
 123         { DRV2667_WV_SEQ_0, 0x00 },
 124         { DRV2667_WV_SEQ_1, 0x00 },
 125         { DRV2667_WV_SEQ_2, 0x00 },
 126         { DRV2667_WV_SEQ_3, 0x00 },
 127         { DRV2667_WV_SEQ_4, 0x00 },
 128         { DRV2667_WV_SEQ_5, 0x00 },
 129         { DRV2667_WV_SEQ_6, 0x00 },
 130         { DRV2667_WV_SEQ_7, 0x00 },
 131         { DRV2667_FIFO, 0x00 },
 132         { DRV2667_PAGE, 0x00 },
 133 };
 134
 135 static int drv2667_set_waveform_freq(struct drv2667_data *haptics)
 136 {
 137         unsigned int read_buf;
 138         int freq;
 139         int error;
 140
 141         /* Per the data sheet:
 142          * Sinusoid Frequency (Hz) = 7.8125 x Frequency
 143          */
 144         freq = (haptics->frequency * 1000) / 78125;
 145         if (freq <= 0) {
 146                 dev_err(&haptics->client->dev,
 147                         "ERROR: Frequency calculated to %i\n", freq);
 148                 return -EINVAL;
 149         }
 150
 151         error = regmap_read(haptics->regmap, DRV2667_PAGE, &read_buf);
 152         if (error) {
 153                 dev_err(&haptics->client->dev,
 154                         "Failed to read the page number: %d\n", error);
 155                 return -EIO;
 156         }
 157
 158         if (read_buf == DRV2667_PAGE_0 ||
 159                 haptics->page != read_buf) {
 160                 error = regmap_write(haptics->regmap,
 161                                 DRV2667_PAGE, haptics->page);
 162                 if (error) {
 163                         dev_err(&haptics->client->dev,
 164                                 "Failed to set the page: %d\n", error);
 165                         return -EIO;
 166                 }
 167         }
 168
 169         error = regmap_write(haptics->regmap, DRV2667_RAM_FREQ, freq);
 170         if (error)
 171                 dev_err(&haptics->client->dev,
 172                                 "Failed to set the frequency: %d\n", error);
 173
 174         /* Reset back to original page */
 175         if (read_buf == DRV2667_PAGE_0 ||
 176                 haptics->page != read_buf) {
 177                 error = regmap_write(haptics->regmap, DRV2667_PAGE, read_buf);
 178                 if (error) {
 179                         dev_err(&haptics->client->dev,
 180                                         "Failed to set the page: %d\n", error);
 181                                 return -EIO;
 182                         }
 183         }
 184
 185         return error;
 186 }
 187
 188 static void drv2667_worker(struct work_struct *work)
 189 {
 190         struct drv2667_data *haptics = container_of(work, struct drv2667_data, work);
 191         int error;
 192
 193         if (haptics->magnitude) {
 194                 error = regmap_write(haptics->regmap,
 195                                 DRV2667_PAGE, haptics->page);
 196                 if (error) {
 197                         dev_err(&haptics->client->dev,
 198                                 "Failed to set the page: %d\n", error);
 199                         return;
 200                 }
 201
 202                 error = regmap_write(haptics->regmap, DRV2667_RAM_AMP,
 203                                 haptics->magnitude);
 204                 if (error) {
 205                         dev_err(&haptics->client->dev,
 206                                 "Failed to set the amplitude: %d\n", error);
 207                         return;
 208                 }
 209
 210                 error = regmap_write(haptics->regmap,
 211                                 DRV2667_PAGE, DRV2667_PAGE_0);
 212                 if (error) {
 213                         dev_err(&haptics->client->dev,
 214                                 "Failed to set the page: %d\n", error);
 215                         return;
 216                 }
 217
 218                 error = regmap_write(haptics->regmap,
 219                                 DRV2667_CTRL_2, DRV2667_GO);
 220                 if (error) {
 221                         dev_err(&haptics->client->dev,
 222                                 "Failed to set the GO bit: %d\n", error);
 223                 }
 224         } else {
 225                 error = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2,
 226                                 DRV2667_GO, 0);
 227                 if (error) {
 228                         dev_err(&haptics->client->dev,
 229                                 "Failed to unset the GO bit: %d\n", error);
 230                 }
 231         }
 232 }
 233
 234 static int drv2667_haptics_play(struct input_dev *input, void *data,
 235                                 struct ff_effect *effect)
 236 {
 237         struct drv2667_data *haptics = input_get_drvdata(input);
 238
 239         if (effect->u.rumble.strong_magnitude > 0)
 240                 haptics->magnitude = effect->u.rumble.strong_magnitude;
 241         else if (effect->u.rumble.weak_magnitude > 0)
 242                 haptics->magnitude = effect->u.rumble.weak_magnitude;
 243         else
 244                 haptics->magnitude = 0;
 245
 246         schedule_work(&haptics->work);
 247
 248         return 0;
 249 }
 250
 251 static void drv2667_close(struct input_dev *input)
 252 {
 253         struct drv2667_data *haptics = input_get_drvdata(input);
 254         int error;
 255
 256         cancel_work_sync(&haptics->work);
 257
 258         error = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2,
 259                                    DRV2667_STANDBY, DRV2667_STANDBY);
 260         if (error)
 261                 dev_err(&haptics->client->dev,
 262                         "Failed to enter standby mode: %d\n", error);
 263 }
 264
 265 static const struct reg_sequence drv2667_init_regs[] = {
 266         { DRV2667_CTRL_2, 0 },
 267         { DRV2667_CTRL_1, DRV2667_25_VPP_GAIN },
 268         { DRV2667_WV_SEQ_0, 1 },
 269         { DRV2667_WV_SEQ_1, 0 }
 270 };
 271
 272 static const struct reg_sequence drv2667_page1_init[] = {
 273         { DRV2667_RAM_HDR_SZ, 0x05 },
 274         { DRV2667_RAM_START_HI, 0x80 },
 275         { DRV2667_RAM_START_LO, 0x06 },
 276         { DRV2667_RAM_STOP_HI, 0x00 },
 277         { DRV2667_RAM_STOP_LO, 0x09 },
 278         { DRV2667_RAM_REPEAT_CT, 0 },
 279         { DRV2667_RAM_DURATION, 0x05 },
 280         { DRV2667_RAM_ENVELOPE, DRV2667_NO_ENV },
 281         { DRV2667_RAM_AMP, 0x60 },
 282 };
 283
 284 static int drv2667_init(struct drv2667_data *haptics)
 285 {
 286         int error;
 287
 288         /* Set default haptic frequency to 195Hz on Page 1*/
 289         haptics->frequency = 195;
 290         haptics->page = DRV2667_PAGE_1;
 291
 292         error = regmap_register_patch(haptics->regmap,
 293                                       drv2667_init_regs,
 294                                       ARRAY_SIZE(drv2667_init_regs));
 295         if (error) {
 296                 dev_err(&haptics->client->dev,
 297                         "Failed to write init registers: %d\n",
 298                         error);
 299                 return error;
 300         }
 301
 302         error = regmap_write(haptics->regmap, DRV2667_PAGE, haptics->page);
 303         if (error) {
 304                 dev_err(&haptics->client->dev, "Failed to set page: %d\n",
 305                         error);
 306                 goto error_out;
 307         }
 308
 309         error = drv2667_set_waveform_freq(haptics);
 310         if (error)
 311                 goto error_page;
 312
 313         error = regmap_register_patch(haptics->regmap,
 314                                       drv2667_page1_init,
 315                                       ARRAY_SIZE(drv2667_page1_init));
 316         if (error) {
 317                 dev_err(&haptics->client->dev,
 318                         "Failed to write page registers: %d\n",
 319                         error);
 320                 return error;
 321         }
 322
 323         error = regmap_write(haptics->regmap, DRV2667_PAGE, DRV2667_PAGE_0);
 324         return error;
 325
 326 error_page:
 327         regmap_write(haptics->regmap, DRV2667_PAGE, DRV2667_PAGE_0);
 328 error_out:
 329         return error;
 330 }
 331
 332 static const struct regmap_config drv2667_regmap_config = {
 333         .reg_bits = 8,
 334         .val_bits = 8,
 335
 336         .max_register = DRV2667_MAX_REG,
 337         .reg_defaults = drv2667_reg_defs,
 338         .num_reg_defaults = ARRAY_SIZE(drv2667_reg_defs),
 339         .cache_type = REGCACHE_NONE,
 340 };
 341
 342 static int drv2667_probe(struct i2c_client *client,
 343                          const struct i2c_device_id *id)
 344 {
 345         struct drv2667_data *haptics;
 346         int error;
 347
 348         haptics = devm_kzalloc(&client->dev, sizeof(*haptics), GFP_KERNEL);
 349         if (!haptics)
 350                 return -ENOMEM;
 351
 352         haptics->regulator = devm_regulator_get(&client->dev, "vbat");
 353         if (IS_ERR(haptics->regulator)) {
 354                 error = PTR_ERR(haptics->regulator);
 355                 dev_err(&client->dev,
 356                         "unable to get regulator, error: %d\n", error);
 357                 return error;
 358         }
 359
 360         haptics->input_dev = devm_input_allocate_device(&client->dev);
 361         if (!haptics->input_dev) {
 362                 dev_err(&client->dev, "Failed to allocate input device\n");
 363                 return -ENOMEM;
 364         }
 365
 366         haptics->input_dev->name = "drv2667:haptics";
 367         haptics->input_dev->dev.parent = client->dev.parent;
 368         haptics->input_dev->close = drv2667_close;
 369         input_set_drvdata(haptics->input_dev, haptics);
 370         input_set_capability(haptics->input_dev, EV_FF, FF_RUMBLE);
 371
 372         error = input_ff_create_memless(haptics->input_dev, NULL,
 373                                         drv2667_haptics_play);
 374         if (error) {
 375                 dev_err(&client->dev, "input_ff_create() failed: %d\n",
 376                         error);
 377                 return error;
 378         }
 379
 380         INIT_WORK(&haptics->work, drv2667_worker);
 381
 382         haptics->client = client;
 383         i2c_set_clientdata(client, haptics);
 384
 385         haptics->regmap = devm_regmap_init_i2c(client, &drv2667_regmap_config);
 386         if (IS_ERR(haptics->regmap)) {
 387                 error = PTR_ERR(haptics->regmap);
 388                 dev_err(&client->dev, "Failed to allocate register map: %d\n",
 389                         error);
 390                 return error;
 391         }
 392
 393         error = drv2667_init(haptics);
 394         if (error) {
 395                 dev_err(&client->dev, "Device init failed: %d\n", error);
 396                 return error;
 397         }
 398
 399         error = input_register_device(haptics->input_dev);
 400         if (error) {
 401                 dev_err(&client->dev, "couldn't register input device: %d\n",
 402                         error);
 403                 return error;
 404         }
 405
 406         return 0;
 407 }
 408
 409 static int __maybe_unused drv2667_suspend(struct device *dev)
 410 {
 411         struct drv2667_data *haptics = dev_get_drvdata(dev);
 412         int ret = 0;
 413
 414         mutex_lock(&haptics->input_dev->mutex);
 415
 416         if (haptics->input_dev->users) {
 417                 ret = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2,
 418                                          DRV2667_STANDBY, DRV2667_STANDBY);
 419                 if (ret) {
 420                         dev_err(dev, "Failed to set standby mode\n");
 421                         regulator_disable(haptics->regulator);
 422                         goto out;
 423                 }
 424
 425                 ret = regulator_disable(haptics->regulator);
 426                 if (ret) {
 427                         dev_err(dev, "Failed to disable regulator\n");
 428                         regmap_update_bits(haptics->regmap,
 429                                            DRV2667_CTRL_2,
 430                                            DRV2667_STANDBY, 0);
 431                 }
 432         }
 433 out:
 434         mutex_unlock(&haptics->input_dev->mutex);
 435         return ret;
 436 }
 437
 438 static int __maybe_unused drv2667_resume(struct device *dev)
 439 {
 440         struct drv2667_data *haptics = dev_get_drvdata(dev);
 441         int ret = 0;
 442
 443         mutex_lock(&haptics->input_dev->mutex);
 444
 445         if (haptics->input_dev->users) {
 446                 ret = regulator_enable(haptics->regulator);
 447                 if (ret) {
 448                         dev_err(dev, "Failed to enable regulator\n");
 449                         goto out;
 450                 }
 451
 452                 ret = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2,
 453                                          DRV2667_STANDBY, 0);
 454                 if (ret) {
 455                         dev_err(dev, "Failed to unset standby mode\n");
 456                         regulator_disable(haptics->regulator);
 457                         goto out;
 458                 }
 459
 460         }
 461
 462 out:
 463         mutex_unlock(&haptics->input_dev->mutex);
 464         return ret;
 465 }
 466
 467 static SIMPLE_DEV_PM_OPS(drv2667_pm_ops, drv2667_suspend, drv2667_resume);
 468
 469 static const struct i2c_device_id drv2667_id[] = {
 470         { "drv2667", 0 },
 471         { }
 472 };
 473 MODULE_DEVICE_TABLE(i2c, drv2667_id);
 474
 475 #ifdef CONFIG_OF
 476 static const struct of_device_id drv2667_of_match[] = {
 477         { .compatible = "ti,drv2667", },
 478         { }
 479 };
 480 MODULE_DEVICE_TABLE(of, drv2667_of_match);
 481 #endif
 482
 483 static struct i2c_driver drv2667_driver = {
 484         .probe          = drv2667_probe,
 485         .driver         = {
 486                 .name   = "drv2667-haptics",
 487                 .of_match_table = of_match_ptr(drv2667_of_match),
 488                 .pm     = &drv2667_pm_ops,
 489         },
 490         .id_table = drv2667_id,
 491 };
 492 module_i2c_driver(drv2667_driver);
 493
 494 MODULE_DESCRIPTION("TI DRV2667 haptics driver");
 495 MODULE_LICENSE("GPL");
 496 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");