1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * twl6040-vibra.c - TWL6040 Vibrator driver 4 * 5 * Author: Jorge Eduardo Candelaria <jorge.candelaria@ti.com> 6 * Author: Misael Lopez Cruz <misael.lopez@ti.com> 7 * 8 * Copyright: (C) 2011 Texas Instruments, Inc. 9 * 10 * Based on twl4030-vibra.c by Henrik Saari <henrik.saari@nokia.com> 11 * Felipe Balbi <felipe.balbi@nokia.com> 12 * Jari Vanhala <ext-javi.vanhala@nokia.com> 13 */ 14 #include <linux/module.h> 15 #include <linux/platform_device.h> 16 #include <linux/of.h> 17 #include <linux/workqueue.h> 18 #include <linux/input.h> 19 #include <linux/mfd/twl6040.h> 20 #include <linux/slab.h> 21 #include <linux/delay.h> 22 #include <linux/regulator/consumer.h> 23 24 #define EFFECT_DIR_180_DEG 0x8000 25 26 /* Recommended modulation index 85% */ 27 #define TWL6040_VIBRA_MOD 85 28 29 #define TWL6040_NUM_SUPPLIES 2 30 31 struct vibra_info { 32 struct device *dev; 33 struct input_dev *input_dev; 34 struct work_struct play_work; 35 36 int irq; 37 38 bool enabled; 39 int weak_speed; 40 int strong_speed; 41 int direction; 42 43 unsigned int vibldrv_res; 44 unsigned int vibrdrv_res; 45 unsigned int viblmotor_res; 46 unsigned int vibrmotor_res; 47 48 struct regulator_bulk_data supplies[TWL6040_NUM_SUPPLIES]; 49 50 struct twl6040 *twl6040; 51 }; 52 twl6040_vib_irq_handler(int irq,void * data)53 static irqreturn_t twl6040_vib_irq_handler(int irq, void *data) 54 { 55 struct vibra_info *info = data; 56 struct twl6040 *twl6040 = info->twl6040; 57 u8 status; 58 59 status = twl6040_reg_read(twl6040, TWL6040_REG_STATUS); 60 if (status & TWL6040_VIBLOCDET) { 61 dev_warn(info->dev, "Left Vibrator overcurrent detected\n"); 62 twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLL, 63 TWL6040_VIBENA); 64 } 65 if (status & TWL6040_VIBROCDET) { 66 dev_warn(info->dev, "Right Vibrator overcurrent detected\n"); 67 twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLR, 68 TWL6040_VIBENA); 69 } 70 71 return IRQ_HANDLED; 72 } 73 twl6040_vibra_enable(struct vibra_info * info)74 static void twl6040_vibra_enable(struct vibra_info *info) 75 { 76 struct twl6040 *twl6040 = info->twl6040; 77 int ret; 78 79 ret = regulator_bulk_enable(ARRAY_SIZE(info->supplies), info->supplies); 80 if (ret) { 81 dev_err(info->dev, "failed to enable regulators %d\n", ret); 82 return; 83 } 84 85 twl6040_power(info->twl6040, 1); 86 if (twl6040_get_revid(twl6040) <= TWL6040_REV_ES1_1) { 87 /* 88 * ERRATA: Disable overcurrent protection for at least 89 * 3ms when enabling vibrator drivers to avoid false 90 * overcurrent detection 91 */ 92 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLL, 93 TWL6040_VIBENA | TWL6040_VIBCTRL); 94 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLR, 95 TWL6040_VIBENA | TWL6040_VIBCTRL); 96 usleep_range(3000, 3500); 97 } 98 99 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLL, 100 TWL6040_VIBENA); 101 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLR, 102 TWL6040_VIBENA); 103 104 info->enabled = true; 105 } 106 twl6040_vibra_disable(struct vibra_info * info)107 static void twl6040_vibra_disable(struct vibra_info *info) 108 { 109 struct twl6040 *twl6040 = info->twl6040; 110 111 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLL, 0x00); 112 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLR, 0x00); 113 twl6040_power(info->twl6040, 0); 114 115 regulator_bulk_disable(ARRAY_SIZE(info->supplies), info->supplies); 116 117 info->enabled = false; 118 } 119 twl6040_vibra_code(int vddvib,int vibdrv_res,int motor_res,int speed,int direction)120 static u8 twl6040_vibra_code(int vddvib, int vibdrv_res, int motor_res, 121 int speed, int direction) 122 { 123 int vpk, max_code; 124 u8 vibdat; 125 126 /* output swing */ 127 vpk = (vddvib * motor_res * TWL6040_VIBRA_MOD) / 128 (100 * (vibdrv_res + motor_res)); 129 130 /* 50mV per VIBDAT code step */ 131 max_code = vpk / 50; 132 if (max_code > TWL6040_VIBDAT_MAX) 133 max_code = TWL6040_VIBDAT_MAX; 134 135 /* scale speed to max allowed code */ 136 vibdat = (u8)((speed * max_code) / USHRT_MAX); 137 138 /* 2's complement for direction > 180 degrees */ 139 vibdat *= direction; 140 141 return vibdat; 142 } 143 twl6040_vibra_set_effect(struct vibra_info * info)144 static void twl6040_vibra_set_effect(struct vibra_info *info) 145 { 146 struct twl6040 *twl6040 = info->twl6040; 147 u8 vibdatl, vibdatr; 148 int volt; 149 150 /* weak motor */ 151 volt = regulator_get_voltage(info->supplies[0].consumer) / 1000; 152 vibdatl = twl6040_vibra_code(volt, info->vibldrv_res, 153 info->viblmotor_res, 154 info->weak_speed, info->direction); 155 156 /* strong motor */ 157 volt = regulator_get_voltage(info->supplies[1].consumer) / 1000; 158 vibdatr = twl6040_vibra_code(volt, info->vibrdrv_res, 159 info->vibrmotor_res, 160 info->strong_speed, info->direction); 161 162 twl6040_reg_write(twl6040, TWL6040_REG_VIBDATL, vibdatl); 163 twl6040_reg_write(twl6040, TWL6040_REG_VIBDATR, vibdatr); 164 } 165 vibra_play_work(struct work_struct * work)166 static void vibra_play_work(struct work_struct *work) 167 { 168 struct vibra_info *info = container_of(work, 169 struct vibra_info, play_work); 170 int ret; 171 172 /* Do not allow effect, while the routing is set to use audio */ 173 ret = twl6040_get_vibralr_status(info->twl6040); 174 if (ret & TWL6040_VIBSEL) { 175 dev_info(info->dev, "Vibra is configured for audio\n"); 176 return; 177 } 178 179 if (info->weak_speed || info->strong_speed) { 180 if (!info->enabled) 181 twl6040_vibra_enable(info); 182 183 twl6040_vibra_set_effect(info); 184 } else if (info->enabled) 185 twl6040_vibra_disable(info); 186 187 } 188 vibra_play(struct input_dev * input,void * data,struct ff_effect * effect)189 static int vibra_play(struct input_dev *input, void *data, 190 struct ff_effect *effect) 191 { 192 struct vibra_info *info = input_get_drvdata(input); 193 194 info->weak_speed = effect->u.rumble.weak_magnitude; 195 info->strong_speed = effect->u.rumble.strong_magnitude; 196 info->direction = effect->direction < EFFECT_DIR_180_DEG ? 1 : -1; 197 198 schedule_work(&info->play_work); 199 200 return 0; 201 } 202 twl6040_vibra_close(struct input_dev * input)203 static void twl6040_vibra_close(struct input_dev *input) 204 { 205 struct vibra_info *info = input_get_drvdata(input); 206 207 cancel_work_sync(&info->play_work); 208 209 if (info->enabled) 210 twl6040_vibra_disable(info); 211 } 212 twl6040_vibra_suspend(struct device * dev)213 static int twl6040_vibra_suspend(struct device *dev) 214 { 215 struct platform_device *pdev = to_platform_device(dev); 216 struct vibra_info *info = platform_get_drvdata(pdev); 217 218 cancel_work_sync(&info->play_work); 219 220 if (info->enabled) 221 twl6040_vibra_disable(info); 222 223 return 0; 224 } 225 226 static DEFINE_SIMPLE_DEV_PM_OPS(twl6040_vibra_pm_ops, 227 twl6040_vibra_suspend, NULL); 228 twl6040_vibra_probe(struct platform_device * pdev)229 static int twl6040_vibra_probe(struct platform_device *pdev) 230 { 231 struct device *twl6040_core_dev = pdev->dev.parent; 232 struct device_node *twl6040_core_node; 233 struct vibra_info *info; 234 int vddvibl_uV = 0; 235 int vddvibr_uV = 0; 236 int error; 237 238 twl6040_core_node = of_get_child_by_name(twl6040_core_dev->of_node, 239 "vibra"); 240 if (!twl6040_core_node) { 241 dev_err(&pdev->dev, "parent of node is missing?\n"); 242 return -EINVAL; 243 } 244 245 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL); 246 if (!info) { 247 of_node_put(twl6040_core_node); 248 dev_err(&pdev->dev, "couldn't allocate memory\n"); 249 return -ENOMEM; 250 } 251 252 info->dev = &pdev->dev; 253 254 info->twl6040 = dev_get_drvdata(pdev->dev.parent); 255 256 of_property_read_u32(twl6040_core_node, "ti,vibldrv-res", 257 &info->vibldrv_res); 258 of_property_read_u32(twl6040_core_node, "ti,vibrdrv-res", 259 &info->vibrdrv_res); 260 of_property_read_u32(twl6040_core_node, "ti,viblmotor-res", 261 &info->viblmotor_res); 262 of_property_read_u32(twl6040_core_node, "ti,vibrmotor-res", 263 &info->vibrmotor_res); 264 of_property_read_u32(twl6040_core_node, "ti,vddvibl-uV", &vddvibl_uV); 265 of_property_read_u32(twl6040_core_node, "ti,vddvibr-uV", &vddvibr_uV); 266 267 of_node_put(twl6040_core_node); 268 269 if ((!info->vibldrv_res && !info->viblmotor_res) || 270 (!info->vibrdrv_res && !info->vibrmotor_res)) { 271 dev_err(info->dev, "invalid vibra driver/motor resistance\n"); 272 return -EINVAL; 273 } 274 275 info->irq = platform_get_irq(pdev, 0); 276 if (info->irq < 0) 277 return -EINVAL; 278 279 error = devm_request_threaded_irq(&pdev->dev, info->irq, NULL, 280 twl6040_vib_irq_handler, 281 IRQF_ONESHOT, 282 "twl6040_irq_vib", info); 283 if (error) { 284 dev_err(info->dev, "VIB IRQ request failed: %d\n", error); 285 return error; 286 } 287 288 info->supplies[0].supply = "vddvibl"; 289 info->supplies[1].supply = "vddvibr"; 290 /* 291 * When booted with Device tree the regulators are attached to the 292 * parent device (twl6040 MFD core) 293 */ 294 error = devm_regulator_bulk_get(twl6040_core_dev, 295 ARRAY_SIZE(info->supplies), 296 info->supplies); 297 if (error) { 298 dev_err(info->dev, "couldn't get regulators %d\n", error); 299 return error; 300 } 301 302 if (vddvibl_uV) { 303 error = regulator_set_voltage(info->supplies[0].consumer, 304 vddvibl_uV, vddvibl_uV); 305 if (error) { 306 dev_err(info->dev, "failed to set VDDVIBL volt %d\n", 307 error); 308 return error; 309 } 310 } 311 312 if (vddvibr_uV) { 313 error = regulator_set_voltage(info->supplies[1].consumer, 314 vddvibr_uV, vddvibr_uV); 315 if (error) { 316 dev_err(info->dev, "failed to set VDDVIBR volt %d\n", 317 error); 318 return error; 319 } 320 } 321 322 INIT_WORK(&info->play_work, vibra_play_work); 323 324 info->input_dev = devm_input_allocate_device(&pdev->dev); 325 if (!info->input_dev) { 326 dev_err(info->dev, "couldn't allocate input device\n"); 327 return -ENOMEM; 328 } 329 330 input_set_drvdata(info->input_dev, info); 331 332 info->input_dev->name = "twl6040:vibrator"; 333 info->input_dev->id.version = 1; 334 info->input_dev->close = twl6040_vibra_close; 335 __set_bit(FF_RUMBLE, info->input_dev->ffbit); 336 337 error = input_ff_create_memless(info->input_dev, NULL, vibra_play); 338 if (error) { 339 dev_err(info->dev, "couldn't register vibrator to FF\n"); 340 return error; 341 } 342 343 error = input_register_device(info->input_dev); 344 if (error) { 345 dev_err(info->dev, "couldn't register input device\n"); 346 return error; 347 } 348 349 platform_set_drvdata(pdev, info); 350 351 return 0; 352 } 353 354 static struct platform_driver twl6040_vibra_driver = { 355 .probe = twl6040_vibra_probe, 356 .driver = { 357 .name = "twl6040-vibra", 358 .pm = pm_sleep_ptr(&twl6040_vibra_pm_ops), 359 }, 360 }; 361 module_platform_driver(twl6040_vibra_driver); 362 363 MODULE_ALIAS("platform:twl6040-vibra"); 364 MODULE_DESCRIPTION("TWL6040 Vibra driver"); 365 MODULE_LICENSE("GPL"); 366 MODULE_AUTHOR("Jorge Eduardo Candelaria <jorge.candelaria@ti.com>"); 367 MODULE_AUTHOR("Misael Lopez Cruz <misael.lopez@ti.com>"); 368