davinci_keyscan.c 8.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * DaVinci Key Scan Driver for TI platforms
  4. *
  5. * Copyright (C) 2009 Texas Instruments, Inc
  6. *
  7. * Author: Miguel Aguilar <miguel.aguilar@ridgerun.com>
  8. *
  9. * Initial Code: Sandeep Paulraj <s-paulraj@ti.com>
  10. */
  11. #include <linux/module.h>
  12. #include <linux/init.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/types.h>
  15. #include <linux/input.h>
  16. #include <linux/kernel.h>
  17. #include <linux/delay.h>
  18. #include <linux/platform_device.h>
  19. #include <linux/errno.h>
  20. #include <linux/slab.h>
  21. #include <linux/platform_data/keyscan-davinci.h>
  22. /* Key scan registers */
  23. #define DAVINCI_KEYSCAN_KEYCTRL 0x0000
  24. #define DAVINCI_KEYSCAN_INTENA 0x0004
  25. #define DAVINCI_KEYSCAN_INTFLAG 0x0008
  26. #define DAVINCI_KEYSCAN_INTCLR 0x000c
  27. #define DAVINCI_KEYSCAN_STRBWIDTH 0x0010
  28. #define DAVINCI_KEYSCAN_INTERVAL 0x0014
  29. #define DAVINCI_KEYSCAN_CONTTIME 0x0018
  30. #define DAVINCI_KEYSCAN_CURRENTST 0x001c
  31. #define DAVINCI_KEYSCAN_PREVSTATE 0x0020
  32. #define DAVINCI_KEYSCAN_EMUCTRL 0x0024
  33. #define DAVINCI_KEYSCAN_IODFTCTRL 0x002c
  34. /* Key Control Register (KEYCTRL) */
  35. #define DAVINCI_KEYSCAN_KEYEN 0x00000001
  36. #define DAVINCI_KEYSCAN_PREVMODE 0x00000002
  37. #define DAVINCI_KEYSCAN_CHATOFF 0x00000004
  38. #define DAVINCI_KEYSCAN_AUTODET 0x00000008
  39. #define DAVINCI_KEYSCAN_SCANMODE 0x00000010
  40. #define DAVINCI_KEYSCAN_OUTTYPE 0x00000020
  41. /* Masks for the interrupts */
  42. #define DAVINCI_KEYSCAN_INT_CONT 0x00000008
  43. #define DAVINCI_KEYSCAN_INT_OFF 0x00000004
  44. #define DAVINCI_KEYSCAN_INT_ON 0x00000002
  45. #define DAVINCI_KEYSCAN_INT_CHANGE 0x00000001
  46. #define DAVINCI_KEYSCAN_INT_ALL 0x0000000f
  47. struct davinci_ks {
  48. struct input_dev *input;
  49. struct davinci_ks_platform_data *pdata;
  50. int irq;
  51. void __iomem *base;
  52. resource_size_t pbase;
  53. size_t base_size;
  54. unsigned short keymap[];
  55. };
  56. /* Initializing the kp Module */
  57. static int __init davinci_ks_initialize(struct davinci_ks *davinci_ks)
  58. {
  59. struct device *dev = &davinci_ks->input->dev;
  60. struct davinci_ks_platform_data *pdata = davinci_ks->pdata;
  61. u32 matrix_ctrl;
  62. /* Enable all interrupts */
  63. __raw_writel(DAVINCI_KEYSCAN_INT_ALL,
  64. davinci_ks->base + DAVINCI_KEYSCAN_INTENA);
  65. /* Clear interrupts if any */
  66. __raw_writel(DAVINCI_KEYSCAN_INT_ALL,
  67. davinci_ks->base + DAVINCI_KEYSCAN_INTCLR);
  68. /* Setup the scan period = strobe + interval */
  69. __raw_writel(pdata->strobe,
  70. davinci_ks->base + DAVINCI_KEYSCAN_STRBWIDTH);
  71. __raw_writel(pdata->interval,
  72. davinci_ks->base + DAVINCI_KEYSCAN_INTERVAL);
  73. __raw_writel(0x01,
  74. davinci_ks->base + DAVINCI_KEYSCAN_CONTTIME);
  75. /* Define matrix type */
  76. switch (pdata->matrix_type) {
  77. case DAVINCI_KEYSCAN_MATRIX_4X4:
  78. matrix_ctrl = 0;
  79. break;
  80. case DAVINCI_KEYSCAN_MATRIX_5X3:
  81. matrix_ctrl = (1 << 6);
  82. break;
  83. default:
  84. dev_err(dev->parent, "wrong matrix type\n");
  85. return -EINVAL;
  86. }
  87. /* Enable key scan module and set matrix type */
  88. __raw_writel(DAVINCI_KEYSCAN_AUTODET | DAVINCI_KEYSCAN_KEYEN |
  89. matrix_ctrl, davinci_ks->base + DAVINCI_KEYSCAN_KEYCTRL);
  90. return 0;
  91. }
  92. static irqreturn_t davinci_ks_interrupt(int irq, void *dev_id)
  93. {
  94. struct davinci_ks *davinci_ks = dev_id;
  95. struct device *dev = &davinci_ks->input->dev;
  96. unsigned short *keymap = davinci_ks->keymap;
  97. int keymapsize = davinci_ks->pdata->keymapsize;
  98. u32 prev_status, new_status, changed;
  99. bool release;
  100. int keycode = KEY_UNKNOWN;
  101. int i;
  102. /* Disable interrupt */
  103. __raw_writel(0x0, davinci_ks->base + DAVINCI_KEYSCAN_INTENA);
  104. /* Reading previous and new status of the key scan */
  105. prev_status = __raw_readl(davinci_ks->base + DAVINCI_KEYSCAN_PREVSTATE);
  106. new_status = __raw_readl(davinci_ks->base + DAVINCI_KEYSCAN_CURRENTST);
  107. changed = prev_status ^ new_status;
  108. if (changed) {
  109. /*
  110. * It goes through all bits in 'changed' to ensure
  111. * that no key changes are being missed
  112. */
  113. for (i = 0 ; i < keymapsize; i++) {
  114. if ((changed>>i) & 0x1) {
  115. keycode = keymap[i];
  116. release = (new_status >> i) & 0x1;
  117. dev_dbg(dev->parent, "key %d %s\n", keycode,
  118. release ? "released" : "pressed");
  119. input_report_key(davinci_ks->input, keycode,
  120. !release);
  121. input_sync(davinci_ks->input);
  122. }
  123. }
  124. /* Clearing interrupt */
  125. __raw_writel(DAVINCI_KEYSCAN_INT_ALL,
  126. davinci_ks->base + DAVINCI_KEYSCAN_INTCLR);
  127. }
  128. /* Enable interrupts */
  129. __raw_writel(0x1, davinci_ks->base + DAVINCI_KEYSCAN_INTENA);
  130. return IRQ_HANDLED;
  131. }
  132. static int __init davinci_ks_probe(struct platform_device *pdev)
  133. {
  134. struct davinci_ks *davinci_ks;
  135. struct input_dev *key_dev;
  136. struct resource *res, *mem;
  137. struct device *dev = &pdev->dev;
  138. struct davinci_ks_platform_data *pdata = dev_get_platdata(dev);
  139. int error, i;
  140. if (pdata->device_enable) {
  141. error = pdata->device_enable(dev);
  142. if (error < 0) {
  143. dev_dbg(dev, "device enable function failed\n");
  144. return error;
  145. }
  146. }
  147. if (!pdata->keymap) {
  148. dev_dbg(dev, "no keymap from pdata\n");
  149. return -EINVAL;
  150. }
  151. davinci_ks = kzalloc(sizeof(struct davinci_ks) +
  152. sizeof(unsigned short) * pdata->keymapsize, GFP_KERNEL);
  153. if (!davinci_ks) {
  154. dev_dbg(dev, "could not allocate memory for private data\n");
  155. return -ENOMEM;
  156. }
  157. memcpy(davinci_ks->keymap, pdata->keymap,
  158. sizeof(unsigned short) * pdata->keymapsize);
  159. key_dev = input_allocate_device();
  160. if (!key_dev) {
  161. dev_dbg(dev, "could not allocate input device\n");
  162. error = -ENOMEM;
  163. goto fail1;
  164. }
  165. davinci_ks->input = key_dev;
  166. davinci_ks->irq = platform_get_irq(pdev, 0);
  167. if (davinci_ks->irq < 0) {
  168. error = davinci_ks->irq;
  169. goto fail2;
  170. }
  171. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  172. if (!res) {
  173. dev_err(dev, "no mem resource\n");
  174. error = -EINVAL;
  175. goto fail2;
  176. }
  177. davinci_ks->pbase = res->start;
  178. davinci_ks->base_size = resource_size(res);
  179. mem = request_mem_region(davinci_ks->pbase, davinci_ks->base_size,
  180. pdev->name);
  181. if (!mem) {
  182. dev_err(dev, "key scan registers at %08x are not free\n",
  183. davinci_ks->pbase);
  184. error = -EBUSY;
  185. goto fail2;
  186. }
  187. davinci_ks->base = ioremap(davinci_ks->pbase, davinci_ks->base_size);
  188. if (!davinci_ks->base) {
  189. dev_err(dev, "can't ioremap MEM resource.\n");
  190. error = -ENOMEM;
  191. goto fail3;
  192. }
  193. /* Enable auto repeat feature of Linux input subsystem */
  194. if (pdata->rep)
  195. __set_bit(EV_REP, key_dev->evbit);
  196. /* Setup input device */
  197. __set_bit(EV_KEY, key_dev->evbit);
  198. /* Setup the platform data */
  199. davinci_ks->pdata = pdata;
  200. for (i = 0; i < davinci_ks->pdata->keymapsize; i++)
  201. __set_bit(davinci_ks->pdata->keymap[i], key_dev->keybit);
  202. key_dev->name = "davinci_keyscan";
  203. key_dev->phys = "davinci_keyscan/input0";
  204. key_dev->dev.parent = dev;
  205. key_dev->id.bustype = BUS_HOST;
  206. key_dev->id.vendor = 0x0001;
  207. key_dev->id.product = 0x0001;
  208. key_dev->id.version = 0x0001;
  209. key_dev->keycode = davinci_ks->keymap;
  210. key_dev->keycodesize = sizeof(davinci_ks->keymap[0]);
  211. key_dev->keycodemax = davinci_ks->pdata->keymapsize;
  212. error = input_register_device(davinci_ks->input);
  213. if (error < 0) {
  214. dev_err(dev, "unable to register davinci key scan device\n");
  215. goto fail4;
  216. }
  217. error = request_irq(davinci_ks->irq, davinci_ks_interrupt,
  218. 0, pdev->name, davinci_ks);
  219. if (error < 0) {
  220. dev_err(dev, "unable to register davinci key scan interrupt\n");
  221. goto fail5;
  222. }
  223. error = davinci_ks_initialize(davinci_ks);
  224. if (error < 0) {
  225. dev_err(dev, "unable to initialize davinci key scan device\n");
  226. goto fail6;
  227. }
  228. platform_set_drvdata(pdev, davinci_ks);
  229. return 0;
  230. fail6:
  231. free_irq(davinci_ks->irq, davinci_ks);
  232. fail5:
  233. input_unregister_device(davinci_ks->input);
  234. key_dev = NULL;
  235. fail4:
  236. iounmap(davinci_ks->base);
  237. fail3:
  238. release_mem_region(davinci_ks->pbase, davinci_ks->base_size);
  239. fail2:
  240. input_free_device(key_dev);
  241. fail1:
  242. kfree(davinci_ks);
  243. return error;
  244. }
  245. static int davinci_ks_remove(struct platform_device *pdev)
  246. {
  247. struct davinci_ks *davinci_ks = platform_get_drvdata(pdev);
  248. free_irq(davinci_ks->irq, davinci_ks);
  249. input_unregister_device(davinci_ks->input);
  250. iounmap(davinci_ks->base);
  251. release_mem_region(davinci_ks->pbase, davinci_ks->base_size);
  252. kfree(davinci_ks);
  253. return 0;
  254. }
  255. static struct platform_driver davinci_ks_driver = {
  256. .driver = {
  257. .name = "davinci_keyscan",
  258. },
  259. .remove = davinci_ks_remove,
  260. };
  261. module_platform_driver_probe(davinci_ks_driver, davinci_ks_probe);
  262. MODULE_AUTHOR("Miguel Aguilar");
  263. MODULE_DESCRIPTION("Texas Instruments DaVinci Key Scan Driver");
  264. MODULE_LICENSE("GPL");