[linux-2.6-block.git] / drivers / input / touchscreen / imagis.c

// SPDX-License-Identifier: GPL-2.0-only

#include <linux/bits.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/input/touchscreen.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/property.h>
#include <linux/regulator/consumer.h>

#define IST3038C_HIB_ACCESS		(0x800B << 16)
#define IST3038C_DIRECT_ACCESS		BIT(31)
#define IST3038C_REG_CHIPID		0x40001000
#define IST3038C_REG_HIB_BASE		0x30000100
#define IST3038C_REG_TOUCH_STATUS	(IST3038C_REG_HIB_BASE | IST3038C_HIB_ACCESS)
#define IST3038C_REG_TOUCH_COORD	(IST3038C_REG_HIB_BASE | IST3038C_HIB_ACCESS | 0x8)
#define IST3038C_REG_INTR_MESSAGE	(IST3038C_REG_HIB_BASE | IST3038C_HIB_ACCESS | 0x4)
#define IST3038C_WHOAMI			0x38c
#define IST3038C_CHIP_ON_DELAY_MS	60
#define IST3038C_I2C_RETRY_COUNT	3
#define IST3038C_MAX_FINGER_NUM		10
#define IST3038C_X_MASK			GENMASK(23, 12)
#define IST3038C_X_SHIFT		12
#define IST3038C_Y_MASK			GENMASK(11, 0)
#define IST3038C_AREA_MASK		GENMASK(27, 24)
#define IST3038C_AREA_SHIFT		24
#define IST3038C_FINGER_COUNT_MASK	GENMASK(15, 12)
#define IST3038C_FINGER_COUNT_SHIFT	12
#define IST3038C_FINGER_STATUS_MASK	GENMASK(9, 0)

struct imagis_ts {
	struct i2c_client *client;
	struct input_dev *input_dev;
	struct touchscreen_properties prop;
	struct regulator_bulk_data supplies[2];
};

static int imagis_i2c_read_reg(struct imagis_ts *ts,
			       unsigned int reg, u32 *data)
{
	__be32 ret_be;
	__be32 reg_be = cpu_to_be32(reg);
	struct i2c_msg msg[] = {
		{
			.addr = ts->client->addr,
			.flags = 0,
			.buf = (unsigned char *)&reg_be,
			.len = sizeof(reg_be),
		}, {
			.addr = ts->client->addr,
			.flags = I2C_M_RD,
			.buf = (unsigned char *)&ret_be,
			.len = sizeof(ret_be),
		},
	};
	int ret, error;
	int retry = IST3038C_I2C_RETRY_COUNT;

	/* Retry in case the controller fails to respond */
	do {
		ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg));
		if (ret == ARRAY_SIZE(msg)) {
			*data = be32_to_cpu(ret_be);
			return 0;
		}

		error = ret < 0 ? ret : -EIO;
		dev_err(&ts->client->dev,
			"%s - i2c_transfer failed: %d (%d)\n",
			__func__, error, ret);
	} while (--retry);

	return error;
}

static irqreturn_t imagis_interrupt(int irq, void *dev_id)
{
	struct imagis_ts *ts = dev_id;
	u32 intr_message, finger_status;
	unsigned int finger_count, finger_pressed;
	int i;
	int error;

	error = imagis_i2c_read_reg(ts, IST3038C_REG_INTR_MESSAGE,
				    &intr_message);
	if (error) {
		dev_err(&ts->client->dev,
			"failed to read the interrupt message: %d\n", error);
		goto out;
	}

	finger_count = (intr_message & IST3038C_FINGER_COUNT_MASK) >>
				IST3038C_FINGER_COUNT_SHIFT;
	if (finger_count > IST3038C_MAX_FINGER_NUM) {
		dev_err(&ts->client->dev,
			"finger count %d is more than maximum supported\n",
			finger_count);
		goto out;
	}

	finger_pressed = intr_message & IST3038C_FINGER_STATUS_MASK;

	for (i = 0; i < finger_count; i++) {
		error = imagis_i2c_read_reg(ts,
					    IST3038C_REG_TOUCH_COORD + (i * 4),
					    &finger_status);
		if (error) {
			dev_err(&ts->client->dev,
				"failed to read coordinates for finger %d: %d\n",
				i, error);
			goto out;
		}

		input_mt_slot(ts->input_dev, i);
		input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER,
					   finger_pressed & BIT(i));
		touchscreen_report_pos(ts->input_dev, &ts->prop,
				       (finger_status & IST3038C_X_MASK) >>
						IST3038C_X_SHIFT,
				       finger_status & IST3038C_Y_MASK, 1);
		input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR,
				 (finger_status & IST3038C_AREA_MASK) >>
					IST3038C_AREA_SHIFT);
	}

	input_mt_sync_frame(ts->input_dev);
	input_sync(ts->input_dev);

out:
	return IRQ_HANDLED;
}

static void imagis_power_off(void *_ts)
{
	struct imagis_ts *ts = _ts;

	regulator_bulk_disable(ARRAY_SIZE(ts->supplies), ts->supplies);
}

static int imagis_power_on(struct imagis_ts *ts)
{
	int error;

	error = regulator_bulk_enable(ARRAY_SIZE(ts->supplies), ts->supplies);
	if (error)
		return error;

	msleep(IST3038C_CHIP_ON_DELAY_MS);

	return 0;
}

static int imagis_start(struct imagis_ts *ts)
{
	int error;

	error = imagis_power_on(ts);
	if (error)
		return error;

	enable_irq(ts->client->irq);

	return 0;
}

static int imagis_stop(struct imagis_ts *ts)
{
	disable_irq(ts->client->irq);

	imagis_power_off(ts);

	return 0;
}

static int imagis_input_open(struct input_dev *dev)
{
	struct imagis_ts *ts = input_get_drvdata(dev);

	return imagis_start(ts);
}

static void imagis_input_close(struct input_dev *dev)
{
	struct imagis_ts *ts = input_get_drvdata(dev);

	imagis_stop(ts);
}

static int imagis_init_input_dev(struct imagis_ts *ts)
{
	struct input_dev *input_dev;
	int error;

	input_dev = devm_input_allocate_device(&ts->client->dev);
	if (!input_dev)
		return -ENOMEM;

	ts->input_dev = input_dev;

	input_dev->name = "Imagis capacitive touchscreen";
	input_dev->phys = "input/ts";
	input_dev->id.bustype = BUS_I2C;
	input_dev->open = imagis_input_open;
	input_dev->close = imagis_input_close;

	input_set_drvdata(input_dev, ts);

	input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
	input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);

	touchscreen_parse_properties(input_dev, true, &ts->prop);
	if (!ts->prop.max_x || !ts->prop.max_y) {
		dev_err(&ts->client->dev,
			"Touchscreen-size-x and/or touchscreen-size-y not set in dts\n");
		return -EINVAL;
	}

	error = input_mt_init_slots(input_dev,
				    IST3038C_MAX_FINGER_NUM,
				    INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
	if (error) {
		dev_err(&ts->client->dev,
			"Failed to initialize MT slots: %d", error);
		return error;
	}

	error = input_register_device(input_dev);
	if (error) {
		dev_err(&ts->client->dev,
			"Failed to register input device: %d", error);
		return error;
	}

	return 0;
}

static int imagis_init_regulators(struct imagis_ts *ts)
{
	struct i2c_client *client = ts->client;

	ts->supplies[0].supply = "vdd";
	ts->supplies[1].supply = "vddio";
	return devm_regulator_bulk_get(&client->dev,
				       ARRAY_SIZE(ts->supplies),
				       ts->supplies);
}

static int imagis_probe(struct i2c_client *i2c)
{
	struct device *dev = &i2c->dev;
	struct imagis_ts *ts;
	int chip_id, error;

	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
	if (!ts)
		return -ENOMEM;

	ts->client = i2c;

	error = imagis_init_regulators(ts);
	if (error) {
		dev_err(dev, "regulator init error: %d\n", error);
		return error;
	}

	error = imagis_power_on(ts);
	if (error) {
		dev_err(dev, "failed to enable regulators: %d\n", error);
		return error;
	}

	error = devm_add_action_or_reset(dev, imagis_power_off, ts);
	if (error) {
		dev_err(dev, "failed to install poweroff action: %d\n", error);
		return error;
	}

	error = imagis_i2c_read_reg(ts,
			IST3038C_REG_CHIPID | IST3038C_DIRECT_ACCESS,
			&chip_id);
	if (error) {
		dev_err(dev, "chip ID read failure: %d\n", error);
		return error;
	}

	if (chip_id != IST3038C_WHOAMI) {
		dev_err(dev, "unknown chip ID: 0x%x\n", chip_id);
		return -EINVAL;
	}

	error = devm_request_threaded_irq(dev, i2c->irq,
					  NULL, imagis_interrupt,
					  IRQF_ONESHOT | IRQF_NO_AUTOEN,
					  "imagis-touchscreen", ts);
	if (error) {
		dev_err(dev, "IRQ %d allocation failure: %d\n",
			i2c->irq, error);
		return error;
	}

	error = imagis_init_input_dev(ts);
	if (error)
		return error;

	return 0;
}

static int imagis_suspend(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct imagis_ts *ts = i2c_get_clientdata(client);
	int retval = 0;

	mutex_lock(&ts->input_dev->mutex);

	if (input_device_enabled(ts->input_dev))
		retval = imagis_stop(ts);

	mutex_unlock(&ts->input_dev->mutex);

	return retval;
}

static int imagis_resume(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct imagis_ts *ts = i2c_get_clientdata(client);
	int retval = 0;

	mutex_lock(&ts->input_dev->mutex);

	if (input_device_enabled(ts->input_dev))
		retval = imagis_start(ts);

	mutex_unlock(&ts->input_dev->mutex);

	return retval;
}

static DEFINE_SIMPLE_DEV_PM_OPS(imagis_pm_ops, imagis_suspend, imagis_resume);

#ifdef CONFIG_OF
static const struct of_device_id imagis_of_match[] = {
	{ .compatible = "imagis,ist3038c", },
	{ },
};
MODULE_DEVICE_TABLE(of, imagis_of_match);
#endif

static struct i2c_driver imagis_ts_driver = {
	.driver = {
		.name = "imagis-touchscreen",
		.pm = pm_sleep_ptr(&imagis_pm_ops),
		.of_match_table = of_match_ptr(imagis_of_match),
	},
	.probe = imagis_probe,
};

module_i2c_driver(imagis_ts_driver);

MODULE_DESCRIPTION("Imagis IST3038C Touchscreen Driver");
MODULE_AUTHOR("Markuss Broks <markuss.broks@gmail.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
a23ba3c0 MB	1	// SPDX-License-Identifier: GPL-2.0-only
	2
	3	#include <linux/bits.h>
	4	#include <linux/delay.h>
	5	#include <linux/i2c.h>
	6	#include <linux/input.h>
	7	#include <linux/input/mt.h>
	8	#include <linux/input/touchscreen.h>
	9	#include <linux/kernel.h>
	10	#include <linux/module.h>
	11	#include <linux/property.h>
	12	#include <linux/regulator/consumer.h>
	13
	14	#define IST3038C_HIB_ACCESS (0x800B << 16)
	15	#define IST3038C_DIRECT_ACCESS BIT(31)
	16	#define IST3038C_REG_CHIPID 0x40001000
	17	#define IST3038C_REG_HIB_BASE 0x30000100
	18	#define IST3038C_REG_TOUCH_STATUS (IST3038C_REG_HIB_BASE \| IST3038C_HIB_ACCESS)
	19	#define IST3038C_REG_TOUCH_COORD (IST3038C_REG_HIB_BASE \| IST3038C_HIB_ACCESS \| 0x8)
	20	#define IST3038C_REG_INTR_MESSAGE (IST3038C_REG_HIB_BASE \| IST3038C_HIB_ACCESS \| 0x4)
	21	#define IST3038C_WHOAMI 0x38c
	22	#define IST3038C_CHIP_ON_DELAY_MS 60
	23	#define IST3038C_I2C_RETRY_COUNT 3
	24	#define IST3038C_MAX_FINGER_NUM 10
	25	#define IST3038C_X_MASK GENMASK(23, 12)
	26	#define IST3038C_X_SHIFT 12
	27	#define IST3038C_Y_MASK GENMASK(11, 0)
	28	#define IST3038C_AREA_MASK GENMASK(27, 24)
	29	#define IST3038C_AREA_SHIFT 24
	30	#define IST3038C_FINGER_COUNT_MASK GENMASK(15, 12)
	31	#define IST3038C_FINGER_COUNT_SHIFT 12
	32	#define IST3038C_FINGER_STATUS_MASK GENMASK(9, 0)
	33
	34	struct imagis_ts {
	35	struct i2c_client *client;
	36	struct input_dev *input_dev;
	37	struct touchscreen_properties prop;
	38	struct regulator_bulk_data supplies[2];
	39	};
	40
	41	static int imagis_i2c_read_reg(struct imagis_ts *ts,
	42	unsigned int reg, u32 *data)
	43	{
	44	__be32 ret_be;
	45	__be32 reg_be = cpu_to_be32(reg);
	46	struct i2c_msg msg[] = {
	47	{
	48	.addr = ts->client->addr,
	49	.flags = 0,
	50	.buf = (unsigned char *)&reg_be,
	51	.len = sizeof(reg_be),
	52	}, {
	53	.addr = ts->client->addr,
	54	.flags = I2C_M_RD,
	55	.buf = (unsigned char *)&ret_be,
	56	.len = sizeof(ret_be),
	57	},
	58	};
	59	int ret, error;
	60	int retry = IST3038C_I2C_RETRY_COUNT;
	61
	62	/* Retry in case the controller fails to respond */
	63	do {
	64	ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg));
65	if (ret == ARRAY_SIZE(msg)) {
66	*data = be32_to_cpu(ret_be);
67	return 0;
68	}
69
70	error = ret < 0 ? ret : -EIO;
71	dev_err(&ts->client->dev,
72	"%s - i2c_transfer failed: %d (%d)\n",
73	__func__, error, ret);
74	} while (--retry);
75
76	return error;
77	}
78
79	static irqreturn_t imagis_interrupt(int irq, void *dev_id)
80	{
81	struct imagis_ts *ts = dev_id;
82	u32 intr_message, finger_status;
83	unsigned int finger_count, finger_pressed;
84	int i;
85	int error;
86
87	error = imagis_i2c_read_reg(ts, IST3038C_REG_INTR_MESSAGE,
88	&intr_message);
89	if (error) {
90	dev_err(&ts->client->dev,
91	"failed to read the interrupt message: %d\n", error);
92	goto out;
93	}
94
95	finger_count = (intr_message & IST3038C_FINGER_COUNT_MASK) >>
96	IST3038C_FINGER_COUNT_SHIFT;
97	if (finger_count > IST3038C_MAX_FINGER_NUM) {
98	dev_err(&ts->client->dev,
99	"finger count %d is more than maximum supported\n",
100	finger_count);
101	goto out;
102	}
103
104	finger_pressed = intr_message & IST3038C_FINGER_STATUS_MASK;
105
106	for (i = 0; i < finger_count; i++) {
107	error = imagis_i2c_read_reg(ts,
108	IST3038C_REG_TOUCH_COORD + (i * 4),
109	&finger_status);
110	if (error) {
111	dev_err(&ts->client->dev,
112	"failed to read coordinates for finger %d: %d\n",
113	i, error);
114	goto out;
115	}
116
117	input_mt_slot(ts->input_dev, i);
118	input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER,
119	finger_pressed & BIT(i));
120	touchscreen_report_pos(ts->input_dev, &ts->prop,
121	(finger_status & IST3038C_X_MASK) >>
122	IST3038C_X_SHIFT,
123	finger_status & IST3038C_Y_MASK, 1);
124	input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR,
125	(finger_status & IST3038C_AREA_MASK) >>
126	IST3038C_AREA_SHIFT);
127	}
128
129	input_mt_sync_frame(ts->input_dev);
130	input_sync(ts->input_dev);
131
132	out:
133	return IRQ_HANDLED;
134	}
135
136	static void imagis_power_off(void *_ts)
137	{
138	struct imagis_ts *ts = _ts;
139
140	regulator_bulk_disable(ARRAY_SIZE(ts->supplies), ts->supplies);
141	}
142
143	static int imagis_power_on(struct imagis_ts *ts)
144	{
145	int error;
146
147	error = regulator_bulk_enable(ARRAY_SIZE(ts->supplies), ts->supplies);
148	if (error)
149	return error;
150
151	msleep(IST3038C_CHIP_ON_DELAY_MS);
152
153	return 0;
154	}
155
156	static int imagis_start(struct imagis_ts *ts)
157	{
158	int error;
159
160	error = imagis_power_on(ts);
161	if (error)
162	return error;
163
164	enable_irq(ts->client->irq);
165
166	return 0;
167	}
168
169	static int imagis_stop(struct imagis_ts *ts)
170	{
171	disable_irq(ts->client->irq);
172
173	imagis_power_off(ts);
174
175	return 0;
176	}
177
178	static int imagis_input_open(struct input_dev *dev)
179	{
180	struct imagis_ts *ts = input_get_drvdata(dev);
181
182	return imagis_start(ts);
183	}
184
185	static void imagis_input_close(struct input_dev *dev)
186	{
187	struct imagis_ts *ts = input_get_drvdata(dev);
188
189	imagis_stop(ts);
190	}
191
192	static int imagis_init_input_dev(struct imagis_ts *ts)
193	{
194	struct input_dev *input_dev;
195	int error;
196
197	input_dev = devm_input_allocate_device(&ts->client->dev);
198	if (!input_dev)
199	return -ENOMEM;
200
201	ts->input_dev = input_dev;
202
203	input_dev->name = "Imagis capacitive touchscreen";
204	input_dev->phys = "input/ts";
205	input_dev->id.bustype = BUS_I2C;
206	input_dev->open = imagis_input_open;
207	input_dev->close = imagis_input_close;
208
209	input_set_drvdata(input_dev, ts);
210
211	input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
212	input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
213	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
214
215	touchscreen_parse_properties(input_dev, true, &ts->prop);
216	if (!ts->prop.max_x \|\| !ts->prop.max_y) {
217	dev_err(&ts->client->dev,
218	"Touchscreen-size-x and/or touchscreen-size-y not set in dts\n");
219	return -EINVAL;
220	}
221
222	error = input_mt_init_slots(input_dev,
223	IST3038C_MAX_FINGER_NUM,
224	INPUT_MT_DIRECT \| INPUT_MT_DROP_UNUSED);
225	if (error) {
226	dev_err(&ts->client->dev,
227	"Failed to initialize MT slots: %d", error);
228	return error;
229	}
230
231	error = input_register_device(input_dev);
232	if (error) {
233	dev_err(&ts->client->dev,
234	"Failed to register input device: %d", error);
235	return error;
236	}
237
238	return 0;
239	}
240
241	static int imagis_init_regulators(struct imagis_ts *ts)
242	{
243	struct i2c_client *client = ts->client;
244
245	ts->supplies[0].supply = "vdd";
246	ts->supplies[1].supply = "vddio";
247	return devm_regulator_bulk_get(&client->dev,
248	ARRAY_SIZE(ts->supplies),
249	ts->supplies);
250	}
251
252	static int imagis_probe(struct i2c_client *i2c)
253	{
254	struct device *dev = &i2c->dev;
255	struct imagis_ts *ts;
256	int chip_id, error;
257
258	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
259	if (!ts)
260	return -ENOMEM;
261
262	ts->client = i2c;
263
264	error = imagis_init_regulators(ts);
265	if (error) {
266	dev_err(dev, "regulator init error: %d\n", error);
267	return error;
268	}
269
270	error = imagis_power_on(ts);
271	if (error) {
272	dev_err(dev, "failed to enable regulators: %d\n", error);
273	return error;
274	}
275
276	error = devm_add_action_or_reset(dev, imagis_power_off, ts);
277	if (error) {
278	dev_err(dev, "failed to install poweroff action: %d\n", error);
279	return error;
280	}
281
282	error = imagis_i2c_read_reg(ts,
283	IST3038C_REG_CHIPID \| IST3038C_DIRECT_ACCESS,
284	&chip_id);
285	if (error) {
286	dev_err(dev, "chip ID read failure: %d\n", error);
287	return error;
288	}
289
290	if (chip_id != IST3038C_WHOAMI) {
291	dev_err(dev, "unknown chip ID: 0x%x\n", chip_id);
292	return -EINVAL;
293	}
294
295	error = devm_request_threaded_irq(dev, i2c->irq,
296	NULL, imagis_interrupt,
297	IRQF_ONESHOT \| IRQF_NO_AUTOEN,
298	"imagis-touchscreen", ts);
299	if (error) {
300	dev_err(dev, "IRQ %d allocation failure: %d\n",
301	i2c->irq, error);
302	return error;
303	}
304
305	error = imagis_init_input_dev(ts);
306	if (error)
307	return error;
308
309	return 0;
310	}
311
a9b11330	312	static int imagis_suspend(struct device *dev)
a23ba3c0 MB	313	{
	314	struct i2c_client *client = to_i2c_client(dev);
	315	struct imagis_ts *ts = i2c_get_clientdata(client);
	316	int retval = 0;
	317
	318	mutex_lock(&ts->input_dev->mutex);
	319
	320	if (input_device_enabled(ts->input_dev))
	321	retval = imagis_stop(ts);
	322
	323	mutex_unlock(&ts->input_dev->mutex);
	324
	325	return retval;
	326	}
	327
a9b11330	328	static int imagis_resume(struct device *dev)
a23ba3c0 MB	329	{
	330	struct i2c_client *client = to_i2c_client(dev);
	331	struct imagis_ts *ts = i2c_get_clientdata(client);
	332	int retval = 0;
	333
	334	mutex_lock(&ts->input_dev->mutex);
	335
	336	if (input_device_enabled(ts->input_dev))
	337	retval = imagis_start(ts);
	338
	339	mutex_unlock(&ts->input_dev->mutex);
	340
	341	return retval;
	342	}
	343
a9b11330	344	static DEFINE_SIMPLE_DEV_PM_OPS(imagis_pm_ops, imagis_suspend, imagis_resume);
a23ba3c0 MB	345
	346	#ifdef CONFIG_OF
	347	static const struct of_device_id imagis_of_match[] = {
	348	{ .compatible = "imagis,ist3038c", },
	349	{ },
	350	};
	351	MODULE_DEVICE_TABLE(of, imagis_of_match);
	352	#endif
	353
	354	static struct i2c_driver imagis_ts_driver = {
	355	.driver = {
	356	.name = "imagis-touchscreen",
a9b11330	357	.pm = pm_sleep_ptr(&imagis_pm_ops),
a23ba3c0 MB	358	.of_match_table = of_match_ptr(imagis_of_match),
a23ba3c0 MB	359	},
d8bde56d	360	.probe = imagis_probe,
a23ba3c0 MB	361	};
	362
	363	module_i2c_driver(imagis_ts_driver);
	364
	365	MODULE_DESCRIPTION("Imagis IST3038C Touchscreen Driver");
	366	MODULE_AUTHOR("Markuss Broks <markuss.broks@gmail.com>");
	367	MODULE_LICENSE("GPL");