1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Touchscreen driver for Dialog Semiconductor DA9034 4 * 5 * Copyright (C) 2006-2008 Marvell International Ltd. 6 * Fengwei Yin <fengwei.yin@marvell.com> 7 * Bin Yang <bin.yang@marvell.com> 8 * Eric Miao <eric.miao@marvell.com> 9 */ 10 11 #include <linux/module.h> 12 #include <linux/kernel.h> 13 #include <linux/delay.h> 14 #include <linux/platform_device.h> 15 #include <linux/input.h> 16 #include <linux/workqueue.h> 17 #include <linux/mfd/da903x.h> 18 #include <linux/slab.h> 19 20 #define DA9034_MANUAL_CTRL 0x50 21 #define DA9034_LDO_ADC_EN (1 << 4) 22 23 #define DA9034_AUTO_CTRL1 0x51 24 25 #define DA9034_AUTO_CTRL2 0x52 26 #define DA9034_AUTO_TSI_EN (1 << 3) 27 #define DA9034_PEN_DETECT (1 << 4) 28 29 #define DA9034_TSI_CTRL1 0x53 30 #define DA9034_TSI_CTRL2 0x54 31 #define DA9034_TSI_X_MSB 0x6c 32 #define DA9034_TSI_Y_MSB 0x6d 33 #define DA9034_TSI_XY_LSB 0x6e 34 35 enum { 36 STATE_IDLE, /* wait for pendown */ 37 STATE_BUSY, /* TSI busy sampling */ 38 STATE_STOP, /* sample available */ 39 STATE_WAIT, /* Wait to start next sample */ 40 }; 41 42 enum { 43 EVENT_PEN_DOWN, 44 EVENT_PEN_UP, 45 EVENT_TSI_READY, 46 EVENT_TIMEDOUT, 47 }; 48 49 struct da9034_touch { 50 struct device *da9034_dev; 51 struct input_dev *input_dev; 52 53 struct delayed_work tsi_work; 54 struct notifier_block notifier; 55 56 int state; 57 58 int interval_ms; 59 int x_inverted; 60 int y_inverted; 61 62 int last_x; 63 int last_y; 64 }; 65 66 static inline int is_pen_down(struct da9034_touch *touch) 67 { 68 return da903x_query_status(touch->da9034_dev, DA9034_STATUS_PEN_DOWN); 69 } 70 71 static inline int detect_pen_down(struct da9034_touch *touch, int on) 72 { 73 if (on) 74 return da903x_set_bits(touch->da9034_dev, 75 DA9034_AUTO_CTRL2, DA9034_PEN_DETECT); 76 else 77 return da903x_clr_bits(touch->da9034_dev, 78 DA9034_AUTO_CTRL2, DA9034_PEN_DETECT); 79 } 80 81 static int read_tsi(struct da9034_touch *touch) 82 { 83 uint8_t _x, _y, _v; 84 int ret; 85 86 ret = da903x_read(touch->da9034_dev, DA9034_TSI_X_MSB, &_x); 87 if (ret) 88 return ret; 89 90 ret = da903x_read(touch->da9034_dev, DA9034_TSI_Y_MSB, &_y); 91 if (ret) 92 return ret; 93 94 ret = da903x_read(touch->da9034_dev, DA9034_TSI_XY_LSB, &_v); 95 if (ret) 96 return ret; 97 98 touch->last_x = ((_x << 2) & 0x3fc) | (_v & 0x3); 99 touch->last_y = ((_y << 2) & 0x3fc) | ((_v & 0xc) >> 2); 100 101 return 0; 102 } 103 104 static inline int start_tsi(struct da9034_touch *touch) 105 { 106 return da903x_set_bits(touch->da9034_dev, 107 DA9034_AUTO_CTRL2, DA9034_AUTO_TSI_EN); 108 } 109 110 static inline int stop_tsi(struct da9034_touch *touch) 111 { 112 return da903x_clr_bits(touch->da9034_dev, 113 DA9034_AUTO_CTRL2, DA9034_AUTO_TSI_EN); 114 } 115 116 static inline void report_pen_down(struct da9034_touch *touch) 117 { 118 int x = touch->last_x; 119 int y = touch->last_y; 120 121 x &= 0xfff; 122 if (touch->x_inverted) 123 x = 1024 - x; 124 y &= 0xfff; 125 if (touch->y_inverted) 126 y = 1024 - y; 127 128 input_report_abs(touch->input_dev, ABS_X, x); 129 input_report_abs(touch->input_dev, ABS_Y, y); 130 input_report_key(touch->input_dev, BTN_TOUCH, 1); 131 132 input_sync(touch->input_dev); 133 } 134 135 static inline void report_pen_up(struct da9034_touch *touch) 136 { 137 input_report_key(touch->input_dev, BTN_TOUCH, 0); 138 input_sync(touch->input_dev); 139 } 140 141 static void da9034_event_handler(struct da9034_touch *touch, int event) 142 { 143 int err; 144 145 switch (touch->state) { 146 case STATE_IDLE: 147 if (event != EVENT_PEN_DOWN) 148 break; 149 150 /* Enable auto measurement of the TSI, this will 151 * automatically disable pen down detection 152 */ 153 err = start_tsi(touch); 154 if (err) 155 goto err_reset; 156 157 touch->state = STATE_BUSY; 158 break; 159 160 case STATE_BUSY: 161 if (event != EVENT_TSI_READY) 162 break; 163 164 err = read_tsi(touch); 165 if (err) 166 goto err_reset; 167 168 /* Disable auto measurement of the TSI, so that 169 * pen down status will be available 170 */ 171 err = stop_tsi(touch); 172 if (err) 173 goto err_reset; 174 175 touch->state = STATE_STOP; 176 177 /* FIXME: PEN_{UP/DOWN} events are expected to be 178 * available by stopping TSI, but this is found not 179 * always true, delay and simulate such an event 180 * here is more reliable 181 */ 182 mdelay(1); 183 da9034_event_handler(touch, 184 is_pen_down(touch) ? EVENT_PEN_DOWN : 185 EVENT_PEN_UP); 186 break; 187 188 case STATE_STOP: 189 if (event == EVENT_PEN_DOWN) { 190 report_pen_down(touch); 191 schedule_delayed_work(&touch->tsi_work, 192 msecs_to_jiffies(touch->interval_ms)); 193 touch->state = STATE_WAIT; 194 } 195 196 if (event == EVENT_PEN_UP) { 197 report_pen_up(touch); 198 touch->state = STATE_IDLE; 199 } 200 break; 201 202 case STATE_WAIT: 203 if (event != EVENT_TIMEDOUT) 204 break; 205 206 if (is_pen_down(touch)) { 207 start_tsi(touch); 208 touch->state = STATE_BUSY; 209 } else { 210 report_pen_up(touch); 211 touch->state = STATE_IDLE; 212 } 213 break; 214 } 215 return; 216 217 err_reset: 218 touch->state = STATE_IDLE; 219 stop_tsi(touch); 220 detect_pen_down(touch, 1); 221 } 222 223 static void da9034_tsi_work(struct work_struct *work) 224 { 225 struct da9034_touch *touch = 226 container_of(work, struct da9034_touch, tsi_work.work); 227 228 da9034_event_handler(touch, EVENT_TIMEDOUT); 229 } 230 231 static int da9034_touch_notifier(struct notifier_block *nb, 232 unsigned long event, void *data) 233 { 234 struct da9034_touch *touch = 235 container_of(nb, struct da9034_touch, notifier); 236 237 if (event & DA9034_EVENT_TSI_READY) 238 da9034_event_handler(touch, EVENT_TSI_READY); 239 240 if ((event & DA9034_EVENT_PEN_DOWN) && touch->state == STATE_IDLE) 241 da9034_event_handler(touch, EVENT_PEN_DOWN); 242 243 return 0; 244 } 245 246 static int da9034_touch_open(struct input_dev *dev) 247 { 248 struct da9034_touch *touch = input_get_drvdata(dev); 249 int ret; 250 251 ret = da903x_register_notifier(touch->da9034_dev, &touch->notifier, 252 DA9034_EVENT_PEN_DOWN | DA9034_EVENT_TSI_READY); 253 if (ret) 254 return -EBUSY; 255 256 /* Enable ADC LDO */ 257 ret = da903x_set_bits(touch->da9034_dev, 258 DA9034_MANUAL_CTRL, DA9034_LDO_ADC_EN); 259 if (ret) 260 return ret; 261 262 /* TSI_DELAY: 3 slots, TSI_SKIP: 3 slots */ 263 ret = da903x_write(touch->da9034_dev, DA9034_TSI_CTRL1, 0x1b); 264 if (ret) 265 return ret; 266 267 ret = da903x_write(touch->da9034_dev, DA9034_TSI_CTRL2, 0x00); 268 if (ret) 269 return ret; 270 271 touch->state = STATE_IDLE; 272 detect_pen_down(touch, 1); 273 274 return 0; 275 } 276 277 static void da9034_touch_close(struct input_dev *dev) 278 { 279 struct da9034_touch *touch = input_get_drvdata(dev); 280 281 da903x_unregister_notifier(touch->da9034_dev, &touch->notifier, 282 DA9034_EVENT_PEN_DOWN | DA9034_EVENT_TSI_READY); 283 284 cancel_delayed_work_sync(&touch->tsi_work); 285 286 touch->state = STATE_IDLE; 287 stop_tsi(touch); 288 detect_pen_down(touch, 0); 289 290 /* Disable ADC LDO */ 291 da903x_clr_bits(touch->da9034_dev, 292 DA9034_MANUAL_CTRL, DA9034_LDO_ADC_EN); 293 } 294 295 296 static int da9034_touch_probe(struct platform_device *pdev) 297 { 298 struct da9034_touch_pdata *pdata = dev_get_platdata(&pdev->dev); 299 struct da9034_touch *touch; 300 struct input_dev *input_dev; 301 int error; 302 303 touch = devm_kzalloc(&pdev->dev, sizeof(struct da9034_touch), 304 GFP_KERNEL); 305 if (!touch) { 306 dev_err(&pdev->dev, "failed to allocate driver data\n"); 307 return -ENOMEM; 308 } 309 310 touch->da9034_dev = pdev->dev.parent; 311 312 if (pdata) { 313 touch->interval_ms = pdata->interval_ms; 314 touch->x_inverted = pdata->x_inverted; 315 touch->y_inverted = pdata->y_inverted; 316 } else { 317 /* fallback into default */ 318 touch->interval_ms = 10; 319 } 320 321 INIT_DELAYED_WORK(&touch->tsi_work, da9034_tsi_work); 322 touch->notifier.notifier_call = da9034_touch_notifier; 323 324 input_dev = devm_input_allocate_device(&pdev->dev); 325 if (!input_dev) { 326 dev_err(&pdev->dev, "failed to allocate input device\n"); 327 return -ENOMEM; 328 } 329 330 input_dev->name = pdev->name; 331 input_dev->open = da9034_touch_open; 332 input_dev->close = da9034_touch_close; 333 input_dev->dev.parent = &pdev->dev; 334 335 __set_bit(EV_ABS, input_dev->evbit); 336 __set_bit(ABS_X, input_dev->absbit); 337 __set_bit(ABS_Y, input_dev->absbit); 338 input_set_abs_params(input_dev, ABS_X, 0, 1023, 0, 0); 339 input_set_abs_params(input_dev, ABS_Y, 0, 1023, 0, 0); 340 341 __set_bit(EV_KEY, input_dev->evbit); 342 __set_bit(BTN_TOUCH, input_dev->keybit); 343 344 touch->input_dev = input_dev; 345 input_set_drvdata(input_dev, touch); 346 347 error = input_register_device(input_dev); 348 if (error) 349 return error; 350 351 return 0; 352 } 353 354 static struct platform_driver da9034_touch_driver = { 355 .driver = { 356 .name = "da9034-touch", 357 }, 358 .probe = da9034_touch_probe, 359 }; 360 module_platform_driver(da9034_touch_driver); 361 362 MODULE_DESCRIPTION("Touchscreen driver for Dialog Semiconductor DA9034"); 363 MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>, Bin Yang <bin.yang@marvell.com>"); 364 MODULE_LICENSE("GPL"); 365 MODULE_ALIAS("platform:da9034-touch"); 366