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 <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/gpio/consumer.h>
  15 #include <linux/input.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/of.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_might_sleep(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_might_sleep(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         if (IS_ERR(vibrator->vcc))
 144                 return dev_err_probe(&pdev->dev, PTR_ERR(vibrator->vcc),
 145                                      "Failed to request regulator\n");
 146
 147         vibrator->enable_gpio = devm_gpiod_get_optional(&pdev->dev, "enable",
 148                                                         GPIOD_OUT_LOW);
 149         if (IS_ERR(vibrator->enable_gpio))
 150                 return dev_err_probe(&pdev->dev, PTR_ERR(vibrator->enable_gpio),
 151                                      "Failed to request enable gpio\n");
 152
 153         vibrator->pwm = devm_pwm_get(&pdev->dev, "enable");
 154         if (IS_ERR(vibrator->pwm))
 155                 return dev_err_probe(&pdev->dev, PTR_ERR(vibrator->pwm),
 156                                      "Failed to request main pwm\n");
 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_might_sleep(vibrator->pwm, &state);
 164         if (err) {
 165                 dev_err(&pdev->dev, "failed to apply initial PWM state: %d\n",
 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_might_sleep(vibrator->pwm_dir, &state);
 178                 if (err) {
 179                         dev_err(&pdev->dev, "failed to apply initial PWM state: %d\n",
 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\n", err);
 197                 fallthrough;
 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\n", 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\n", err);
 221                 return err;
 222         }
 223
 224         platform_set_drvdata(pdev, vibrator);
 225
 226         return 0;
 227 }
 228
 229 static int 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 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 DEFINE_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     = pm_sleep_ptr(&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");