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