drivers/input/misc/pwm-vibra.c

   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 };
  38
  39 static int pwm_vibrator_start(struct pwm_vibrator *vibrator)
  40 {
  41         struct device *pdev = vibrator->input->dev.parent;
  42         struct pwm_state state;
  43         int err;
  44
  45         err = regulator_enable(vibrator->vcc);
  46         if (err) {
  47                 dev_err(pdev, "failed to enable regulator: %d", err);
  48                 return err;
  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         regulator_disable(vibrator->vcc);
  80
  81         if (vibrator->pwm_dir)
  82                 pwm_disable(vibrator->pwm_dir);
  83         pwm_disable(vibrator->pwm);
  84 }
  85
  86 static void pwm_vibrator_play_work(struct work_struct *work)
  87 {
  88         struct pwm_vibrator *vibrator = container_of(work,
  89                                         struct pwm_vibrator, play_work);
  90
  91         if (vibrator->level)
  92                 pwm_vibrator_start(vibrator);
  93         else
  94                 pwm_vibrator_stop(vibrator);
  95 }
  96
  97 static int pwm_vibrator_play_effect(struct input_dev *dev, void *data,
  98                                     struct ff_effect *effect)
  99 {
 100         struct pwm_vibrator *vibrator = input_get_drvdata(dev);
 101
 102         vibrator->level = effect->u.rumble.strong_magnitude;
 103         if (!vibrator->level)
 104                 vibrator->level = effect->u.rumble.weak_magnitude;
 105
 106         schedule_work(&vibrator->play_work);
 107
 108         return 0;
 109 }
 110
 111 static void pwm_vibrator_close(struct input_dev *input)
 112 {
 113         struct pwm_vibrator *vibrator = input_get_drvdata(input);
 114
 115         cancel_work_sync(&vibrator->play_work);
 116         pwm_vibrator_stop(vibrator);
 117 }
 118
 119 static int pwm_vibrator_probe(struct platform_device *pdev)
 120 {
 121         struct pwm_vibrator *vibrator;
 122         struct pwm_state state;
 123         int err;
 124
 125         vibrator = devm_kzalloc(&pdev->dev, sizeof(*vibrator), GFP_KERNEL);
 126         if (!vibrator)
 127                 return -ENOMEM;
 128
 129         vibrator->input = devm_input_allocate_device(&pdev->dev);
 130         if (!vibrator->input)
 131                 return -ENOMEM;
 132
 133         vibrator->vcc = devm_regulator_get(&pdev->dev, "vcc");
 134         err = PTR_ERR_OR_ZERO(vibrator->vcc);
 135         if (err) {
 136                 if (err != -EPROBE_DEFER)
 137                         dev_err(&pdev->dev, "Failed to request regulator: %d",
 138                                 err);
 139                 return err;
 140         }
 141
 142         vibrator->pwm = devm_pwm_get(&pdev->dev, "enable");
 143         err = PTR_ERR_OR_ZERO(vibrator->pwm);
 144         if (err) {
 145                 if (err != -EPROBE_DEFER)
 146                         dev_err(&pdev->dev, "Failed to request main pwm: %d",
 147                                 err);
 148                 return err;
 149         }
 150
 151         INIT_WORK(&vibrator->play_work, pwm_vibrator_play_work);
 152
 153         /* Sync up PWM state and ensure it is off. */
 154         pwm_init_state(vibrator->pwm, &state);
 155         state.enabled = false;
 156         err = pwm_apply_state(vibrator->pwm, &state);
 157         if (err) {
 158                 dev_err(&pdev->dev, "failed to apply initial PWM state: %d",
 159                         err);
 160                 return err;
 161         }
 162
 163         vibrator->pwm_dir = devm_pwm_get(&pdev->dev, "direction");
 164         err = PTR_ERR_OR_ZERO(vibrator->pwm_dir);
 165         switch (err) {
 166         case 0:
 167                 /* Sync up PWM state and ensure it is off. */
 168                 pwm_init_state(vibrator->pwm_dir, &state);
 169                 state.enabled = false;
 170                 err = pwm_apply_state(vibrator->pwm_dir, &state);
 171                 if (err) {
 172                         dev_err(&pdev->dev, "failed to apply initial PWM state: %d",
 173                                 err);
 174                         return err;
 175                 }
 176
 177                 vibrator->direction_duty_cycle =
 178                         pwm_get_period(vibrator->pwm_dir) / 2;
 179                 device_property_read_u32(&pdev->dev, "direction-duty-cycle-ns",
 180                                          &vibrator->direction_duty_cycle);
 181                 break;
 182
 183         case -ENODATA:
 184                 /* Direction PWM is optional */
 185                 vibrator->pwm_dir = NULL;
 186                 break;
 187
 188         default:
 189                 dev_err(&pdev->dev, "Failed to request direction pwm: %d", err);
 190                 /* Fall through */
 191
 192         case -EPROBE_DEFER:
 193                 return err;
 194         }
 195
 196         vibrator->input->name = "pwm-vibrator";
 197         vibrator->input->id.bustype = BUS_HOST;
 198         vibrator->input->dev.parent = &pdev->dev;
 199         vibrator->input->close = pwm_vibrator_close;
 200
 201         input_set_drvdata(vibrator->input, vibrator);
 202         input_set_capability(vibrator->input, EV_FF, FF_RUMBLE);
 203
 204         err = input_ff_create_memless(vibrator->input, NULL,
 205                                       pwm_vibrator_play_effect);
 206         if (err) {
 207                 dev_err(&pdev->dev, "Couldn't create FF dev: %d", err);
 208                 return err;
 209         }
 210
 211         err = input_register_device(vibrator->input);
 212         if (err) {
 213                 dev_err(&pdev->dev, "Couldn't register input dev: %d", err);
 214                 return err;
 215         }
 216
 217         platform_set_drvdata(pdev, vibrator);
 218
 219         return 0;
 220 }
 221
 222 static int __maybe_unused pwm_vibrator_suspend(struct device *dev)
 223 {
 224         struct pwm_vibrator *vibrator = dev_get_drvdata(dev);
 225
 226         cancel_work_sync(&vibrator->play_work);
 227         if (vibrator->level)
 228                 pwm_vibrator_stop(vibrator);
 229
 230         return 0;
 231 }
 232
 233 static int __maybe_unused pwm_vibrator_resume(struct device *dev)
 234 {
 235         struct pwm_vibrator *vibrator = dev_get_drvdata(dev);
 236
 237         if (vibrator->level)
 238                 pwm_vibrator_start(vibrator);
 239
 240         return 0;
 241 }
 242
 243 static SIMPLE_DEV_PM_OPS(pwm_vibrator_pm_ops,
 244                          pwm_vibrator_suspend, pwm_vibrator_resume);
 245
 246 #ifdef CONFIG_OF
 247 static const struct of_device_id pwm_vibra_dt_match_table[] = {
 248         { .compatible = "pwm-vibrator" },
 249         {},
 250 };
 251 MODULE_DEVICE_TABLE(of, pwm_vibra_dt_match_table);
 252 #endif
 253
 254 static struct platform_driver pwm_vibrator_driver = {
 255         .probe  = pwm_vibrator_probe,
 256         .driver = {
 257                 .name   = "pwm-vibrator",
 258                 .pm     = &pwm_vibrator_pm_ops,
 259                 .of_match_table = of_match_ptr(pwm_vibra_dt_match_table),
 260         },
 261 };
 262 module_platform_driver(pwm_vibrator_driver);
 263
 264 MODULE_AUTHOR("Sebastian Reichel <sre@kernel.org>");
 265 MODULE_DESCRIPTION("PWM vibrator driver");
 266 MODULE_LICENSE("GPL");
 267 MODULE_ALIAS("platform:pwm-vibrator");