drivers/input/misc/pwm-vibra.c

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