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 { 338 struct drv2667_data *haptics; 339 int error; 340 341 haptics = devm_kzalloc(&client->dev, sizeof(*haptics), GFP_KERNEL); 342 if (!haptics) 343 return -ENOMEM; 344 345 haptics->regulator = devm_regulator_get(&client->dev, "vbat"); 346 if (IS_ERR(haptics->regulator)) { 347 error = PTR_ERR(haptics->regulator); 348 dev_err(&client->dev, 349 "unable to get regulator, error: %d\n", error); 350 return error; 351 } 352 353 haptics->input_dev = devm_input_allocate_device(&client->dev); 354 if (!haptics->input_dev) { 355 dev_err(&client->dev, "Failed to allocate input device\n"); 356 return -ENOMEM; 357 } 358 359 haptics->input_dev->name = "drv2667:haptics"; 360 haptics->input_dev->dev.parent = client->dev.parent; 361 haptics->input_dev->close = drv2667_close; 362 input_set_drvdata(haptics->input_dev, haptics); 363 input_set_capability(haptics->input_dev, EV_FF, FF_RUMBLE); 364 365 error = input_ff_create_memless(haptics->input_dev, NULL, 366 drv2667_haptics_play); 367 if (error) { 368 dev_err(&client->dev, "input_ff_create() failed: %d\n", 369 error); 370 return error; 371 } 372 373 INIT_WORK(&haptics->work, drv2667_worker); 374 375 haptics->client = client; 376 i2c_set_clientdata(client, haptics); 377 378 haptics->regmap = devm_regmap_init_i2c(client, &drv2667_regmap_config); 379 if (IS_ERR(haptics->regmap)) { 380 error = PTR_ERR(haptics->regmap); 381 dev_err(&client->dev, "Failed to allocate register map: %d\n", 382 error); 383 return error; 384 } 385 386 error = drv2667_init(haptics); 387 if (error) { 388 dev_err(&client->dev, "Device init failed: %d\n", error); 389 return error; 390 } 391 392 error = input_register_device(haptics->input_dev); 393 if (error) { 394 dev_err(&client->dev, "couldn't register input device: %d\n", 395 error); 396 return error; 397 } 398 399 return 0; 400 } 401 402 static int __maybe_unused drv2667_suspend(struct device *dev) 403 { 404 struct drv2667_data *haptics = dev_get_drvdata(dev); 405 int ret = 0; 406 407 mutex_lock(&haptics->input_dev->mutex); 408 409 if (input_device_enabled(haptics->input_dev)) { 410 ret = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2, 411 DRV2667_STANDBY, DRV2667_STANDBY); 412 if (ret) { 413 dev_err(dev, "Failed to set standby mode\n"); 414 regulator_disable(haptics->regulator); 415 goto out; 416 } 417 418 ret = regulator_disable(haptics->regulator); 419 if (ret) { 420 dev_err(dev, "Failed to disable regulator\n"); 421 regmap_update_bits(haptics->regmap, 422 DRV2667_CTRL_2, 423 DRV2667_STANDBY, 0); 424 } 425 } 426 out: 427 mutex_unlock(&haptics->input_dev->mutex); 428 return ret; 429 } 430 431 static int __maybe_unused drv2667_resume(struct device *dev) 432 { 433 struct drv2667_data *haptics = dev_get_drvdata(dev); 434 int ret = 0; 435 436 mutex_lock(&haptics->input_dev->mutex); 437 438 if (input_device_enabled(haptics->input_dev)) { 439 ret = regulator_enable(haptics->regulator); 440 if (ret) { 441 dev_err(dev, "Failed to enable regulator\n"); 442 goto out; 443 } 444 445 ret = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2, 446 DRV2667_STANDBY, 0); 447 if (ret) { 448 dev_err(dev, "Failed to unset standby mode\n"); 449 regulator_disable(haptics->regulator); 450 goto out; 451 } 452 453 } 454 455 out: 456 mutex_unlock(&haptics->input_dev->mutex); 457 return ret; 458 } 459 460 static SIMPLE_DEV_PM_OPS(drv2667_pm_ops, drv2667_suspend, drv2667_resume); 461 462 static const struct i2c_device_id drv2667_id[] = { 463 { "drv2667", 0 }, 464 { } 465 }; 466 MODULE_DEVICE_TABLE(i2c, drv2667_id); 467 468 #ifdef CONFIG_OF 469 static const struct of_device_id drv2667_of_match[] = { 470 { .compatible = "ti,drv2667", }, 471 { } 472 }; 473 MODULE_DEVICE_TABLE(of, drv2667_of_match); 474 #endif 475 476 static struct i2c_driver drv2667_driver = { 477 .probe_new = drv2667_probe, 478 .driver = { 479 .name = "drv2667-haptics", 480 .of_match_table = of_match_ptr(drv2667_of_match), 481 .pm = &drv2667_pm_ops, 482 }, 483 .id_table = drv2667_id, 484 }; 485 module_i2c_driver(drv2667_driver); 486 487 MODULE_DESCRIPTION("TI DRV2667 haptics driver"); 488 MODULE_LICENSE("GPL"); 489 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>"); 490