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