drv2667.c (12348B)
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**/ 102struct 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 113static 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 129static 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 182static 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 228static 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 245static 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 259static 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 266static 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 278static 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 320error_page: 321 regmap_write(haptics->regmap, DRV2667_PAGE, DRV2667_PAGE_0); 322error_out: 323 return error; 324} 325 326static 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 336static 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 403static 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 } 427out: 428 mutex_unlock(&haptics->input_dev->mutex); 429 return ret; 430} 431 432static 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 456out: 457 mutex_unlock(&haptics->input_dev->mutex); 458 return ret; 459} 460 461static SIMPLE_DEV_PM_OPS(drv2667_pm_ops, drv2667_suspend, drv2667_resume); 462 463static const struct i2c_device_id drv2667_id[] = { 464 { "drv2667", 0 }, 465 { } 466}; 467MODULE_DEVICE_TABLE(i2c, drv2667_id); 468 469#ifdef CONFIG_OF 470static const struct of_device_id drv2667_of_match[] = { 471 { .compatible = "ti,drv2667", }, 472 { } 473}; 474MODULE_DEVICE_TABLE(of, drv2667_of_match); 475#endif 476 477static 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}; 486module_i2c_driver(drv2667_driver); 487 488MODULE_DESCRIPTION("TI DRV2667 haptics driver"); 489MODULE_LICENSE("GPL"); 490MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");