1 /* 2 * Toradex Colibri VF50 Touchscreen driver 3 * 4 * Copyright 2015 Toradex AG 5 * 6 * Originally authored by Stefan Agner for 3.0 kernel 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 */ 13 14 #include <linux/delay.h> 15 #include <linux/err.h> 16 #include <linux/gpio.h> 17 #include <linux/gpio/consumer.h> 18 #include <linux/iio/consumer.h> 19 #include <linux/iio/types.h> 20 #include <linux/input.h> 21 #include <linux/interrupt.h> 22 #include <linux/kernel.h> 23 #include <linux/module.h> 24 #include <linux/of.h> 25 #include <linux/pinctrl/consumer.h> 26 #include <linux/platform_device.h> 27 #include <linux/slab.h> 28 #include <linux/types.h> 29 30 #define DRIVER_NAME "colibri-vf50-ts" 31 32 #define VF_ADC_MAX ((1 << 12) - 1) 33 34 #define COLI_TOUCH_MIN_DELAY_US 1000 35 #define COLI_TOUCH_MAX_DELAY_US 2000 36 #define COLI_PULLUP_MIN_DELAY_US 10000 37 #define COLI_PULLUP_MAX_DELAY_US 11000 38 #define COLI_TOUCH_NO_OF_AVGS 5 39 #define COLI_TOUCH_REQ_ADC_CHAN 4 40 41 struct vf50_touch_device { 42 struct platform_device *pdev; 43 struct input_dev *ts_input; 44 struct iio_channel *channels; 45 struct gpio_desc *gpio_xp; 46 struct gpio_desc *gpio_xm; 47 struct gpio_desc *gpio_yp; 48 struct gpio_desc *gpio_ym; 49 int pen_irq; 50 int min_pressure; 51 bool stop_touchscreen; 52 }; 53 54 /* 55 * Enables given plates and measures touch parameters using ADC 56 */ 57 static int adc_ts_measure(struct iio_channel *channel, 58 struct gpio_desc *plate_p, struct gpio_desc *plate_m) 59 { 60 int i, value = 0, val = 0; 61 int error; 62 63 gpiod_set_value(plate_p, 1); 64 gpiod_set_value(plate_m, 1); 65 66 usleep_range(COLI_TOUCH_MIN_DELAY_US, COLI_TOUCH_MAX_DELAY_US); 67 68 for (i = 0; i < COLI_TOUCH_NO_OF_AVGS; i++) { 69 error = iio_read_channel_raw(channel, &val); 70 if (error < 0) { 71 value = error; 72 goto error_iio_read; 73 } 74 75 value += val; 76 } 77 78 value /= COLI_TOUCH_NO_OF_AVGS; 79 80 error_iio_read: 81 gpiod_set_value(plate_p, 0); 82 gpiod_set_value(plate_m, 0); 83 84 return value; 85 } 86 87 /* 88 * Enable touch detection using falling edge detection on XM 89 */ 90 static void vf50_ts_enable_touch_detection(struct vf50_touch_device *vf50_ts) 91 { 92 /* Enable plate YM (needs to be strong GND, high active) */ 93 gpiod_set_value(vf50_ts->gpio_ym, 1); 94 95 /* 96 * Let the platform mux to idle state in order to enable 97 * Pull-Up on GPIO 98 */ 99 pinctrl_pm_select_idle_state(&vf50_ts->pdev->dev); 100 101 /* Wait for the pull-up to be stable on high */ 102 usleep_range(COLI_PULLUP_MIN_DELAY_US, COLI_PULLUP_MAX_DELAY_US); 103 } 104 105 /* 106 * ADC touch screen sampling bottom half irq handler 107 */ 108 static irqreturn_t vf50_ts_irq_bh(int irq, void *private) 109 { 110 struct vf50_touch_device *vf50_ts = private; 111 struct device *dev = &vf50_ts->pdev->dev; 112 int val_x, val_y, val_z1, val_z2, val_p = 0; 113 bool discard_val_on_start = true; 114 115 /* Disable the touch detection plates */ 116 gpiod_set_value(vf50_ts->gpio_ym, 0); 117 118 /* Let the platform mux to default state in order to mux as ADC */ 119 pinctrl_pm_select_default_state(dev); 120 121 while (!vf50_ts->stop_touchscreen) { 122 /* X-Direction */ 123 val_x = adc_ts_measure(&vf50_ts->channels[0], 124 vf50_ts->gpio_xp, vf50_ts->gpio_xm); 125 if (val_x < 0) 126 break; 127 128 /* Y-Direction */ 129 val_y = adc_ts_measure(&vf50_ts->channels[1], 130 vf50_ts->gpio_yp, vf50_ts->gpio_ym); 131 if (val_y < 0) 132 break; 133 134 /* 135 * Touch pressure 136 * Measure on XP/YM 137 */ 138 val_z1 = adc_ts_measure(&vf50_ts->channels[2], 139 vf50_ts->gpio_yp, vf50_ts->gpio_xm); 140 if (val_z1 < 0) 141 break; 142 val_z2 = adc_ts_measure(&vf50_ts->channels[3], 143 vf50_ts->gpio_yp, vf50_ts->gpio_xm); 144 if (val_z2 < 0) 145 break; 146 147 /* Validate signal (avoid calculation using noise) */ 148 if (val_z1 > 64 && val_x > 64) { 149 /* 150 * Calculate resistance between the plates 151 * lower resistance means higher pressure 152 */ 153 int r_x = (1000 * val_x) / VF_ADC_MAX; 154 155 val_p = (r_x * val_z2) / val_z1 - r_x; 156 157 } else { 158 val_p = 2000; 159 } 160 161 val_p = 2000 - val_p; 162 dev_dbg(dev, 163 "Measured values: x: %d, y: %d, z1: %d, z2: %d, p: %d\n", 164 val_x, val_y, val_z1, val_z2, val_p); 165 166 /* 167 * If touch pressure is too low, stop measuring and reenable 168 * touch detection 169 */ 170 if (val_p < vf50_ts->min_pressure || val_p > 2000) 171 break; 172 173 /* 174 * The pressure may not be enough for the first x and the 175 * second y measurement, but, the pressure is ok when the 176 * driver is doing the third and fourth measurement. To 177 * take care of this, we drop the first measurement always. 178 */ 179 if (discard_val_on_start) { 180 discard_val_on_start = false; 181 } else { 182 /* 183 * Report touch position and sleep for 184 * the next measurement. 185 */ 186 input_report_abs(vf50_ts->ts_input, 187 ABS_X, VF_ADC_MAX - val_x); 188 input_report_abs(vf50_ts->ts_input, 189 ABS_Y, VF_ADC_MAX - val_y); 190 input_report_abs(vf50_ts->ts_input, 191 ABS_PRESSURE, val_p); 192 input_report_key(vf50_ts->ts_input, BTN_TOUCH, 1); 193 input_sync(vf50_ts->ts_input); 194 } 195 196 usleep_range(COLI_PULLUP_MIN_DELAY_US, 197 COLI_PULLUP_MAX_DELAY_US); 198 } 199 200 /* Report no more touch, re-enable touch detection */ 201 input_report_abs(vf50_ts->ts_input, ABS_PRESSURE, 0); 202 input_report_key(vf50_ts->ts_input, BTN_TOUCH, 0); 203 input_sync(vf50_ts->ts_input); 204 205 vf50_ts_enable_touch_detection(vf50_ts); 206 207 return IRQ_HANDLED; 208 } 209 210 static int vf50_ts_open(struct input_dev *dev_input) 211 { 212 struct vf50_touch_device *touchdev = input_get_drvdata(dev_input); 213 struct device *dev = &touchdev->pdev->dev; 214 215 dev_dbg(dev, "Input device %s opened, starting touch detection\n", 216 dev_input->name); 217 218 touchdev->stop_touchscreen = false; 219 220 /* Mux detection before request IRQ, wait for pull-up to settle */ 221 vf50_ts_enable_touch_detection(touchdev); 222 223 return 0; 224 } 225 226 static void vf50_ts_close(struct input_dev *dev_input) 227 { 228 struct vf50_touch_device *touchdev = input_get_drvdata(dev_input); 229 struct device *dev = &touchdev->pdev->dev; 230 231 touchdev->stop_touchscreen = true; 232 233 /* Make sure IRQ is not running past close */ 234 mb(); 235 synchronize_irq(touchdev->pen_irq); 236 237 gpiod_set_value(touchdev->gpio_ym, 0); 238 pinctrl_pm_select_default_state(dev); 239 240 dev_dbg(dev, "Input device %s closed, disable touch detection\n", 241 dev_input->name); 242 } 243 244 static int vf50_ts_get_gpiod(struct device *dev, struct gpio_desc **gpio_d, 245 const char *con_id, enum gpiod_flags flags) 246 { 247 int error; 248 249 *gpio_d = devm_gpiod_get(dev, con_id, flags); 250 if (IS_ERR(*gpio_d)) { 251 error = PTR_ERR(*gpio_d); 252 dev_err(dev, "Could not get gpio_%s %d\n", con_id, error); 253 return error; 254 } 255 256 return 0; 257 } 258 259 static void vf50_ts_channel_release(void *data) 260 { 261 struct iio_channel *channels = data; 262 263 iio_channel_release_all(channels); 264 } 265 266 static int vf50_ts_probe(struct platform_device *pdev) 267 { 268 struct input_dev *input; 269 struct iio_channel *channels; 270 struct device *dev = &pdev->dev; 271 struct vf50_touch_device *touchdev; 272 int num_adc_channels; 273 int error; 274 275 channels = iio_channel_get_all(dev); 276 if (IS_ERR(channels)) 277 return PTR_ERR(channels); 278 279 error = devm_add_action(dev, vf50_ts_channel_release, channels); 280 if (error) { 281 iio_channel_release_all(channels); 282 dev_err(dev, "Failed to register iio channel release action"); 283 return error; 284 } 285 286 num_adc_channels = 0; 287 while (channels[num_adc_channels].indio_dev) 288 num_adc_channels++; 289 290 if (num_adc_channels != COLI_TOUCH_REQ_ADC_CHAN) { 291 dev_err(dev, "Inadequate ADC channels specified\n"); 292 return -EINVAL; 293 } 294 295 touchdev = devm_kzalloc(dev, sizeof(*touchdev), GFP_KERNEL); 296 if (!touchdev) 297 return -ENOMEM; 298 299 touchdev->pdev = pdev; 300 touchdev->channels = channels; 301 302 error = of_property_read_u32(dev->of_node, "vf50-ts-min-pressure", 303 &touchdev->min_pressure); 304 if (error) 305 return error; 306 307 input = devm_input_allocate_device(dev); 308 if (!input) { 309 dev_err(dev, "Failed to allocate TS input device\n"); 310 return -ENOMEM; 311 } 312 313 input->name = DRIVER_NAME; 314 input->id.bustype = BUS_HOST; 315 input->dev.parent = dev; 316 input->open = vf50_ts_open; 317 input->close = vf50_ts_close; 318 319 input_set_capability(input, EV_KEY, BTN_TOUCH); 320 input_set_abs_params(input, ABS_X, 0, VF_ADC_MAX, 0, 0); 321 input_set_abs_params(input, ABS_Y, 0, VF_ADC_MAX, 0, 0); 322 input_set_abs_params(input, ABS_PRESSURE, 0, VF_ADC_MAX, 0, 0); 323 324 touchdev->ts_input = input; 325 input_set_drvdata(input, touchdev); 326 327 error = input_register_device(input); 328 if (error) { 329 dev_err(dev, "Failed to register input device\n"); 330 return error; 331 } 332 333 error = vf50_ts_get_gpiod(dev, &touchdev->gpio_xp, "xp", GPIOD_OUT_LOW); 334 if (error) 335 return error; 336 337 error = vf50_ts_get_gpiod(dev, &touchdev->gpio_xm, 338 "xm", GPIOD_OUT_LOW); 339 if (error) 340 return error; 341 342 error = vf50_ts_get_gpiod(dev, &touchdev->gpio_yp, "yp", GPIOD_OUT_LOW); 343 if (error) 344 return error; 345 346 error = vf50_ts_get_gpiod(dev, &touchdev->gpio_ym, "ym", GPIOD_OUT_LOW); 347 if (error) 348 return error; 349 350 touchdev->pen_irq = platform_get_irq(pdev, 0); 351 if (touchdev->pen_irq < 0) 352 return touchdev->pen_irq; 353 354 error = devm_request_threaded_irq(dev, touchdev->pen_irq, 355 NULL, vf50_ts_irq_bh, IRQF_ONESHOT, 356 "vf50 touch", touchdev); 357 if (error) { 358 dev_err(dev, "Failed to request IRQ %d: %d\n", 359 touchdev->pen_irq, error); 360 return error; 361 } 362 363 return 0; 364 } 365 366 static const struct of_device_id vf50_touch_of_match[] = { 367 { .compatible = "toradex,vf50-touchscreen", }, 368 { } 369 }; 370 MODULE_DEVICE_TABLE(of, vf50_touch_of_match); 371 372 static struct platform_driver vf50_touch_driver = { 373 .driver = { 374 .name = "toradex,vf50_touchctrl", 375 .of_match_table = vf50_touch_of_match, 376 }, 377 .probe = vf50_ts_probe, 378 }; 379 module_platform_driver(vf50_touch_driver); 380 381 MODULE_AUTHOR("Sanchayan Maity"); 382 MODULE_DESCRIPTION("Colibri VF50 Touchscreen driver"); 383 MODULE_LICENSE("GPL"); 384