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/mod_devicetable.h> 17 #include <linux/module.h> 18 #include <linux/platform_device.h> 19 #include <linux/property.h> 20 21 #define DRIVER_NAME "resistive-adc-touch" 22 #define GRTS_DEFAULT_PRESSURE_MIN 50000 23 #define GRTS_DEFAULT_PRESSURE_MAX 65535 24 #define GRTS_MAX_POS_MASK GENMASK(11, 0) 25 #define GRTS_MAX_CHANNELS 4 26 27 enum grts_ch_type { 28 GRTS_CH_X, 29 GRTS_CH_Y, 30 GRTS_CH_PRESSURE, 31 GRTS_CH_Z1, 32 GRTS_CH_Z2, 33 GRTS_CH_MAX = GRTS_CH_Z2 + 1 34 }; 35 36 /** 37 * struct grts_state - generic resistive touch screen information struct 38 * @x_plate_ohms: resistance of the X plate 39 * @pressure_min: number representing the minimum for the pressure 40 * @pressure: are we getting pressure info or not 41 * @iio_chans: list of channels acquired 42 * @iio_cb: iio_callback buffer for the data 43 * @input: the input device structure that we register 44 * @prop: touchscreen properties struct 45 * @ch_map: map of channels that are defined for the touchscreen 46 */ 47 struct grts_state { 48 u32 x_plate_ohms; 49 u32 pressure_min; 50 bool pressure; 51 struct iio_channel *iio_chans; 52 struct iio_cb_buffer *iio_cb; 53 struct input_dev *input; 54 struct touchscreen_properties prop; 55 u8 ch_map[GRTS_CH_MAX]; 56 }; 57 58 static int grts_cb(const void *data, void *private) 59 { 60 const u16 *touch_info = data; 61 struct grts_state *st = private; 62 unsigned int x, y, press = 0; 63 64 x = touch_info[st->ch_map[GRTS_CH_X]]; 65 y = touch_info[st->ch_map[GRTS_CH_Y]]; 66 67 if (st->ch_map[GRTS_CH_PRESSURE] < GRTS_MAX_CHANNELS) { 68 press = touch_info[st->ch_map[GRTS_CH_PRESSURE]]; 69 } else if (st->ch_map[GRTS_CH_Z1] < GRTS_MAX_CHANNELS) { 70 unsigned int z1 = touch_info[st->ch_map[GRTS_CH_Z1]]; 71 unsigned int z2 = touch_info[st->ch_map[GRTS_CH_Z2]]; 72 unsigned int Rt; 73 74 if (likely(x && z1)) { 75 Rt = z2; 76 Rt -= z1; 77 Rt *= st->x_plate_ohms; 78 Rt = DIV_ROUND_CLOSEST(Rt, 16); 79 Rt *= x; 80 Rt /= z1; 81 Rt = DIV_ROUND_CLOSEST(Rt, 256); 82 /* 83 * On increased pressure the resistance (Rt) is 84 * decreasing so, convert values to make it looks as 85 * real pressure. 86 */ 87 if (Rt < GRTS_DEFAULT_PRESSURE_MAX) 88 press = GRTS_DEFAULT_PRESSURE_MAX - Rt; 89 } 90 } 91 92 if ((!x && !y) || (st->pressure && (press < st->pressure_min))) { 93 /* report end of touch */ 94 input_report_key(st->input, BTN_TOUCH, 0); 95 input_sync(st->input); 96 return 0; 97 } 98 99 /* report proper touch to subsystem*/ 100 touchscreen_report_pos(st->input, &st->prop, x, y, false); 101 if (st->pressure) 102 input_report_abs(st->input, ABS_PRESSURE, press); 103 input_report_key(st->input, BTN_TOUCH, 1); 104 input_sync(st->input); 105 106 return 0; 107 } 108 109 static int grts_open(struct input_dev *dev) 110 { 111 int error; 112 struct grts_state *st = input_get_drvdata(dev); 113 114 error = iio_channel_start_all_cb(st->iio_cb); 115 if (error) { 116 dev_err(dev->dev.parent, "failed to start callback buffer.\n"); 117 return error; 118 } 119 return 0; 120 } 121 122 static void grts_close(struct input_dev *dev) 123 { 124 struct grts_state *st = input_get_drvdata(dev); 125 126 iio_channel_stop_all_cb(st->iio_cb); 127 } 128 129 static void grts_disable(void *data) 130 { 131 iio_channel_release_all_cb(data); 132 } 133 134 static int grts_map_channel(struct grts_state *st, struct device *dev, 135 enum grts_ch_type type, const char *name, 136 bool optional) 137 { 138 int idx; 139 140 idx = device_property_match_string(dev, "io-channel-names", name); 141 if (idx < 0) { 142 if (!optional) 143 return idx; 144 idx = GRTS_MAX_CHANNELS; 145 } else if (idx >= GRTS_MAX_CHANNELS) { 146 return -EOVERFLOW; 147 } 148 149 st->ch_map[type] = idx; 150 return 0; 151 } 152 153 static int grts_get_properties(struct grts_state *st, struct device *dev) 154 { 155 int error; 156 157 error = grts_map_channel(st, dev, GRTS_CH_X, "x", false); 158 if (error) 159 return error; 160 161 error = grts_map_channel(st, dev, GRTS_CH_Y, "y", false); 162 if (error) 163 return error; 164 165 /* pressure is optional */ 166 error = grts_map_channel(st, dev, GRTS_CH_PRESSURE, "pressure", true); 167 if (error) 168 return error; 169 170 if (st->ch_map[GRTS_CH_PRESSURE] < GRTS_MAX_CHANNELS) { 171 st->pressure = true; 172 return 0; 173 } 174 175 /* if no pressure is defined, try optional z1 + z2 */ 176 error = grts_map_channel(st, dev, GRTS_CH_Z1, "z1", true); 177 if (error) 178 return error; 179 180 if (st->ch_map[GRTS_CH_Z1] >= GRTS_MAX_CHANNELS) 181 return 0; 182 183 /* if z1 is provided z2 is not optional */ 184 error = grts_map_channel(st, dev, GRTS_CH_Z2, "z2", true); 185 if (error) 186 return error; 187 188 error = device_property_read_u32(dev, 189 "touchscreen-x-plate-ohms", 190 &st->x_plate_ohms); 191 if (error) { 192 dev_err(dev, "can't get touchscreen-x-plate-ohms property\n"); 193 return error; 194 } 195 196 st->pressure = true; 197 return 0; 198 } 199 200 static int grts_probe(struct platform_device *pdev) 201 { 202 struct grts_state *st; 203 struct input_dev *input; 204 struct device *dev = &pdev->dev; 205 int error; 206 207 st = devm_kzalloc(dev, sizeof(struct grts_state), GFP_KERNEL); 208 if (!st) 209 return -ENOMEM; 210 211 /* get the channels from IIO device */ 212 st->iio_chans = devm_iio_channel_get_all(dev); 213 if (IS_ERR(st->iio_chans)) 214 return dev_err_probe(dev, PTR_ERR(st->iio_chans), "can't get iio channels\n"); 215 216 if (!device_property_present(dev, "io-channel-names")) 217 return -ENODEV; 218 219 error = grts_get_properties(st, dev); 220 if (error) { 221 dev_err(dev, "Failed to parse properties\n"); 222 return error; 223 } 224 225 if (st->pressure) { 226 error = device_property_read_u32(dev, 227 "touchscreen-min-pressure", 228 &st->pressure_min); 229 if (error) { 230 dev_dbg(dev, "can't get touchscreen-min-pressure property.\n"); 231 st->pressure_min = GRTS_DEFAULT_PRESSURE_MIN; 232 } 233 } 234 235 input = devm_input_allocate_device(dev); 236 if (!input) { 237 dev_err(dev, "failed to allocate input device.\n"); 238 return -ENOMEM; 239 } 240 241 input->name = DRIVER_NAME; 242 input->id.bustype = BUS_HOST; 243 input->open = grts_open; 244 input->close = grts_close; 245 246 input_set_abs_params(input, ABS_X, 0, GRTS_MAX_POS_MASK - 1, 0, 0); 247 input_set_abs_params(input, ABS_Y, 0, GRTS_MAX_POS_MASK - 1, 0, 0); 248 if (st->pressure) 249 input_set_abs_params(input, ABS_PRESSURE, st->pressure_min, 250 GRTS_DEFAULT_PRESSURE_MAX, 0, 0); 251 252 input_set_capability(input, EV_KEY, BTN_TOUCH); 253 254 /* parse optional device tree properties */ 255 touchscreen_parse_properties(input, false, &st->prop); 256 257 st->input = input; 258 input_set_drvdata(input, st); 259 260 error = input_register_device(input); 261 if (error) { 262 dev_err(dev, "failed to register input device."); 263 return error; 264 } 265 266 st->iio_cb = iio_channel_get_all_cb(dev, grts_cb, st); 267 if (IS_ERR(st->iio_cb)) { 268 dev_err(dev, "failed to allocate callback buffer.\n"); 269 return PTR_ERR(st->iio_cb); 270 } 271 272 error = devm_add_action_or_reset(dev, grts_disable, st->iio_cb); 273 if (error) { 274 dev_err(dev, "failed to add disable action.\n"); 275 return error; 276 } 277 278 return 0; 279 } 280 281 static const struct of_device_id grts_of_match[] = { 282 { 283 .compatible = "resistive-adc-touch", 284 }, { 285 /* sentinel */ 286 }, 287 }; 288 289 MODULE_DEVICE_TABLE(of, grts_of_match); 290 291 static struct platform_driver grts_driver = { 292 .probe = grts_probe, 293 .driver = { 294 .name = DRIVER_NAME, 295 .of_match_table = grts_of_match, 296 }, 297 }; 298 299 module_platform_driver(grts_driver); 300 301 MODULE_AUTHOR("Eugen Hristev <eugen.hristev@microchip.com>"); 302 MODULE_DESCRIPTION("Generic ADC Resistive Touch Driver"); 303 MODULE_LICENSE("GPL v2"); 304