1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Input driver for joysticks connected over ADC. |
4 | * Copyright (c) 2019-2020 Artur Rojek <contact@artur-rojek.eu> |
5 | */ |
6 | #include <linux/ctype.h> |
7 | #include <linux/input.h> |
8 | #include <linux/iio/iio.h> |
9 | #include <linux/iio/consumer.h> |
10 | #include <linux/module.h> |
11 | #include <linux/platform_device.h> |
12 | #include <linux/property.h> |
13 | |
14 | #include <asm/unaligned.h> |
15 | |
16 | struct adc_joystick_axis { |
17 | u32 code; |
18 | s32 range[2]; |
19 | s32 fuzz; |
20 | s32 flat; |
21 | }; |
22 | |
23 | struct adc_joystick { |
24 | struct input_dev *input; |
25 | struct iio_cb_buffer *buffer; |
26 | struct adc_joystick_axis *axes; |
27 | struct iio_channel *chans; |
28 | int num_chans; |
29 | bool polled; |
30 | }; |
31 | |
32 | static void adc_joystick_poll(struct input_dev *input) |
33 | { |
34 | struct adc_joystick *joy = input_get_drvdata(dev: input); |
35 | int i, val, ret; |
36 | |
37 | for (i = 0; i < joy->num_chans; i++) { |
38 | ret = iio_read_channel_raw(chan: &joy->chans[i], val: &val); |
39 | if (ret < 0) |
40 | return; |
41 | input_report_abs(dev: input, code: joy->axes[i].code, value: val); |
42 | } |
43 | input_sync(dev: input); |
44 | } |
45 | |
46 | static int adc_joystick_handle(const void *data, void *private) |
47 | { |
48 | struct adc_joystick *joy = private; |
49 | enum iio_endian endianness; |
50 | int bytes, msb, val, idx, i; |
51 | const u16 *data_u16; |
52 | bool sign; |
53 | |
54 | bytes = joy->chans[0].channel->scan_type.storagebits >> 3; |
55 | |
56 | for (i = 0; i < joy->num_chans; ++i) { |
57 | idx = joy->chans[i].channel->scan_index; |
58 | endianness = joy->chans[i].channel->scan_type.endianness; |
59 | msb = joy->chans[i].channel->scan_type.realbits - 1; |
60 | sign = tolower(joy->chans[i].channel->scan_type.sign) == 's'; |
61 | |
62 | switch (bytes) { |
63 | case 1: |
64 | val = ((const u8 *)data)[idx]; |
65 | break; |
66 | case 2: |
67 | data_u16 = (const u16 *)data + idx; |
68 | |
69 | /* |
70 | * Data is aligned to the sample size by IIO core. |
71 | * Call `get_unaligned_xe16` to hide type casting. |
72 | */ |
73 | if (endianness == IIO_BE) |
74 | val = get_unaligned_be16(p: data_u16); |
75 | else if (endianness == IIO_LE) |
76 | val = get_unaligned_le16(p: data_u16); |
77 | else /* IIO_CPU */ |
78 | val = *data_u16; |
79 | break; |
80 | default: |
81 | return -EINVAL; |
82 | } |
83 | |
84 | val >>= joy->chans[i].channel->scan_type.shift; |
85 | if (sign) |
86 | val = sign_extend32(value: val, index: msb); |
87 | else |
88 | val &= GENMASK(msb, 0); |
89 | input_report_abs(dev: joy->input, code: joy->axes[i].code, value: val); |
90 | } |
91 | |
92 | input_sync(dev: joy->input); |
93 | |
94 | return 0; |
95 | } |
96 | |
97 | static int adc_joystick_open(struct input_dev *dev) |
98 | { |
99 | struct adc_joystick *joy = input_get_drvdata(dev); |
100 | struct device *devp = &dev->dev; |
101 | int ret; |
102 | |
103 | ret = iio_channel_start_all_cb(cb_buff: joy->buffer); |
104 | if (ret) |
105 | dev_err(devp, "Unable to start callback buffer: %d\n" , ret); |
106 | |
107 | return ret; |
108 | } |
109 | |
110 | static void adc_joystick_close(struct input_dev *dev) |
111 | { |
112 | struct adc_joystick *joy = input_get_drvdata(dev); |
113 | |
114 | iio_channel_stop_all_cb(cb_buff: joy->buffer); |
115 | } |
116 | |
117 | static void adc_joystick_cleanup(void *data) |
118 | { |
119 | iio_channel_release_all_cb(cb_buffer: data); |
120 | } |
121 | |
122 | static int adc_joystick_set_axes(struct device *dev, struct adc_joystick *joy) |
123 | { |
124 | struct adc_joystick_axis *axes; |
125 | struct fwnode_handle *child; |
126 | int num_axes, error, i; |
127 | |
128 | num_axes = device_get_child_node_count(dev); |
129 | if (!num_axes) { |
130 | dev_err(dev, "Unable to find child nodes\n" ); |
131 | return -EINVAL; |
132 | } |
133 | |
134 | if (num_axes != joy->num_chans) { |
135 | dev_err(dev, "Got %d child nodes for %d channels\n" , |
136 | num_axes, joy->num_chans); |
137 | return -EINVAL; |
138 | } |
139 | |
140 | axes = devm_kmalloc_array(dev, n: num_axes, size: sizeof(*axes), GFP_KERNEL); |
141 | if (!axes) |
142 | return -ENOMEM; |
143 | |
144 | device_for_each_child_node(dev, child) { |
145 | error = fwnode_property_read_u32(fwnode: child, propname: "reg" , val: &i); |
146 | if (error) { |
147 | dev_err(dev, "reg invalid or missing\n" ); |
148 | goto err_fwnode_put; |
149 | } |
150 | |
151 | if (i >= num_axes) { |
152 | error = -EINVAL; |
153 | dev_err(dev, "No matching axis for reg %d\n" , i); |
154 | goto err_fwnode_put; |
155 | } |
156 | |
157 | error = fwnode_property_read_u32(fwnode: child, propname: "linux,code" , |
158 | val: &axes[i].code); |
159 | if (error) { |
160 | dev_err(dev, "linux,code invalid or missing\n" ); |
161 | goto err_fwnode_put; |
162 | } |
163 | |
164 | error = fwnode_property_read_u32_array(fwnode: child, propname: "abs-range" , |
165 | val: axes[i].range, nval: 2); |
166 | if (error) { |
167 | dev_err(dev, "abs-range invalid or missing\n" ); |
168 | goto err_fwnode_put; |
169 | } |
170 | |
171 | fwnode_property_read_u32(fwnode: child, propname: "abs-fuzz" , val: &axes[i].fuzz); |
172 | fwnode_property_read_u32(fwnode: child, propname: "abs-flat" , val: &axes[i].flat); |
173 | |
174 | input_set_abs_params(dev: joy->input, axis: axes[i].code, |
175 | min: axes[i].range[0], max: axes[i].range[1], |
176 | fuzz: axes[i].fuzz, flat: axes[i].flat); |
177 | input_set_capability(dev: joy->input, EV_ABS, code: axes[i].code); |
178 | } |
179 | |
180 | joy->axes = axes; |
181 | |
182 | return 0; |
183 | |
184 | err_fwnode_put: |
185 | fwnode_handle_put(fwnode: child); |
186 | return error; |
187 | } |
188 | |
189 | static int adc_joystick_probe(struct platform_device *pdev) |
190 | { |
191 | struct device *dev = &pdev->dev; |
192 | struct adc_joystick *joy; |
193 | struct input_dev *input; |
194 | int error; |
195 | int bits; |
196 | int i; |
197 | unsigned int poll_interval; |
198 | |
199 | joy = devm_kzalloc(dev, size: sizeof(*joy), GFP_KERNEL); |
200 | if (!joy) |
201 | return -ENOMEM; |
202 | |
203 | joy->chans = devm_iio_channel_get_all(dev); |
204 | if (IS_ERR(ptr: joy->chans)) { |
205 | error = PTR_ERR(ptr: joy->chans); |
206 | if (error != -EPROBE_DEFER) |
207 | dev_err(dev, "Unable to get IIO channels" ); |
208 | return error; |
209 | } |
210 | |
211 | error = device_property_read_u32(dev, propname: "poll-interval" , val: &poll_interval); |
212 | if (error) { |
213 | /* -EINVAL means the property is absent. */ |
214 | if (error != -EINVAL) |
215 | return error; |
216 | } else if (poll_interval == 0) { |
217 | dev_err(dev, "Unable to get poll-interval\n" ); |
218 | return -EINVAL; |
219 | } else { |
220 | joy->polled = true; |
221 | } |
222 | |
223 | /* |
224 | * Count how many channels we got. NULL terminated. |
225 | * Do not check the storage size if using polling. |
226 | */ |
227 | for (i = 0; joy->chans[i].indio_dev; i++) { |
228 | if (joy->polled) |
229 | continue; |
230 | bits = joy->chans[i].channel->scan_type.storagebits; |
231 | if (!bits || bits > 16) { |
232 | dev_err(dev, "Unsupported channel storage size\n" ); |
233 | return -EINVAL; |
234 | } |
235 | if (bits != joy->chans[0].channel->scan_type.storagebits) { |
236 | dev_err(dev, "Channels must have equal storage size\n" ); |
237 | return -EINVAL; |
238 | } |
239 | } |
240 | joy->num_chans = i; |
241 | |
242 | input = devm_input_allocate_device(dev); |
243 | if (!input) { |
244 | dev_err(dev, "Unable to allocate input device\n" ); |
245 | return -ENOMEM; |
246 | } |
247 | |
248 | joy->input = input; |
249 | input->name = pdev->name; |
250 | input->id.bustype = BUS_HOST; |
251 | |
252 | error = adc_joystick_set_axes(dev, joy); |
253 | if (error) |
254 | return error; |
255 | |
256 | if (joy->polled) { |
257 | input_setup_polling(dev: input, poll_fn: adc_joystick_poll); |
258 | input_set_poll_interval(dev: input, interval: poll_interval); |
259 | } else { |
260 | input->open = adc_joystick_open; |
261 | input->close = adc_joystick_close; |
262 | |
263 | joy->buffer = iio_channel_get_all_cb(dev, cb: adc_joystick_handle, |
264 | private: joy); |
265 | if (IS_ERR(ptr: joy->buffer)) { |
266 | dev_err(dev, "Unable to allocate callback buffer\n" ); |
267 | return PTR_ERR(ptr: joy->buffer); |
268 | } |
269 | |
270 | error = devm_add_action_or_reset(dev, adc_joystick_cleanup, |
271 | joy->buffer); |
272 | if (error) { |
273 | dev_err(dev, "Unable to add action\n" ); |
274 | return error; |
275 | } |
276 | } |
277 | |
278 | input_set_drvdata(dev: input, data: joy); |
279 | |
280 | error = input_register_device(input); |
281 | if (error) { |
282 | dev_err(dev, "Unable to register input device\n" ); |
283 | return error; |
284 | } |
285 | |
286 | return 0; |
287 | } |
288 | |
289 | static const struct of_device_id adc_joystick_of_match[] = { |
290 | { .compatible = "adc-joystick" , }, |
291 | { } |
292 | }; |
293 | MODULE_DEVICE_TABLE(of, adc_joystick_of_match); |
294 | |
295 | static struct platform_driver adc_joystick_driver = { |
296 | .driver = { |
297 | .name = "adc-joystick" , |
298 | .of_match_table = adc_joystick_of_match, |
299 | }, |
300 | .probe = adc_joystick_probe, |
301 | }; |
302 | module_platform_driver(adc_joystick_driver); |
303 | |
304 | MODULE_DESCRIPTION("Input driver for joysticks connected over ADC" ); |
305 | MODULE_AUTHOR("Artur Rojek <contact@artur-rojek.eu>" ); |
306 | MODULE_LICENSE("GPL" ); |
307 | |