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