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 * 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
grts_cb(const void * data,void * private)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
grts_open(struct input_dev * dev)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
grts_close(struct input_dev * dev)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
grts_disable(void * data)92 static void grts_disable(void *data)
93 {
94 iio_channel_release_all_cb(data);
95 }
96
grts_probe(struct platform_device * pdev)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
