1// SPDX-License-Identifier: GPL-2.0+
2/*
3 *  GPIO vibrator driver
4 *
5 *  Copyright (C) 2019 Luca Weiss <luca@z3ntu.xyz>
6 *
7 *  Based on PWM vibrator driver:
8 *  Copyright (C) 2017 Collabora Ltd.
9 *
10 *  Based on previous work from:
11 *  Copyright (C) 2012 Dmitry Torokhov <dmitry.torokhov@gmail.com>
12 *
13 *  Based on PWM beeper driver:
14 *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
15 */
16
17#include <linux/gpio/consumer.h>
18#include <linux/input.h>
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/of.h>
22#include <linux/platform_device.h>
23#include <linux/property.h>
24#include <linux/regulator/consumer.h>
25#include <linux/slab.h>
26
27struct gpio_vibrator {
28	struct input_dev *input;
29	struct gpio_desc *gpio;
30	struct regulator *vcc;
31
32	struct work_struct play_work;
33	bool running;
34	bool vcc_on;
35};
36
37static int gpio_vibrator_start(struct gpio_vibrator *vibrator)
38{
39	struct device *pdev = vibrator->input->dev.parent;
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\n", err);
46			return err;
47		}
48		vibrator->vcc_on = true;
49	}
50
51	gpiod_set_value_cansleep(vibrator->gpio, 1);
52
53	return 0;
54}
55
56static void gpio_vibrator_stop(struct gpio_vibrator *vibrator)
57{
58	gpiod_set_value_cansleep(vibrator->gpio, 0);
59
60	if (vibrator->vcc_on) {
61		regulator_disable(vibrator->vcc);
62		vibrator->vcc_on = false;
63	}
64}
65
66static void gpio_vibrator_play_work(struct work_struct *work)
67{
68	struct gpio_vibrator *vibrator =
69		container_of(work, struct gpio_vibrator, play_work);
70
71	if (vibrator->running)
72		gpio_vibrator_start(vibrator);
73	else
74		gpio_vibrator_stop(vibrator);
75}
76
77static int gpio_vibrator_play_effect(struct input_dev *dev, void *data,
78				     struct ff_effect *effect)
79{
80	struct gpio_vibrator *vibrator = input_get_drvdata(dev);
81	int level;
82
83	level = effect->u.rumble.strong_magnitude;
84	if (!level)
85		level = effect->u.rumble.weak_magnitude;
86
87	vibrator->running = level;
88	schedule_work(&vibrator->play_work);
89
90	return 0;
91}
92
93static void gpio_vibrator_close(struct input_dev *input)
94{
95	struct gpio_vibrator *vibrator = input_get_drvdata(input);
96
97	cancel_work_sync(&vibrator->play_work);
98	gpio_vibrator_stop(vibrator);
99	vibrator->running = false;
100}
101
102static int gpio_vibrator_probe(struct platform_device *pdev)
103{
104	struct gpio_vibrator *vibrator;
105	int err;
106
107	vibrator = devm_kzalloc(&pdev->dev, sizeof(*vibrator), GFP_KERNEL);
108	if (!vibrator)
109		return -ENOMEM;
110
111	vibrator->input = devm_input_allocate_device(&pdev->dev);
112	if (!vibrator->input)
113		return -ENOMEM;
114
115	vibrator->vcc = devm_regulator_get(&pdev->dev, "vcc");
116	if (IS_ERR(vibrator->vcc))
117		return dev_err_probe(&pdev->dev, PTR_ERR(vibrator->vcc),
118				     "Failed to request regulator\n");
119
120	vibrator->gpio = devm_gpiod_get(&pdev->dev, "enable", GPIOD_OUT_LOW);
121	if (IS_ERR(vibrator->gpio))
122		return dev_err_probe(&pdev->dev, PTR_ERR(vibrator->gpio),
123				     "Failed to request main gpio\n");
124
125	INIT_WORK(&vibrator->play_work, gpio_vibrator_play_work);
126
127	vibrator->input->name = "gpio-vibrator";
128	vibrator->input->id.bustype = BUS_HOST;
129	vibrator->input->close = gpio_vibrator_close;
130
131	input_set_drvdata(vibrator->input, vibrator);
132	input_set_capability(vibrator->input, EV_FF, FF_RUMBLE);
133
134	err = input_ff_create_memless(vibrator->input, NULL,
135				      gpio_vibrator_play_effect);
136	if (err) {
137		dev_err(&pdev->dev, "Couldn't create FF dev: %d\n", err);
138		return err;
139	}
140
141	err = input_register_device(vibrator->input);
142	if (err) {
143		dev_err(&pdev->dev, "Couldn't register input dev: %d\n", err);
144		return err;
145	}
146
147	platform_set_drvdata(pdev, vibrator);
148
149	return 0;
150}
151
152static int gpio_vibrator_suspend(struct device *dev)
153{
154	struct platform_device *pdev = to_platform_device(dev);
155	struct gpio_vibrator *vibrator = platform_get_drvdata(pdev);
156
157	cancel_work_sync(&vibrator->play_work);
158	if (vibrator->running)
159		gpio_vibrator_stop(vibrator);
160
161	return 0;
162}
163
164static int gpio_vibrator_resume(struct device *dev)
165{
166	struct platform_device *pdev = to_platform_device(dev);
167	struct gpio_vibrator *vibrator = platform_get_drvdata(pdev);
168
169	if (vibrator->running)
170		gpio_vibrator_start(vibrator);
171
172	return 0;
173}
174
175static DEFINE_SIMPLE_DEV_PM_OPS(gpio_vibrator_pm_ops,
176				gpio_vibrator_suspend, gpio_vibrator_resume);
177
178#ifdef CONFIG_OF
179static const struct of_device_id gpio_vibra_dt_match_table[] = {
180	{ .compatible = "gpio-vibrator" },
181	{}
182};
183MODULE_DEVICE_TABLE(of, gpio_vibra_dt_match_table);
184#endif
185
186static struct platform_driver gpio_vibrator_driver = {
187	.probe	= gpio_vibrator_probe,
188	.driver	= {
189		.name	= "gpio-vibrator",
190		.pm	= pm_sleep_ptr(&gpio_vibrator_pm_ops),
191		.of_match_table = of_match_ptr(gpio_vibra_dt_match_table),
192	},
193};
194module_platform_driver(gpio_vibrator_driver);
195
196MODULE_AUTHOR("Luca Weiss <luca@z3ntu.xy>");
197MODULE_DESCRIPTION("GPIO vibrator driver");
198MODULE_LICENSE("GPL");
199MODULE_ALIAS("platform:gpio-vibrator");
200