1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * ADC generic resistive touchscreen (GRTS)
4  * This is a generic input driver that connects to an ADC
5  * given the channels in device tree, and reports events to the input
6  * subsystem.
7  *
8  * Copyright (C) 2017,2018 Microchip Technology,
9  * Author: Eugen Hristev <eugen.hristev@microchip.com>
10  *
11  */
12 #include <linux/input.h>
13 #include <linux/input/touchscreen.h>
14 #include <linux/iio/consumer.h>
15 #include <linux/iio/iio.h>
16 #include <linux/module.h>
17 #include <linux/of.h>
18 #include <linux/of_device.h>
19 #include <linux/platform_device.h>
20 
21 #define DRIVER_NAME					"resistive-adc-touch"
22 #define GRTS_DEFAULT_PRESSURE_MIN			50000
23 #define GRTS_MAX_POS_MASK				GENMASK(11, 0)
24 
25 /**
26  * struct grts_state - generic resistive touch screen information struct
27  * @pressure_min:	number representing the minimum for the pressure
28  * @pressure:		are we getting pressure info or not
29  * @iio_chans:		list of channels acquired
30  * @iio_cb:		iio_callback buffer for the data
31  * @input:		the input device structure that we register
32  * @prop:		touchscreen properties struct
33  */
34 struct grts_state {
35 	u32				pressure_min;
36 	bool				pressure;
37 	struct iio_channel		*iio_chans;
38 	struct iio_cb_buffer		*iio_cb;
39 	struct input_dev		*input;
40 	struct touchscreen_properties	prop;
41 };
42 
43 static int grts_cb(const void *data, void *private)
44 {
45 	const u16 *touch_info = data;
46 	struct grts_state *st = private;
47 	unsigned int x, y, press = 0x0;
48 
49 	/* channel data coming in buffer in the order below */
50 	x = touch_info[0];
51 	y = touch_info[1];
52 	if (st->pressure)
53 		press = touch_info[2];
54 
55 	if ((!x && !y) || (st->pressure && (press < st->pressure_min))) {
56 		/* report end of touch */
57 		input_report_key(st->input, BTN_TOUCH, 0);
58 		input_sync(st->input);
59 		return 0;
60 	}
61 
62 	/* report proper touch to subsystem*/
63 	touchscreen_report_pos(st->input, &st->prop, x, y, false);
64 	if (st->pressure)
65 		input_report_abs(st->input, ABS_PRESSURE, press);
66 	input_report_key(st->input, BTN_TOUCH, 1);
67 	input_sync(st->input);
68 
69 	return 0;
70 }
71 
72 static int grts_open(struct input_dev *dev)
73 {
74 	int error;
75 	struct grts_state *st = input_get_drvdata(dev);
76 
77 	error = iio_channel_start_all_cb(st->iio_cb);
78 	if (error) {
79 		dev_err(dev->dev.parent, "failed to start callback buffer.\n");
80 		return error;
81 	}
82 	return 0;
83 }
84 
85 static void grts_close(struct input_dev *dev)
86 {
87 	struct grts_state *st = input_get_drvdata(dev);
88 
89 	iio_channel_stop_all_cb(st->iio_cb);
90 }
91 
92 static void grts_disable(void *data)
93 {
94 	iio_channel_release_all_cb(data);
95 }
96 
97 static int grts_probe(struct platform_device *pdev)
98 {
99 	struct grts_state *st;
100 	struct input_dev *input;
101 	struct device *dev = &pdev->dev;
102 	struct iio_channel *chan;
103 	int error;
104 
105 	st = devm_kzalloc(dev, sizeof(struct grts_state), GFP_KERNEL);
106 	if (!st)
107 		return -ENOMEM;
108 
109 	/* get the channels from IIO device */
110 	st->iio_chans = devm_iio_channel_get_all(dev);
111 	if (IS_ERR(st->iio_chans)) {
112 		error = PTR_ERR(st->iio_chans);
113 		if (error != -EPROBE_DEFER)
114 			dev_err(dev, "can't get iio channels.\n");
115 		return error;
116 	}
117 
118 	chan = &st->iio_chans[0];
119 	st->pressure = false;
120 	while (chan && chan->indio_dev) {
121 		if (!strcmp(chan->channel->datasheet_name, "pressure"))
122 			st->pressure = true;
123 		chan++;
124 	}
125 
126 	if (st->pressure) {
127 		error = device_property_read_u32(dev,
128 						 "touchscreen-min-pressure",
129 						 &st->pressure_min);
130 		if (error) {
131 			dev_dbg(dev, "can't get touchscreen-min-pressure property.\n");
132 			st->pressure_min = GRTS_DEFAULT_PRESSURE_MIN;
133 		}
134 	}
135 
136 	input = devm_input_allocate_device(dev);
137 	if (!input) {
138 		dev_err(dev, "failed to allocate input device.\n");
139 		return -ENOMEM;
140 	}
141 
142 	input->name = DRIVER_NAME;
143 	input->id.bustype = BUS_HOST;
144 	input->open = grts_open;
145 	input->close = grts_close;
146 
147 	input_set_abs_params(input, ABS_X, 0, GRTS_MAX_POS_MASK - 1, 0, 0);
148 	input_set_abs_params(input, ABS_Y, 0, GRTS_MAX_POS_MASK - 1, 0, 0);
149 	if (st->pressure)
150 		input_set_abs_params(input, ABS_PRESSURE, st->pressure_min,
151 				     0xffff, 0, 0);
152 
153 	input_set_capability(input, EV_KEY, BTN_TOUCH);
154 
155 	/* parse optional device tree properties */
156 	touchscreen_parse_properties(input, false, &st->prop);
157 
158 	st->input = input;
159 	input_set_drvdata(input, st);
160 
161 	error = input_register_device(input);
162 	if (error) {
163 		dev_err(dev, "failed to register input device.");
164 		return error;
165 	}
166 
167 	st->iio_cb = iio_channel_get_all_cb(dev, grts_cb, st);
168 	if (IS_ERR(st->iio_cb)) {
169 		dev_err(dev, "failed to allocate callback buffer.\n");
170 		return PTR_ERR(st->iio_cb);
171 	}
172 
173 	error = devm_add_action_or_reset(dev, grts_disable, st->iio_cb);
174 	if (error) {
175 		dev_err(dev, "failed to add disable action.\n");
176 		return error;
177 	}
178 
179 	return 0;
180 }
181 
182 static const struct of_device_id grts_of_match[] = {
183 	{
184 		.compatible = "resistive-adc-touch",
185 	}, {
186 		/* sentinel */
187 	},
188 };
189 
190 MODULE_DEVICE_TABLE(of, grts_of_match);
191 
192 static struct platform_driver grts_driver = {
193 	.probe = grts_probe,
194 	.driver = {
195 		.name = DRIVER_NAME,
196 		.of_match_table = of_match_ptr(grts_of_match),
197 	},
198 };
199 
200 module_platform_driver(grts_driver);
201 
202 MODULE_AUTHOR("Eugen Hristev <eugen.hristev@microchip.com>");
203 MODULE_DESCRIPTION("Generic ADC Resistive Touch Driver");
204 MODULE_LICENSE("GPL v2");
205