[mirror_ubuntu-hirsute-kernel.git] / drivers / input / misc / msm-vibrator.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Qualcomm MSM vibrator driver
 *
 * Copyright (c) 2018 Brian Masney <masneyb@onstation.org>
 *
 * Based on qcom,pwm-vibrator.c from:
 * Copyright (c) 2018 Jonathan Marek <jonathan@marek.ca>
 *
 * Based on msm_pwm_vibrator.c from downstream Android sources:
 * Copyright (C) 2009-2014 LGE, Inc.
 */

#include <linux/clk.h>
#include <linux/err.h>
#include <linux/gpio/consumer.h>
#include <linux/input.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regulator/consumer.h>

#define REG_CMD_RCGR           0x00
#define REG_CFG_RCGR           0x04
#define REG_M                  0x08
#define REG_N                  0x0C
#define REG_D                  0x10
#define REG_CBCR               0x24
#define MMSS_CC_M_DEFAULT      1

struct msm_vibrator {
	struct input_dev *input;
	struct mutex mutex;
	struct work_struct worker;
	void __iomem *base;
	struct regulator *vcc;
	struct clk *clk;
	struct gpio_desc *enable_gpio;
	u16 magnitude;
	bool enabled;
};

static void msm_vibrator_write(struct msm_vibrator *vibrator, int offset,
			       u32 value)
{
	writel(value, vibrator->base + offset);
}

static int msm_vibrator_start(struct msm_vibrator *vibrator)
{
	int d_reg_val, ret = 0;

	mutex_lock(&vibrator->mutex);

	if (!vibrator->enabled) {
		ret = clk_set_rate(vibrator->clk, 24000);
		if (ret) {
			dev_err(&vibrator->input->dev,
				"Failed to set clock rate: %d\n", ret);
			goto unlock;
		}

		ret = clk_prepare_enable(vibrator->clk);
		if (ret) {
			dev_err(&vibrator->input->dev,
				"Failed to enable clock: %d\n", ret);
			goto unlock;
		}

		ret = regulator_enable(vibrator->vcc);
		if (ret) {
			dev_err(&vibrator->input->dev,
				"Failed to enable regulator: %d\n", ret);
			clk_disable(vibrator->clk);
			goto unlock;
		}

		gpiod_set_value_cansleep(vibrator->enable_gpio, 1);

		vibrator->enabled = true;
	}

	d_reg_val = 127 - ((126 * vibrator->magnitude) / 0xffff);
	msm_vibrator_write(vibrator, REG_CFG_RCGR,
			   (2 << 12) | /* dual edge mode */
			   (0 << 8) |  /* cxo */
			   (7 << 0));
	msm_vibrator_write(vibrator, REG_M, 1);
	msm_vibrator_write(vibrator, REG_N, 128);
	msm_vibrator_write(vibrator, REG_D, d_reg_val);
	msm_vibrator_write(vibrator, REG_CMD_RCGR, 1);
	msm_vibrator_write(vibrator, REG_CBCR, 1);

unlock:
	mutex_unlock(&vibrator->mutex);

	return ret;
}

static void msm_vibrator_stop(struct msm_vibrator *vibrator)
{
	mutex_lock(&vibrator->mutex);

	if (vibrator->enabled) {
		gpiod_set_value_cansleep(vibrator->enable_gpio, 0);
		regulator_disable(vibrator->vcc);
		clk_disable(vibrator->clk);
		vibrator->enabled = false;
	}

	mutex_unlock(&vibrator->mutex);
}

static void msm_vibrator_worker(struct work_struct *work)
{
	struct msm_vibrator *vibrator = container_of(work,
						     struct msm_vibrator,
						     worker);

	if (vibrator->magnitude)
		msm_vibrator_start(vibrator);
	else
		msm_vibrator_stop(vibrator);
}

static int msm_vibrator_play_effect(struct input_dev *dev, void *data,
				    struct ff_effect *effect)
{
	struct msm_vibrator *vibrator = input_get_drvdata(dev);

	mutex_lock(&vibrator->mutex);

	if (effect->u.rumble.strong_magnitude > 0)
		vibrator->magnitude = effect->u.rumble.strong_magnitude;
	else
		vibrator->magnitude = effect->u.rumble.weak_magnitude;

	mutex_unlock(&vibrator->mutex);

	schedule_work(&vibrator->worker);

	return 0;
}

static void msm_vibrator_close(struct input_dev *input)
{
	struct msm_vibrator *vibrator = input_get_drvdata(input);

	cancel_work_sync(&vibrator->worker);
	msm_vibrator_stop(vibrator);
}

static int msm_vibrator_probe(struct platform_device *pdev)
{
	struct msm_vibrator *vibrator;
	struct resource *res;
	int ret;

	vibrator = devm_kzalloc(&pdev->dev, sizeof(*vibrator), GFP_KERNEL);
	if (!vibrator)
		return -ENOMEM;

	vibrator->input = devm_input_allocate_device(&pdev->dev);
	if (!vibrator->input)
		return -ENOMEM;

	vibrator->vcc = devm_regulator_get(&pdev->dev, "vcc");
	if (IS_ERR(vibrator->vcc)) {
		if (PTR_ERR(vibrator->vcc) != -EPROBE_DEFER)
			dev_err(&pdev->dev, "Failed to get regulator: %ld\n",
				PTR_ERR(vibrator->vcc));
		return PTR_ERR(vibrator->vcc);
	}

	vibrator->enable_gpio = devm_gpiod_get(&pdev->dev, "enable",
					       GPIOD_OUT_LOW);
	if (IS_ERR(vibrator->enable_gpio)) {
		if (PTR_ERR(vibrator->enable_gpio) != -EPROBE_DEFER)
			dev_err(&pdev->dev, "Failed to get enable gpio: %ld\n",
				PTR_ERR(vibrator->enable_gpio));
		return PTR_ERR(vibrator->enable_gpio);
	}

	vibrator->clk = devm_clk_get(&pdev->dev, "pwm");
	if (IS_ERR(vibrator->clk)) {
		if (PTR_ERR(vibrator->clk) != -EPROBE_DEFER)
			dev_err(&pdev->dev, "Failed to lookup pwm clock: %ld\n",
				PTR_ERR(vibrator->clk));
		return PTR_ERR(vibrator->clk);
	}

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		dev_err(&pdev->dev, "Failed to get platform resource\n");
		return -ENODEV;
	}

	vibrator->base = devm_ioremap(&pdev->dev, res->start,
				     resource_size(res));
	if (!vibrator->base) {
		dev_err(&pdev->dev, "Failed to iomap resource.\n");
		return -ENOMEM;
	}

	vibrator->enabled = false;
	mutex_init(&vibrator->mutex);
	INIT_WORK(&vibrator->worker, msm_vibrator_worker);

	vibrator->input->name = "msm-vibrator";
	vibrator->input->id.bustype = BUS_HOST;
	vibrator->input->close = msm_vibrator_close;

	input_set_drvdata(vibrator->input, vibrator);
	input_set_capability(vibrator->input, EV_FF, FF_RUMBLE);

	ret = input_ff_create_memless(vibrator->input, NULL,
				      msm_vibrator_play_effect);
	if (ret) {
		dev_err(&pdev->dev, "Failed to create ff memless: %d", ret);
		return ret;
	}

	ret = input_register_device(vibrator->input);
	if (ret) {
		dev_err(&pdev->dev, "Failed to register input device: %d", ret);
		return ret;
	}

	platform_set_drvdata(pdev, vibrator);

	return 0;
}

static int __maybe_unused msm_vibrator_suspend(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct msm_vibrator *vibrator = platform_get_drvdata(pdev);

	cancel_work_sync(&vibrator->worker);

	if (vibrator->enabled)
		msm_vibrator_stop(vibrator);

	return 0;
}

static int __maybe_unused msm_vibrator_resume(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct msm_vibrator *vibrator = platform_get_drvdata(pdev);

	if (vibrator->enabled)
		msm_vibrator_start(vibrator);

	return 0;
}

static SIMPLE_DEV_PM_OPS(msm_vibrator_pm_ops, msm_vibrator_suspend,
			 msm_vibrator_resume);

static const struct of_device_id msm_vibrator_of_match[] = {
	{ .compatible = "qcom,msm8226-vibrator" },
	{ .compatible = "qcom,msm8974-vibrator" },
	{},
};
MODULE_DEVICE_TABLE(of, msm_vibrator_of_match);

static struct platform_driver msm_vibrator_driver = {
	.probe	= msm_vibrator_probe,
	.driver	= {
		.name = "msm-vibrator",
		.pm = &msm_vibrator_pm_ops,
		.of_match_table = of_match_ptr(msm_vibrator_of_match),
	},
};
module_platform_driver(msm_vibrator_driver);

MODULE_AUTHOR("Brian Masney <masneyb@onstation.org>");
MODULE_DESCRIPTION("Qualcomm MSM vibrator driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
0f681d09 BM	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Qualcomm MSM vibrator driver
	4	*
	5	* Copyright (c) 2018 Brian Masney <masneyb@onstation.org>
	6	*
	7	* Based on qcom,pwm-vibrator.c from:
	8	* Copyright (c) 2018 Jonathan Marek <jonathan@marek.ca>
	9	*
	10	* Based on msm_pwm_vibrator.c from downstream Android sources:
	11	* Copyright (C) 2009-2014 LGE, Inc.
	12	*/
	13
	14	#include <linux/clk.h>
	15	#include <linux/err.h>
741c73ed	16	#include <linux/gpio/consumer.h>
0f681d09 BM	17	#include <linux/input.h>
	18	#include <linux/io.h>
	19	#include <linux/module.h>
	20	#include <linux/of.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/regulator/consumer.h>
	23
	24	#define REG_CMD_RCGR 0x00
	25	#define REG_CFG_RCGR 0x04
	26	#define REG_M 0x08
	27	#define REG_N 0x0C
	28	#define REG_D 0x10
	29	#define REG_CBCR 0x24
	30	#define MMSS_CC_M_DEFAULT 1
	31
	32	struct msm_vibrator {
	33	struct input_dev *input;
	34	struct mutex mutex;
	35	struct work_struct worker;
	36	void __iomem *base;
	37	struct regulator *vcc;
	38	struct clk *clk;
	39	struct gpio_desc *enable_gpio;
	40	u16 magnitude;
	41	bool enabled;
	42	};
	43
	44	static void msm_vibrator_write(struct msm_vibrator *vibrator, int offset,
	45	u32 value)
	46	{
	47	writel(value, vibrator->base + offset);
	48	}
	49
	50	static int msm_vibrator_start(struct msm_vibrator *vibrator)
	51	{
	52	int d_reg_val, ret = 0;
	53
	54	mutex_lock(&vibrator->mutex);
	55
	56	if (!vibrator->enabled) {
	57	ret = clk_set_rate(vibrator->clk, 24000);
	58	if (ret) {
	59	dev_err(&vibrator->input->dev,
	60	"Failed to set clock rate: %d\n", ret);
	61	goto unlock;
	62	}
	63
	64	ret = clk_prepare_enable(vibrator->clk);
	65	if (ret) {
	66	dev_err(&vibrator->input->dev,
	67	"Failed to enable clock: %d\n", ret);
	68	goto unlock;
	69	}
	70
	71	ret = regulator_enable(vibrator->vcc);
	72	if (ret) {
	73	dev_err(&vibrator->input->dev,
	74	"Failed to enable regulator: %d\n", ret);
	75	clk_disable(vibrator->clk);
	76	goto unlock;
	77	}
	78
	79	gpiod_set_value_cansleep(vibrator->enable_gpio, 1);
	80
81	vibrator->enabled = true;
82	}
83
84	d_reg_val = 127 - ((126 * vibrator->magnitude) / 0xffff);
85	msm_vibrator_write(vibrator, REG_CFG_RCGR,
86	(2 << 12) \| /* dual edge mode */
87	(0 << 8) \| /* cxo */
88	(7 << 0));
89	msm_vibrator_write(vibrator, REG_M, 1);
90	msm_vibrator_write(vibrator, REG_N, 128);
91	msm_vibrator_write(vibrator, REG_D, d_reg_val);
92	msm_vibrator_write(vibrator, REG_CMD_RCGR, 1);
93	msm_vibrator_write(vibrator, REG_CBCR, 1);
94
95	unlock:
96	mutex_unlock(&vibrator->mutex);
97
98	return ret;
99	}
100
101	static void msm_vibrator_stop(struct msm_vibrator *vibrator)
102	{
103	mutex_lock(&vibrator->mutex);
104
105	if (vibrator->enabled) {
106	gpiod_set_value_cansleep(vibrator->enable_gpio, 0);
107	regulator_disable(vibrator->vcc);
108	clk_disable(vibrator->clk);
109	vibrator->enabled = false;
110	}
111
112	mutex_unlock(&vibrator->mutex);
113	}
114
115	static void msm_vibrator_worker(struct work_struct *work)
116	{
117	struct msm_vibrator *vibrator = container_of(work,
118	struct msm_vibrator,
119	worker);
120
121	if (vibrator->magnitude)
122	msm_vibrator_start(vibrator);
123	else
124	msm_vibrator_stop(vibrator);
125	}
126
127	static int msm_vibrator_play_effect(struct input_dev dev, void data,
128	struct ff_effect *effect)
129	{
130	struct msm_vibrator *vibrator = input_get_drvdata(dev);
131
132	mutex_lock(&vibrator->mutex);
133
134	if (effect->u.rumble.strong_magnitude > 0)
135	vibrator->magnitude = effect->u.rumble.strong_magnitude;
136	else
137	vibrator->magnitude = effect->u.rumble.weak_magnitude;
138
139	mutex_unlock(&vibrator->mutex);
140
141	schedule_work(&vibrator->worker);
142
143	return 0;
144	}
145
146	static void msm_vibrator_close(struct input_dev *input)
147	{
148	struct msm_vibrator *vibrator = input_get_drvdata(input);
149
150	cancel_work_sync(&vibrator->worker);
151	msm_vibrator_stop(vibrator);
152	}
153
154	static int msm_vibrator_probe(struct platform_device *pdev)
155	{
156	struct msm_vibrator *vibrator;
157	struct resource *res;
158	int ret;
159
160	vibrator = devm_kzalloc(&pdev->dev, sizeof(*vibrator), GFP_KERNEL);
161	if (!vibrator)
162	return -ENOMEM;
163
164	vibrator->input = devm_input_allocate_device(&pdev->dev);
165	if (!vibrator->input)
166	return -ENOMEM;
167
168	vibrator->vcc = devm_regulator_get(&pdev->dev, "vcc");
169	if (IS_ERR(vibrator->vcc)) {
170	if (PTR_ERR(vibrator->vcc) != -EPROBE_DEFER)
171	dev_err(&pdev->dev, "Failed to get regulator: %ld\n",
172	PTR_ERR(vibrator->vcc));
173	return PTR_ERR(vibrator->vcc);
174	}
175
176	vibrator->enable_gpio = devm_gpiod_get(&pdev->dev, "enable",
177	GPIOD_OUT_LOW);
178	if (IS_ERR(vibrator->enable_gpio)) {
179	if (PTR_ERR(vibrator->enable_gpio) != -EPROBE_DEFER)
180	dev_err(&pdev->dev, "Failed to get enable gpio: %ld\n",
181	PTR_ERR(vibrator->enable_gpio));
182	return PTR_ERR(vibrator->enable_gpio);
183	}
184
185	vibrator->clk = devm_clk_get(&pdev->dev, "pwm");
186	if (IS_ERR(vibrator->clk)) {
187	if (PTR_ERR(vibrator->clk) != -EPROBE_DEFER)
188	dev_err(&pdev->dev, "Failed to lookup pwm clock: %ld\n",
189	PTR_ERR(vibrator->clk));
190	return PTR_ERR(vibrator->clk);
191	}
192
193	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
194	if (!res) {
195	dev_err(&pdev->dev, "Failed to get platform resource\n");
196	return -ENODEV;
197	}
198
199	vibrator->base = devm_ioremap(&pdev->dev, res->start,
200	resource_size(res));
201	if (!vibrator->base) {
320f07b4	202	dev_err(&pdev->dev, "Failed to iomap resource.\n");
0f681d09 BM	203	return -ENOMEM;
	204	}
	205
	206	vibrator->enabled = false;
	207	mutex_init(&vibrator->mutex);
	208	INIT_WORK(&vibrator->worker, msm_vibrator_worker);
	209
	210	vibrator->input->name = "msm-vibrator";
	211	vibrator->input->id.bustype = BUS_HOST;
	212	vibrator->input->close = msm_vibrator_close;
	213
	214	input_set_drvdata(vibrator->input, vibrator);
	215	input_set_capability(vibrator->input, EV_FF, FF_RUMBLE);
	216
	217	ret = input_ff_create_memless(vibrator->input, NULL,
	218	msm_vibrator_play_effect);
	219	if (ret) {
	220	dev_err(&pdev->dev, "Failed to create ff memless: %d", ret);
	221	return ret;
	222	}
	223
	224	ret = input_register_device(vibrator->input);
	225	if (ret) {
	226	dev_err(&pdev->dev, "Failed to register input device: %d", ret);
	227	return ret;
	228	}
	229
	230	platform_set_drvdata(pdev, vibrator);
	231
	232	return 0;
	233	}
	234
	235	static int __maybe_unused msm_vibrator_suspend(struct device *dev)
	236	{
	237	struct platform_device *pdev = to_platform_device(dev);
	238	struct msm_vibrator *vibrator = platform_get_drvdata(pdev);
	239
	240	cancel_work_sync(&vibrator->worker);
	241
	242	if (vibrator->enabled)
	243	msm_vibrator_stop(vibrator);
	244
	245	return 0;
	246	}
	247
	248	static int __maybe_unused msm_vibrator_resume(struct device *dev)
	249	{
	250	struct platform_device *pdev = to_platform_device(dev);
	251	struct msm_vibrator *vibrator = platform_get_drvdata(pdev);
	252
	253	if (vibrator->enabled)
	254	msm_vibrator_start(vibrator);
	255
	256	return 0;
	257	}
	258
	259	static SIMPLE_DEV_PM_OPS(msm_vibrator_pm_ops, msm_vibrator_suspend,
	260	msm_vibrator_resume);
	261
	262	static const struct of_device_id msm_vibrator_of_match[] = {
	263	{ .compatible = "qcom,msm8226-vibrator" },
	264	{ .compatible = "qcom,msm8974-vibrator" },
	265	{},
	266	};
267	MODULE_DEVICE_TABLE(of, msm_vibrator_of_match);
268
269	static struct platform_driver msm_vibrator_driver = {
270	.probe = msm_vibrator_probe,
271	.driver = {
272	.name = "msm-vibrator",
273	.pm = &msm_vibrator_pm_ops,
274	.of_match_table = of_match_ptr(msm_vibrator_of_match),
275	},
276	};
277	module_platform_driver(msm_vibrator_driver);
278
279	MODULE_AUTHOR("Brian Masney <masneyb@onstation.org>");
280	MODULE_DESCRIPTION("Qualcomm MSM vibrator driver");
281	MODULE_LICENSE("GPL");