ucb1x00-ts.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Touchscreen driver for UCB1x00-based touchscreens
  4. *
  5. * Copyright (C) 2001 Russell King, All Rights Reserved.
  6. * Copyright (C) 2005 Pavel Machek
  7. *
  8. * 21-Jan-2002 <jco@ict.es> :
  9. *
  10. * Added support for synchronous A/D mode. This mode is useful to
  11. * avoid noise induced in the touchpanel by the LCD, provided that
  12. * the UCB1x00 has a valid LCD sync signal routed to its ADCSYNC pin.
  13. * It is important to note that the signal connected to the ADCSYNC
  14. * pin should provide pulses even when the LCD is blanked, otherwise
  15. * a pen touch needed to unblank the LCD will never be read.
  16. */
  17. #include <linux/module.h>
  18. #include <linux/moduleparam.h>
  19. #include <linux/init.h>
  20. #include <linux/interrupt.h>
  21. #include <linux/sched.h>
  22. #include <linux/spinlock.h>
  23. #include <linux/completion.h>
  24. #include <linux/delay.h>
  25. #include <linux/string.h>
  26. #include <linux/input.h>
  27. #include <linux/device.h>
  28. #include <linux/freezer.h>
  29. #include <linux/slab.h>
  30. #include <linux/kthread.h>
  31. #include <linux/mfd/ucb1x00.h>
  32. #include <mach/collie.h>
  33. #include <asm/mach-types.h>
  34. struct ucb1x00_ts {
  35. struct input_dev *idev;
  36. struct ucb1x00 *ucb;
  37. spinlock_t irq_lock;
  38. unsigned irq_disabled;
  39. wait_queue_head_t irq_wait;
  40. struct task_struct *rtask;
  41. u16 x_res;
  42. u16 y_res;
  43. unsigned int adcsync:1;
  44. };
  45. static int adcsync;
  46. static inline void ucb1x00_ts_evt_add(struct ucb1x00_ts *ts, u16 pressure, u16 x, u16 y)
  47. {
  48. struct input_dev *idev = ts->idev;
  49. input_report_abs(idev, ABS_X, x);
  50. input_report_abs(idev, ABS_Y, y);
  51. input_report_abs(idev, ABS_PRESSURE, pressure);
  52. input_report_key(idev, BTN_TOUCH, 1);
  53. input_sync(idev);
  54. }
  55. static inline void ucb1x00_ts_event_release(struct ucb1x00_ts *ts)
  56. {
  57. struct input_dev *idev = ts->idev;
  58. input_report_abs(idev, ABS_PRESSURE, 0);
  59. input_report_key(idev, BTN_TOUCH, 0);
  60. input_sync(idev);
  61. }
  62. /*
  63. * Switch to interrupt mode.
  64. */
  65. static inline void ucb1x00_ts_mode_int(struct ucb1x00_ts *ts)
  66. {
  67. ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
  68. UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW |
  69. UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND |
  70. UCB_TS_CR_MODE_INT);
  71. }
  72. /*
  73. * Switch to pressure mode, and read pressure. We don't need to wait
  74. * here, since both plates are being driven.
  75. */
  76. static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts *ts)
  77. {
  78. if (machine_is_collie()) {
  79. ucb1x00_io_write(ts->ucb, COLLIE_TC35143_GPIO_TBL_CHK, 0);
  80. ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
  81. UCB_TS_CR_TSPX_POW | UCB_TS_CR_TSMX_POW |
  82. UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA);
  83. udelay(55);
  84. return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_AD2, ts->adcsync);
  85. } else {
  86. ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
  87. UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW |
  88. UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND |
  89. UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
  90. return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync);
  91. }
  92. }
  93. /*
  94. * Switch to X position mode and measure Y plate. We switch the plate
  95. * configuration in pressure mode, then switch to position mode. This
  96. * gives a faster response time. Even so, we need to wait about 55us
  97. * for things to stabilise.
  98. */
  99. static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts *ts)
  100. {
  101. if (machine_is_collie())
  102. ucb1x00_io_write(ts->ucb, 0, COLLIE_TC35143_GPIO_TBL_CHK);
  103. else {
  104. ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
  105. UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
  106. UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
  107. ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
  108. UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
  109. UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
  110. }
  111. ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
  112. UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
  113. UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA);
  114. udelay(55);
  115. return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync);
  116. }
  117. /*
  118. * Switch to Y position mode and measure X plate. We switch the plate
  119. * configuration in pressure mode, then switch to position mode. This
  120. * gives a faster response time. Even so, we need to wait about 55us
  121. * for things to stabilise.
  122. */
  123. static inline unsigned int ucb1x00_ts_read_ypos(struct ucb1x00_ts *ts)
  124. {
  125. if (machine_is_collie())
  126. ucb1x00_io_write(ts->ucb, 0, COLLIE_TC35143_GPIO_TBL_CHK);
  127. else {
  128. ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
  129. UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
  130. UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
  131. ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
  132. UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
  133. UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
  134. }
  135. ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
  136. UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
  137. UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA);
  138. udelay(55);
  139. return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPX, ts->adcsync);
  140. }
  141. /*
  142. * Switch to X plate resistance mode. Set MX to ground, PX to
  143. * supply. Measure current.
  144. */
  145. static inline unsigned int ucb1x00_ts_read_xres(struct ucb1x00_ts *ts)
  146. {
  147. ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
  148. UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
  149. UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
  150. return ucb1x00_adc_read(ts->ucb, 0, ts->adcsync);
  151. }
  152. /*
  153. * Switch to Y plate resistance mode. Set MY to ground, PY to
  154. * supply. Measure current.
  155. */
  156. static inline unsigned int ucb1x00_ts_read_yres(struct ucb1x00_ts *ts)
  157. {
  158. ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
  159. UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
  160. UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
  161. return ucb1x00_adc_read(ts->ucb, 0, ts->adcsync);
  162. }
  163. static inline int ucb1x00_ts_pen_down(struct ucb1x00_ts *ts)
  164. {
  165. unsigned int val = ucb1x00_reg_read(ts->ucb, UCB_TS_CR);
  166. if (machine_is_collie())
  167. return (!(val & (UCB_TS_CR_TSPX_LOW)));
  168. else
  169. return (val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW));
  170. }
  171. /*
  172. * This is a RT kernel thread that handles the ADC accesses
  173. * (mainly so we can use semaphores in the UCB1200 core code
  174. * to serialise accesses to the ADC).
  175. */
  176. static int ucb1x00_thread(void *_ts)
  177. {
  178. struct ucb1x00_ts *ts = _ts;
  179. DECLARE_WAITQUEUE(wait, current);
  180. bool frozen, ignore = false;
  181. int valid = 0;
  182. set_freezable();
  183. add_wait_queue(&ts->irq_wait, &wait);
  184. while (!kthread_freezable_should_stop(&frozen)) {
  185. unsigned int x, y, p;
  186. signed long timeout;
  187. if (frozen)
  188. ignore = true;
  189. ucb1x00_adc_enable(ts->ucb);
  190. x = ucb1x00_ts_read_xpos(ts);
  191. y = ucb1x00_ts_read_ypos(ts);
  192. p = ucb1x00_ts_read_pressure(ts);
  193. /*
  194. * Switch back to interrupt mode.
  195. */
  196. ucb1x00_ts_mode_int(ts);
  197. ucb1x00_adc_disable(ts->ucb);
  198. msleep(10);
  199. ucb1x00_enable(ts->ucb);
  200. if (ucb1x00_ts_pen_down(ts)) {
  201. set_current_state(TASK_INTERRUPTIBLE);
  202. spin_lock_irq(&ts->irq_lock);
  203. if (ts->irq_disabled) {
  204. ts->irq_disabled = 0;
  205. enable_irq(ts->ucb->irq_base + UCB_IRQ_TSPX);
  206. }
  207. spin_unlock_irq(&ts->irq_lock);
  208. ucb1x00_disable(ts->ucb);
  209. /*
  210. * If we spat out a valid sample set last time,
  211. * spit out a "pen off" sample here.
  212. */
  213. if (valid) {
  214. ucb1x00_ts_event_release(ts);
  215. valid = 0;
  216. }
  217. timeout = MAX_SCHEDULE_TIMEOUT;
  218. } else {
  219. ucb1x00_disable(ts->ucb);
  220. /*
  221. * Filtering is policy. Policy belongs in user
  222. * space. We therefore leave it to user space
  223. * to do any filtering they please.
  224. */
  225. if (!ignore) {
  226. ucb1x00_ts_evt_add(ts, p, x, y);
  227. valid = 1;
  228. }
  229. set_current_state(TASK_INTERRUPTIBLE);
  230. timeout = HZ / 100;
  231. }
  232. schedule_timeout(timeout);
  233. }
  234. remove_wait_queue(&ts->irq_wait, &wait);
  235. ts->rtask = NULL;
  236. return 0;
  237. }
  238. /*
  239. * We only detect touch screen _touches_ with this interrupt
  240. * handler, and even then we just schedule our task.
  241. */
  242. static irqreturn_t ucb1x00_ts_irq(int irq, void *id)
  243. {
  244. struct ucb1x00_ts *ts = id;
  245. spin_lock(&ts->irq_lock);
  246. ts->irq_disabled = 1;
  247. disable_irq_nosync(ts->ucb->irq_base + UCB_IRQ_TSPX);
  248. spin_unlock(&ts->irq_lock);
  249. wake_up(&ts->irq_wait);
  250. return IRQ_HANDLED;
  251. }
  252. static int ucb1x00_ts_open(struct input_dev *idev)
  253. {
  254. struct ucb1x00_ts *ts = input_get_drvdata(idev);
  255. unsigned long flags = 0;
  256. int ret = 0;
  257. BUG_ON(ts->rtask);
  258. if (machine_is_collie())
  259. flags = IRQF_TRIGGER_RISING;
  260. else
  261. flags = IRQF_TRIGGER_FALLING;
  262. ts->irq_disabled = 0;
  263. init_waitqueue_head(&ts->irq_wait);
  264. ret = request_irq(ts->ucb->irq_base + UCB_IRQ_TSPX, ucb1x00_ts_irq,
  265. flags, "ucb1x00-ts", ts);
  266. if (ret < 0)
  267. goto out;
  268. /*
  269. * If we do this at all, we should allow the user to
  270. * measure and read the X and Y resistance at any time.
  271. */
  272. ucb1x00_adc_enable(ts->ucb);
  273. ts->x_res = ucb1x00_ts_read_xres(ts);
  274. ts->y_res = ucb1x00_ts_read_yres(ts);
  275. ucb1x00_adc_disable(ts->ucb);
  276. ts->rtask = kthread_run(ucb1x00_thread, ts, "ktsd");
  277. if (!IS_ERR(ts->rtask)) {
  278. ret = 0;
  279. } else {
  280. free_irq(ts->ucb->irq_base + UCB_IRQ_TSPX, ts);
  281. ts->rtask = NULL;
  282. ret = -EFAULT;
  283. }
  284. out:
  285. return ret;
  286. }
  287. /*
  288. * Release touchscreen resources. Disable IRQs.
  289. */
  290. static void ucb1x00_ts_close(struct input_dev *idev)
  291. {
  292. struct ucb1x00_ts *ts = input_get_drvdata(idev);
  293. if (ts->rtask)
  294. kthread_stop(ts->rtask);
  295. ucb1x00_enable(ts->ucb);
  296. free_irq(ts->ucb->irq_base + UCB_IRQ_TSPX, ts);
  297. ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 0);
  298. ucb1x00_disable(ts->ucb);
  299. }
  300. /*
  301. * Initialisation.
  302. */
  303. static int ucb1x00_ts_add(struct ucb1x00_dev *dev)
  304. {
  305. struct ucb1x00_ts *ts;
  306. struct input_dev *idev;
  307. int err;
  308. ts = kzalloc(sizeof(struct ucb1x00_ts), GFP_KERNEL);
  309. idev = input_allocate_device();
  310. if (!ts || !idev) {
  311. err = -ENOMEM;
  312. goto fail;
  313. }
  314. ts->ucb = dev->ucb;
  315. ts->idev = idev;
  316. ts->adcsync = adcsync ? UCB_SYNC : UCB_NOSYNC;
  317. spin_lock_init(&ts->irq_lock);
  318. idev->name = "Touchscreen panel";
  319. idev->id.product = ts->ucb->id;
  320. idev->open = ucb1x00_ts_open;
  321. idev->close = ucb1x00_ts_close;
  322. idev->dev.parent = &ts->ucb->dev;
  323. idev->evbit[0] = BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY);
  324. idev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
  325. input_set_drvdata(idev, ts);
  326. ucb1x00_adc_enable(ts->ucb);
  327. ts->x_res = ucb1x00_ts_read_xres(ts);
  328. ts->y_res = ucb1x00_ts_read_yres(ts);
  329. ucb1x00_adc_disable(ts->ucb);
  330. input_set_abs_params(idev, ABS_X, 0, ts->x_res, 0, 0);
  331. input_set_abs_params(idev, ABS_Y, 0, ts->y_res, 0, 0);
  332. input_set_abs_params(idev, ABS_PRESSURE, 0, 0, 0, 0);
  333. err = input_register_device(idev);
  334. if (err)
  335. goto fail;
  336. dev->priv = ts;
  337. return 0;
  338. fail:
  339. input_free_device(idev);
  340. kfree(ts);
  341. return err;
  342. }
  343. static void ucb1x00_ts_remove(struct ucb1x00_dev *dev)
  344. {
  345. struct ucb1x00_ts *ts = dev->priv;
  346. input_unregister_device(ts->idev);
  347. kfree(ts);
  348. }
  349. static struct ucb1x00_driver ucb1x00_ts_driver = {
  350. .add = ucb1x00_ts_add,
  351. .remove = ucb1x00_ts_remove,
  352. };
  353. static int __init ucb1x00_ts_init(void)
  354. {
  355. return ucb1x00_register_driver(&ucb1x00_ts_driver);
  356. }
  357. static void __exit ucb1x00_ts_exit(void)
  358. {
  359. ucb1x00_unregister_driver(&ucb1x00_ts_driver);
  360. }
  361. module_param(adcsync, int, 0444);
  362. module_init(ucb1x00_ts_init);
  363. module_exit(ucb1x00_ts_exit);
  364. MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
  365. MODULE_DESCRIPTION("UCB1x00 touchscreen driver");
  366. MODULE_LICENSE("GPL");