drivers/input/misc/drv2667.c

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