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 * @magnitude - Magnitude of the vibration event 99 **/ 100 struct drv2667_data { 101 struct input_dev *input_dev; 102 struct i2c_client *client; 103 struct regmap *regmap; 104 struct work_struct work; 105 struct regulator *regulator; 106 u32 page; 107 u32 magnitude; 108 u32 frequency; 109 }; 110 111 static const struct reg_default drv2667_reg_defs[] = { 112 { DRV2667_STATUS, 0x02 }, 113 { DRV2667_CTRL_1, 0x28 }, 114 { DRV2667_CTRL_2, 0x40 }, 115 { DRV2667_WV_SEQ_0, 0x00 }, 116 { DRV2667_WV_SEQ_1, 0x00 }, 117 { DRV2667_WV_SEQ_2, 0x00 }, 118 { DRV2667_WV_SEQ_3, 0x00 }, 119 { DRV2667_WV_SEQ_4, 0x00 }, 120 { DRV2667_WV_SEQ_5, 0x00 }, 121 { DRV2667_WV_SEQ_6, 0x00 }, 122 { DRV2667_WV_SEQ_7, 0x00 }, 123 { DRV2667_FIFO, 0x00 }, 124 { DRV2667_PAGE, 0x00 }, 125 }; 126 127 static int drv2667_set_waveform_freq(struct drv2667_data *haptics) 128 { 129 unsigned int read_buf; 130 int freq; 131 int error; 132 133 /* Per the data sheet: 134 * Sinusoid Frequency (Hz) = 7.8125 x Frequency 135 */ 136 freq = (haptics->frequency * 1000) / 78125; 137 if (freq <= 0) { 138 dev_err(&haptics->client->dev, 139 "ERROR: Frequency calculated to %i\n", freq); 140 return -EINVAL; 141 } 142 143 error = regmap_read(haptics->regmap, DRV2667_PAGE, &read_buf); 144 if (error) { 145 dev_err(&haptics->client->dev, 146 "Failed to read the page number: %d\n", error); 147 return -EIO; 148 } 149 150 if (read_buf == DRV2667_PAGE_0 || 151 haptics->page != read_buf) { 152 error = regmap_write(haptics->regmap, 153 DRV2667_PAGE, haptics->page); 154 if (error) { 155 dev_err(&haptics->client->dev, 156 "Failed to set the page: %d\n", error); 157 return -EIO; 158 } 159 } 160 161 error = regmap_write(haptics->regmap, DRV2667_RAM_FREQ, freq); 162 if (error) 163 dev_err(&haptics->client->dev, 164 "Failed to set the frequency: %d\n", error); 165 166 /* Reset back to original page */ 167 if (read_buf == DRV2667_PAGE_0 || 168 haptics->page != read_buf) { 169 error = regmap_write(haptics->regmap, DRV2667_PAGE, read_buf); 170 if (error) { 171 dev_err(&haptics->client->dev, 172 "Failed to set the page: %d\n", error); 173 return -EIO; 174 } 175 } 176 177 return error; 178 } 179 180 static void drv2667_worker(struct work_struct *work) 181 { 182 struct drv2667_data *haptics = container_of(work, struct drv2667_data, work); 183 int error; 184 185 if (haptics->magnitude) { 186 error = regmap_write(haptics->regmap, 187 DRV2667_PAGE, haptics->page); 188 if (error) { 189 dev_err(&haptics->client->dev, 190 "Failed to set the page: %d\n", error); 191 return; 192 } 193 194 error = regmap_write(haptics->regmap, DRV2667_RAM_AMP, 195 haptics->magnitude); 196 if (error) { 197 dev_err(&haptics->client->dev, 198 "Failed to set the amplitude: %d\n", error); 199 return; 200 } 201 202 error = regmap_write(haptics->regmap, 203 DRV2667_PAGE, DRV2667_PAGE_0); 204 if (error) { 205 dev_err(&haptics->client->dev, 206 "Failed to set the page: %d\n", error); 207 return; 208 } 209 210 error = regmap_write(haptics->regmap, 211 DRV2667_CTRL_2, DRV2667_GO); 212 if (error) { 213 dev_err(&haptics->client->dev, 214 "Failed to set the GO bit: %d\n", error); 215 } 216 } else { 217 error = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2, 218 DRV2667_GO, 0); 219 if (error) { 220 dev_err(&haptics->client->dev, 221 "Failed to unset the GO bit: %d\n", error); 222 } 223 } 224 } 225 226 static int drv2667_haptics_play(struct input_dev *input, void *data, 227 struct ff_effect *effect) 228 { 229 struct drv2667_data *haptics = input_get_drvdata(input); 230 231 if (effect->u.rumble.strong_magnitude > 0) 232 haptics->magnitude = effect->u.rumble.strong_magnitude; 233 else if (effect->u.rumble.weak_magnitude > 0) 234 haptics->magnitude = effect->u.rumble.weak_magnitude; 235 else 236 haptics->magnitude = 0; 237 238 schedule_work(&haptics->work); 239 240 return 0; 241 } 242 243 static void drv2667_close(struct input_dev *input) 244 { 245 struct drv2667_data *haptics = input_get_drvdata(input); 246 int error; 247 248 cancel_work_sync(&haptics->work); 249 250 error = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2, 251 DRV2667_STANDBY, DRV2667_STANDBY); 252 if (error) 253 dev_err(&haptics->client->dev, 254 "Failed to enter standby mode: %d\n", error); 255 } 256 257 static const struct reg_sequence drv2667_init_regs[] = { 258 { DRV2667_CTRL_2, 0 }, 259 { DRV2667_CTRL_1, DRV2667_25_VPP_GAIN }, 260 { DRV2667_WV_SEQ_0, 1 }, 261 { DRV2667_WV_SEQ_1, 0 } 262 }; 263 264 static const struct reg_sequence drv2667_page1_init[] = { 265 { DRV2667_RAM_HDR_SZ, 0x05 }, 266 { DRV2667_RAM_START_HI, 0x80 }, 267 { DRV2667_RAM_START_LO, 0x06 }, 268 { DRV2667_RAM_STOP_HI, 0x00 }, 269 { DRV2667_RAM_STOP_LO, 0x09 }, 270 { DRV2667_RAM_REPEAT_CT, 0 }, 271 { DRV2667_RAM_DURATION, 0x05 }, 272 { DRV2667_RAM_ENVELOPE, DRV2667_NO_ENV }, 273 { DRV2667_RAM_AMP, 0x60 }, 274 }; 275 276 static int drv2667_init(struct drv2667_data *haptics) 277 { 278 int error; 279 280 /* Set default haptic frequency to 195Hz on Page 1*/ 281 haptics->frequency = 195; 282 haptics->page = DRV2667_PAGE_1; 283 284 error = regmap_register_patch(haptics->regmap, 285 drv2667_init_regs, 286 ARRAY_SIZE(drv2667_init_regs)); 287 if (error) { 288 dev_err(&haptics->client->dev, 289 "Failed to write init registers: %d\n", 290 error); 291 return error; 292 } 293 294 error = regmap_write(haptics->regmap, DRV2667_PAGE, haptics->page); 295 if (error) { 296 dev_err(&haptics->client->dev, "Failed to set page: %d\n", 297 error); 298 goto error_out; 299 } 300 301 error = drv2667_set_waveform_freq(haptics); 302 if (error) 303 goto error_page; 304 305 error = regmap_register_patch(haptics->regmap, 306 drv2667_page1_init, 307 ARRAY_SIZE(drv2667_page1_init)); 308 if (error) { 309 dev_err(&haptics->client->dev, 310 "Failed to write page registers: %d\n", 311 error); 312 return error; 313 } 314 315 error = regmap_write(haptics->regmap, DRV2667_PAGE, DRV2667_PAGE_0); 316 return error; 317 318 error_page: 319 regmap_write(haptics->regmap, DRV2667_PAGE, DRV2667_PAGE_0); 320 error_out: 321 return error; 322 } 323 324 static const struct regmap_config drv2667_regmap_config = { 325 .reg_bits = 8, 326 .val_bits = 8, 327 328 .max_register = DRV2667_MAX_REG, 329 .reg_defaults = drv2667_reg_defs, 330 .num_reg_defaults = ARRAY_SIZE(drv2667_reg_defs), 331 .cache_type = REGCACHE_NONE, 332 }; 333 334 static int drv2667_probe(struct i2c_client *client, 335 const struct i2c_device_id *id) 336 { 337 struct drv2667_data *haptics; 338 int error; 339 340 haptics = devm_kzalloc(&client->dev, sizeof(*haptics), GFP_KERNEL); 341 if (!haptics) 342 return -ENOMEM; 343 344 haptics->regulator = devm_regulator_get(&client->dev, "vbat"); 345 if (IS_ERR(haptics->regulator)) { 346 error = PTR_ERR(haptics->regulator); 347 dev_err(&client->dev, 348 "unable to get regulator, error: %d\n", error); 349 return error; 350 } 351 352 haptics->input_dev = devm_input_allocate_device(&client->dev); 353 if (!haptics->input_dev) { 354 dev_err(&client->dev, "Failed to allocate input device\n"); 355 return -ENOMEM; 356 } 357 358 haptics->input_dev->name = "drv2667:haptics"; 359 haptics->input_dev->dev.parent = client->dev.parent; 360 haptics->input_dev->close = drv2667_close; 361 input_set_drvdata(haptics->input_dev, haptics); 362 input_set_capability(haptics->input_dev, EV_FF, FF_RUMBLE); 363 364 error = input_ff_create_memless(haptics->input_dev, NULL, 365 drv2667_haptics_play); 366 if (error) { 367 dev_err(&client->dev, "input_ff_create() failed: %d\n", 368 error); 369 return error; 370 } 371 372 INIT_WORK(&haptics->work, drv2667_worker); 373 374 haptics->client = client; 375 i2c_set_clientdata(client, haptics); 376 377 haptics->regmap = devm_regmap_init_i2c(client, &drv2667_regmap_config); 378 if (IS_ERR(haptics->regmap)) { 379 error = PTR_ERR(haptics->regmap); 380 dev_err(&client->dev, "Failed to allocate register map: %d\n", 381 error); 382 return error; 383 } 384 385 error = drv2667_init(haptics); 386 if (error) { 387 dev_err(&client->dev, "Device init failed: %d\n", error); 388 return error; 389 } 390 391 error = input_register_device(haptics->input_dev); 392 if (error) { 393 dev_err(&client->dev, "couldn't register input device: %d\n", 394 error); 395 return error; 396 } 397 398 return 0; 399 } 400 401 static int __maybe_unused drv2667_suspend(struct device *dev) 402 { 403 struct drv2667_data *haptics = dev_get_drvdata(dev); 404 int ret = 0; 405 406 mutex_lock(&haptics->input_dev->mutex); 407 408 if (haptics->input_dev->users) { 409 ret = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2, 410 DRV2667_STANDBY, DRV2667_STANDBY); 411 if (ret) { 412 dev_err(dev, "Failed to set standby mode\n"); 413 regulator_disable(haptics->regulator); 414 goto out; 415 } 416 417 ret = regulator_disable(haptics->regulator); 418 if (ret) { 419 dev_err(dev, "Failed to disable regulator\n"); 420 regmap_update_bits(haptics->regmap, 421 DRV2667_CTRL_2, 422 DRV2667_STANDBY, 0); 423 } 424 } 425 out: 426 mutex_unlock(&haptics->input_dev->mutex); 427 return ret; 428 } 429 430 static int __maybe_unused drv2667_resume(struct device *dev) 431 { 432 struct drv2667_data *haptics = dev_get_drvdata(dev); 433 int ret = 0; 434 435 mutex_lock(&haptics->input_dev->mutex); 436 437 if (haptics->input_dev->users) { 438 ret = regulator_enable(haptics->regulator); 439 if (ret) { 440 dev_err(dev, "Failed to enable regulator\n"); 441 goto out; 442 } 443 444 ret = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2, 445 DRV2667_STANDBY, 0); 446 if (ret) { 447 dev_err(dev, "Failed to unset standby mode\n"); 448 regulator_disable(haptics->regulator); 449 goto out; 450 } 451 452 } 453 454 out: 455 mutex_unlock(&haptics->input_dev->mutex); 456 return ret; 457 } 458 459 static SIMPLE_DEV_PM_OPS(drv2667_pm_ops, drv2667_suspend, drv2667_resume); 460 461 static const struct i2c_device_id drv2667_id[] = { 462 { "drv2667", 0 }, 463 { } 464 }; 465 MODULE_DEVICE_TABLE(i2c, drv2667_id); 466 467 #ifdef CONFIG_OF 468 static const struct of_device_id drv2667_of_match[] = { 469 { .compatible = "ti,drv2667", }, 470 { } 471 }; 472 MODULE_DEVICE_TABLE(of, drv2667_of_match); 473 #endif 474 475 static struct i2c_driver drv2667_driver = { 476 .probe = drv2667_probe, 477 .driver = { 478 .name = "drv2667-haptics", 479 .of_match_table = of_match_ptr(drv2667_of_match), 480 .pm = &drv2667_pm_ops, 481 }, 482 .id_table = drv2667_id, 483 }; 484 module_i2c_driver(drv2667_driver); 485 486 MODULE_DESCRIPTION("TI DRV2667 haptics driver"); 487 MODULE_LICENSE("GPL"); 488 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>"); 489