1 /* 2 * PWM vibrator driver 3 * 4 * Copyright (C) 2017 Collabora Ltd. 5 * 6 * Based on previous work from: 7 * Copyright (C) 2012 Dmitry Torokhov <dmitry.torokhov@gmail.com> 8 * 9 * Based on PWM beeper driver: 10 * Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de> 11 * 12 * This program is free software; you can redistribute it and/or modify it 13 * under the terms of the GNU General Public License as published by the 14 * Free Software Foundation; either version 2 of the License, or (at your 15 * option) any later version. 16 */ 17 18 #include <linux/input.h> 19 #include <linux/kernel.h> 20 #include <linux/module.h> 21 #include <linux/of_device.h> 22 #include <linux/platform_device.h> 23 #include <linux/property.h> 24 #include <linux/pwm.h> 25 #include <linux/regulator/consumer.h> 26 #include <linux/slab.h> 27 28 struct pwm_vibrator { 29 struct input_dev *input; 30 struct pwm_device *pwm; 31 struct pwm_device *pwm_dir; 32 struct regulator *vcc; 33 34 struct work_struct play_work; 35 u16 level; 36 u32 direction_duty_cycle; 37 bool vcc_on; 38 }; 39 40 static int pwm_vibrator_start(struct pwm_vibrator *vibrator) 41 { 42 struct device *pdev = vibrator->input->dev.parent; 43 struct pwm_state state; 44 int err; 45 46 if (!vibrator->vcc_on) { 47 err = regulator_enable(vibrator->vcc); 48 if (err) { 49 dev_err(pdev, "failed to enable regulator: %d", err); 50 return err; 51 } 52 vibrator->vcc_on = true; 53 } 54 55 pwm_get_state(vibrator->pwm, &state); 56 pwm_set_relative_duty_cycle(&state, vibrator->level, 0xffff); 57 state.enabled = true; 58 59 err = pwm_apply_state(vibrator->pwm, &state); 60 if (err) { 61 dev_err(pdev, "failed to apply pwm state: %d", err); 62 return err; 63 } 64 65 if (vibrator->pwm_dir) { 66 pwm_get_state(vibrator->pwm_dir, &state); 67 state.duty_cycle = vibrator->direction_duty_cycle; 68 state.enabled = true; 69 70 err = pwm_apply_state(vibrator->pwm_dir, &state); 71 if (err) { 72 dev_err(pdev, "failed to apply dir-pwm state: %d", err); 73 pwm_disable(vibrator->pwm); 74 return err; 75 } 76 } 77 78 return 0; 79 } 80 81 static void pwm_vibrator_stop(struct pwm_vibrator *vibrator) 82 { 83 if (vibrator->pwm_dir) 84 pwm_disable(vibrator->pwm_dir); 85 pwm_disable(vibrator->pwm); 86 87 if (vibrator->vcc_on) { 88 regulator_disable(vibrator->vcc); 89 vibrator->vcc_on = false; 90 } 91 } 92 93 static void pwm_vibrator_play_work(struct work_struct *work) 94 { 95 struct pwm_vibrator *vibrator = container_of(work, 96 struct pwm_vibrator, play_work); 97 98 if (vibrator->level) 99 pwm_vibrator_start(vibrator); 100 else 101 pwm_vibrator_stop(vibrator); 102 } 103 104 static int pwm_vibrator_play_effect(struct input_dev *dev, void *data, 105 struct ff_effect *effect) 106 { 107 struct pwm_vibrator *vibrator = input_get_drvdata(dev); 108 109 vibrator->level = effect->u.rumble.strong_magnitude; 110 if (!vibrator->level) 111 vibrator->level = effect->u.rumble.weak_magnitude; 112 113 schedule_work(&vibrator->play_work); 114 115 return 0; 116 } 117 118 static void pwm_vibrator_close(struct input_dev *input) 119 { 120 struct pwm_vibrator *vibrator = input_get_drvdata(input); 121 122 cancel_work_sync(&vibrator->play_work); 123 pwm_vibrator_stop(vibrator); 124 } 125 126 static int pwm_vibrator_probe(struct platform_device *pdev) 127 { 128 struct pwm_vibrator *vibrator; 129 struct pwm_state state; 130 int err; 131 132 vibrator = devm_kzalloc(&pdev->dev, sizeof(*vibrator), GFP_KERNEL); 133 if (!vibrator) 134 return -ENOMEM; 135 136 vibrator->input = devm_input_allocate_device(&pdev->dev); 137 if (!vibrator->input) 138 return -ENOMEM; 139 140 vibrator->vcc = devm_regulator_get(&pdev->dev, "vcc"); 141 err = PTR_ERR_OR_ZERO(vibrator->vcc); 142 if (err) { 143 if (err != -EPROBE_DEFER) 144 dev_err(&pdev->dev, "Failed to request regulator: %d", 145 err); 146 return err; 147 } 148 149 vibrator->pwm = devm_pwm_get(&pdev->dev, "enable"); 150 err = PTR_ERR_OR_ZERO(vibrator->pwm); 151 if (err) { 152 if (err != -EPROBE_DEFER) 153 dev_err(&pdev->dev, "Failed to request main pwm: %d", 154 err); 155 return err; 156 } 157 158 INIT_WORK(&vibrator->play_work, pwm_vibrator_play_work); 159 160 /* Sync up PWM state and ensure it is off. */ 161 pwm_init_state(vibrator->pwm, &state); 162 state.enabled = false; 163 err = pwm_apply_state(vibrator->pwm, &state); 164 if (err) { 165 dev_err(&pdev->dev, "failed to apply initial PWM state: %d", 166 err); 167 return err; 168 } 169 170 vibrator->pwm_dir = devm_pwm_get(&pdev->dev, "direction"); 171 err = PTR_ERR_OR_ZERO(vibrator->pwm_dir); 172 switch (err) { 173 case 0: 174 /* Sync up PWM state and ensure it is off. */ 175 pwm_init_state(vibrator->pwm_dir, &state); 176 state.enabled = false; 177 err = pwm_apply_state(vibrator->pwm_dir, &state); 178 if (err) { 179 dev_err(&pdev->dev, "failed to apply initial PWM state: %d", 180 err); 181 return err; 182 } 183 184 vibrator->direction_duty_cycle = 185 pwm_get_period(vibrator->pwm_dir) / 2; 186 device_property_read_u32(&pdev->dev, "direction-duty-cycle-ns", 187 &vibrator->direction_duty_cycle); 188 break; 189 190 case -ENODATA: 191 /* Direction PWM is optional */ 192 vibrator->pwm_dir = NULL; 193 break; 194 195 default: 196 dev_err(&pdev->dev, "Failed to request direction pwm: %d", err); 197 /* Fall through */ 198 199 case -EPROBE_DEFER: 200 return err; 201 } 202 203 vibrator->input->name = "pwm-vibrator"; 204 vibrator->input->id.bustype = BUS_HOST; 205 vibrator->input->dev.parent = &pdev->dev; 206 vibrator->input->close = pwm_vibrator_close; 207 208 input_set_drvdata(vibrator->input, vibrator); 209 input_set_capability(vibrator->input, EV_FF, FF_RUMBLE); 210 211 err = input_ff_create_memless(vibrator->input, NULL, 212 pwm_vibrator_play_effect); 213 if (err) { 214 dev_err(&pdev->dev, "Couldn't create FF dev: %d", err); 215 return err; 216 } 217 218 err = input_register_device(vibrator->input); 219 if (err) { 220 dev_err(&pdev->dev, "Couldn't register input dev: %d", err); 221 return err; 222 } 223 224 platform_set_drvdata(pdev, vibrator); 225 226 return 0; 227 } 228 229 static int __maybe_unused pwm_vibrator_suspend(struct device *dev) 230 { 231 struct pwm_vibrator *vibrator = dev_get_drvdata(dev); 232 233 cancel_work_sync(&vibrator->play_work); 234 if (vibrator->level) 235 pwm_vibrator_stop(vibrator); 236 237 return 0; 238 } 239 240 static int __maybe_unused pwm_vibrator_resume(struct device *dev) 241 { 242 struct pwm_vibrator *vibrator = dev_get_drvdata(dev); 243 244 if (vibrator->level) 245 pwm_vibrator_start(vibrator); 246 247 return 0; 248 } 249 250 static SIMPLE_DEV_PM_OPS(pwm_vibrator_pm_ops, 251 pwm_vibrator_suspend, pwm_vibrator_resume); 252 253 #ifdef CONFIG_OF 254 static const struct of_device_id pwm_vibra_dt_match_table[] = { 255 { .compatible = "pwm-vibrator" }, 256 {}, 257 }; 258 MODULE_DEVICE_TABLE(of, pwm_vibra_dt_match_table); 259 #endif 260 261 static struct platform_driver pwm_vibrator_driver = { 262 .probe = pwm_vibrator_probe, 263 .driver = { 264 .name = "pwm-vibrator", 265 .pm = &pwm_vibrator_pm_ops, 266 .of_match_table = of_match_ptr(pwm_vibra_dt_match_table), 267 }, 268 }; 269 module_platform_driver(pwm_vibrator_driver); 270 271 MODULE_AUTHOR("Sebastian Reichel <sre@kernel.org>"); 272 MODULE_DESCRIPTION("PWM vibrator driver"); 273 MODULE_LICENSE("GPL"); 274 MODULE_ALIAS("platform:pwm-vibrator"); 275