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