[mirror_ubuntu-jammy-kernel.git] / drivers / hid / i2c-hid / i2c-hid-of-goodix.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Driver for Goodix touchscreens that use the i2c-hid protocol.
 *
 * Copyright 2020 Google LLC
 */

#include <linux/delay.h>
#include <linux/device.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/pm.h>
#include <linux/regulator/consumer.h>

#include "i2c-hid.h"

struct goodix_i2c_hid_timing_data {
	unsigned int post_gpio_reset_delay_ms;
	unsigned int post_power_delay_ms;
};

struct i2c_hid_of_goodix {
	struct i2chid_ops ops;

	struct regulator *vdd;
	struct notifier_block nb;
	struct gpio_desc *reset_gpio;
	const struct goodix_i2c_hid_timing_data *timings;
};

static void goodix_i2c_hid_deassert_reset(struct i2c_hid_of_goodix *ihid_goodix,
					  bool regulator_just_turned_on)
{
	if (regulator_just_turned_on && ihid_goodix->timings->post_power_delay_ms)
		msleep(ihid_goodix->timings->post_power_delay_ms);

	gpiod_set_value_cansleep(ihid_goodix->reset_gpio, 0);
	if (ihid_goodix->timings->post_gpio_reset_delay_ms)
		msleep(ihid_goodix->timings->post_gpio_reset_delay_ms);
}

static int goodix_i2c_hid_power_up(struct i2chid_ops *ops)
{
	struct i2c_hid_of_goodix *ihid_goodix =
		container_of(ops, struct i2c_hid_of_goodix, ops);

	return regulator_enable(ihid_goodix->vdd);
}

static void goodix_i2c_hid_power_down(struct i2chid_ops *ops)
{
	struct i2c_hid_of_goodix *ihid_goodix =
		container_of(ops, struct i2c_hid_of_goodix, ops);

	regulator_disable(ihid_goodix->vdd);
}

static int ihid_goodix_vdd_notify(struct notifier_block *nb,
				    unsigned long event,
				    void *ignored)
{
	struct i2c_hid_of_goodix *ihid_goodix =
		container_of(nb, struct i2c_hid_of_goodix, nb);
	int ret = NOTIFY_OK;

	switch (event) {
	case REGULATOR_EVENT_PRE_DISABLE:
		gpiod_set_value_cansleep(ihid_goodix->reset_gpio, 1);
		break;

	case REGULATOR_EVENT_ENABLE:
		goodix_i2c_hid_deassert_reset(ihid_goodix, true);
		break;

	case REGULATOR_EVENT_ABORT_DISABLE:
		goodix_i2c_hid_deassert_reset(ihid_goodix, false);
		break;

	default:
		ret = NOTIFY_DONE;
		break;
	}

	return ret;
}

static int i2c_hid_of_goodix_probe(struct i2c_client *client,
				   const struct i2c_device_id *id)
{
	struct i2c_hid_of_goodix *ihid_goodix;
	int ret;
	ihid_goodix = devm_kzalloc(&client->dev, sizeof(*ihid_goodix),
				   GFP_KERNEL);
	if (!ihid_goodix)
		return -ENOMEM;

	ihid_goodix->ops.power_up = goodix_i2c_hid_power_up;
	ihid_goodix->ops.power_down = goodix_i2c_hid_power_down;

	/* Start out with reset asserted */
	ihid_goodix->reset_gpio =
		devm_gpiod_get_optional(&client->dev, "reset", GPIOD_OUT_HIGH);
	if (IS_ERR(ihid_goodix->reset_gpio))
		return PTR_ERR(ihid_goodix->reset_gpio);

	ihid_goodix->vdd = devm_regulator_get(&client->dev, "vdd");
	if (IS_ERR(ihid_goodix->vdd))
		return PTR_ERR(ihid_goodix->vdd);

	ihid_goodix->timings = device_get_match_data(&client->dev);

	/*
	 * We need to control the "reset" line in lockstep with the regulator
	 * actually turning on an off instead of just when we make the request.
	 * This matters if the regulator is shared with another consumer.
	 * - If the regulator is off then we must assert reset. The reset
	 *   line is active low and on some boards it could cause a current
	 *   leak if left high.
	 * - If the regulator is on then we don't want reset asserted for very
	 *   long. Holding the controller in reset apparently draws extra
	 *   power.
	 */
	ihid_goodix->nb.notifier_call = ihid_goodix_vdd_notify;
	ret = devm_regulator_register_notifier(ihid_goodix->vdd, &ihid_goodix->nb);
	if (ret)
		return dev_err_probe(&client->dev, ret,
			"regulator notifier request failed\n");

	/*
	 * If someone else is holding the regulator on (or the regulator is
	 * an always-on one) we might never be told to deassert reset. Do it
	 * now... and temporarily bump the regulator reference count just to
	 * make sure it is impossible for this to race with our own notifier!
	 * We also assume that someone else might have _just barely_ turned
	 * the regulator on so we'll do the full "post_power_delay" just in
	 * case.
	 */
	if (ihid_goodix->reset_gpio && regulator_is_enabled(ihid_goodix->vdd)) {
		ret = regulator_enable(ihid_goodix->vdd);
		if (ret)
			return ret;
		goodix_i2c_hid_deassert_reset(ihid_goodix, true);
		regulator_disable(ihid_goodix->vdd);
	}

	return i2c_hid_core_probe(client, &ihid_goodix->ops, 0x0001, 0);
}

static const struct goodix_i2c_hid_timing_data goodix_gt7375p_timing_data = {
	.post_power_delay_ms = 10,
	.post_gpio_reset_delay_ms = 180,
};

static const struct of_device_id goodix_i2c_hid_of_match[] = {
	{ .compatible = "goodix,gt7375p", .data = &goodix_gt7375p_timing_data },
	{ }
};
MODULE_DEVICE_TABLE(of, goodix_i2c_hid_of_match);

static struct i2c_driver goodix_i2c_hid_ts_driver = {
	.driver = {
		.name	= "i2c_hid_of_goodix",
		.pm	= &i2c_hid_core_pm,
		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
		.of_match_table = of_match_ptr(goodix_i2c_hid_of_match),
	},
	.probe		= i2c_hid_of_goodix_probe,
	.remove		= i2c_hid_core_remove,
	.shutdown	= i2c_hid_core_shutdown,
};
module_i2c_driver(goodix_i2c_hid_ts_driver);

MODULE_AUTHOR("Douglas Anderson <dianders@chromium.org>");
MODULE_DESCRIPTION("Goodix i2c-hid touchscreen driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
c1ed18c1 DA	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Driver for Goodix touchscreens that use the i2c-hid protocol.
	4	*
	5	* Copyright 2020 Google LLC
	6	*/
	7
	8	#include <linux/delay.h>
	9	#include <linux/device.h>
	10	#include <linux/gpio/consumer.h>
	11	#include <linux/i2c.h>
	12	#include <linux/kernel.h>
	13	#include <linux/module.h>
	14	#include <linux/of.h>
	15	#include <linux/pm.h>
	16	#include <linux/regulator/consumer.h>
	17
	18	#include "i2c-hid.h"
	19
	20	struct goodix_i2c_hid_timing_data {
	21	unsigned int post_gpio_reset_delay_ms;
	22	unsigned int post_power_delay_ms;
	23	};
	24
	25	struct i2c_hid_of_goodix {
	26	struct i2chid_ops ops;
	27
	28	struct regulator *vdd;
18eeef46	29	struct notifier_block nb;
c1ed18c1 DA	30	struct gpio_desc *reset_gpio;
	31	const struct goodix_i2c_hid_timing_data *timings;
	32	};
	33
18eeef46 DA	34	static void goodix_i2c_hid_deassert_reset(struct i2c_hid_of_goodix *ihid_goodix,
18eeef46 DA	35	bool regulator_just_turned_on)
c1ed18c1	36	{
18eeef46	37	if (regulator_just_turned_on && ihid_goodix->timings->post_power_delay_ms)
c1ed18c1 DA	38	msleep(ihid_goodix->timings->post_power_delay_ms);
	39
	40	gpiod_set_value_cansleep(ihid_goodix->reset_gpio, 0);
	41	if (ihid_goodix->timings->post_gpio_reset_delay_ms)
	42	msleep(ihid_goodix->timings->post_gpio_reset_delay_ms);
18eeef46	43	}
c1ed18c1	44
18eeef46 DA	45	static int goodix_i2c_hid_power_up(struct i2chid_ops *ops)
	46	{
	47	struct i2c_hid_of_goodix *ihid_goodix =
	48	container_of(ops, struct i2c_hid_of_goodix, ops);
	49
	50	return regulator_enable(ihid_goodix->vdd);
c1ed18c1 DA	51	}
	52
	53	static void goodix_i2c_hid_power_down(struct i2chid_ops *ops)
	54	{
	55	struct i2c_hid_of_goodix *ihid_goodix =
	56	container_of(ops, struct i2c_hid_of_goodix, ops);
	57
c1ed18c1 DA	58	regulator_disable(ihid_goodix->vdd);
	59	}
	60
18eeef46 DA	61	static int ihid_goodix_vdd_notify(struct notifier_block *nb,
	62	unsigned long event,
	63	void *ignored)
	64	{
	65	struct i2c_hid_of_goodix *ihid_goodix =
	66	container_of(nb, struct i2c_hid_of_goodix, nb);
	67	int ret = NOTIFY_OK;
	68
18eeef46 DA	69	switch (event) {
	70	case REGULATOR_EVENT_PRE_DISABLE:
	71	gpiod_set_value_cansleep(ihid_goodix->reset_gpio, 1);
	72	break;
	73
	74	case REGULATOR_EVENT_ENABLE:
	75	goodix_i2c_hid_deassert_reset(ihid_goodix, true);
	76	break;
	77
	78	case REGULATOR_EVENT_ABORT_DISABLE:
	79	goodix_i2c_hid_deassert_reset(ihid_goodix, false);
	80	break;
	81
	82	default:
	83	ret = NOTIFY_DONE;
	84	break;
	85	}
	86
18eeef46 DA	87	return ret;
	88	}
	89
c1ed18c1 DA	90	static int i2c_hid_of_goodix_probe(struct i2c_client *client,
	91	const struct i2c_device_id *id)
	92	{
	93	struct i2c_hid_of_goodix *ihid_goodix;
18eeef46	94	int ret;
c1ed18c1 DA	95	ihid_goodix = devm_kzalloc(&client->dev, sizeof(*ihid_goodix),
	96	GFP_KERNEL);
	97	if (!ihid_goodix)
	98	return -ENOMEM;
	99
	100	ihid_goodix->ops.power_up = goodix_i2c_hid_power_up;
	101	ihid_goodix->ops.power_down = goodix_i2c_hid_power_down;
	102
	103	/* Start out with reset asserted */
	104	ihid_goodix->reset_gpio =
	105	devm_gpiod_get_optional(&client->dev, "reset", GPIOD_OUT_HIGH);
	106	if (IS_ERR(ihid_goodix->reset_gpio))
	107	return PTR_ERR(ihid_goodix->reset_gpio);
	108
	109	ihid_goodix->vdd = devm_regulator_get(&client->dev, "vdd");
	110	if (IS_ERR(ihid_goodix->vdd))
	111	return PTR_ERR(ihid_goodix->vdd);
	112
	113	ihid_goodix->timings = device_get_match_data(&client->dev);
	114
18eeef46 DA	115	/*
	116	* We need to control the "reset" line in lockstep with the regulator
	117	* actually turning on an off instead of just when we make the request.
	118	* This matters if the regulator is shared with another consumer.
	119	* - If the regulator is off then we must assert reset. The reset
	120	* line is active low and on some boards it could cause a current
	121	* leak if left high.
	122	* - If the regulator is on then we don't want reset asserted for very
	123	* long. Holding the controller in reset apparently draws extra
	124	* power.
	125	*/
18eeef46	126	ihid_goodix->nb.notifier_call = ihid_goodix_vdd_notify;
25ddd7cf	127	ret = devm_regulator_register_notifier(ihid_goodix->vdd, &ihid_goodix->nb);
fe1e255c	128	if (ret)
18eeef46 DA	129	return dev_err_probe(&client->dev, ret,
18eeef46 DA	130	"regulator notifier request failed\n");
18eeef46 DA	131
	132	/*
	133	* If someone else is holding the regulator on (or the regulator is
	134	* an always-on one) we might never be told to deassert reset. Do it
fe1e255c DT	135	* now... and temporarily bump the regulator reference count just to
	136	* make sure it is impossible for this to race with our own notifier!
	137	* We also assume that someone else might have _just barely_ turned
	138	* the regulator on so we'll do the full "post_power_delay" just in
	139	* case.
18eeef46	140	*/
fe1e255c DT	141	if (ihid_goodix->reset_gpio && regulator_is_enabled(ihid_goodix->vdd)) {
	142	ret = regulator_enable(ihid_goodix->vdd);
	143	if (ret)
	144	return ret;
18eeef46	145	goodix_i2c_hid_deassert_reset(ihid_goodix, true);
fe1e255c DT	146	regulator_disable(ihid_goodix->vdd);
fe1e255c DT	147	}
18eeef46	148
e7362fae	149	return i2c_hid_core_probe(client, &ihid_goodix->ops, 0x0001, 0);
c1ed18c1 DA	150	}
	151
	152	static const struct goodix_i2c_hid_timing_data goodix_gt7375p_timing_data = {
	153	.post_power_delay_ms = 10,
	154	.post_gpio_reset_delay_ms = 180,
	155	};
	156
	157	static const struct of_device_id goodix_i2c_hid_of_match[] = {
	158	{ .compatible = "goodix,gt7375p", .data = &goodix_gt7375p_timing_data },
	159	{ }
	160	};
	161	MODULE_DEVICE_TABLE(of, goodix_i2c_hid_of_match);
	162
	163	static struct i2c_driver goodix_i2c_hid_ts_driver = {
	164	.driver = {
	165	.name = "i2c_hid_of_goodix",
	166	.pm = &i2c_hid_core_pm,
	167	.probe_type = PROBE_PREFER_ASYNCHRONOUS,
	168	.of_match_table = of_match_ptr(goodix_i2c_hid_of_match),
	169	},
	170	.probe = i2c_hid_of_goodix_probe,
	171	.remove = i2c_hid_core_remove,
	172	.shutdown = i2c_hid_core_shutdown,
	173	};
	174	module_i2c_driver(goodix_i2c_hid_ts_driver);
	175
	176	MODULE_AUTHOR("Douglas Anderson <dianders@chromium.org>");
	177	MODULE_DESCRIPTION("Goodix i2c-hid touchscreen driver");
	178	MODULE_LICENSE("GPL v2");