omap4-keypad.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * OMAP4 Keypad Driver
  4. *
  5. * Copyright (C) 2010 Texas Instruments
  6. *
  7. * Author: Abraham Arce <x0066660@ti.com>
  8. * Initial Code: Syed Rafiuddin <rafiuddin.syed@ti.com>
  9. */
  10. #include <linux/module.h>
  11. #include <linux/interrupt.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/errno.h>
  14. #include <linux/io.h>
  15. #include <linux/of.h>
  16. #include <linux/input.h>
  17. #include <linux/input/matrix_keypad.h>
  18. #include <linux/slab.h>
  19. #include <linux/pm_runtime.h>
  20. /* OMAP4 registers */
  21. #define OMAP4_KBD_REVISION 0x00
  22. #define OMAP4_KBD_SYSCONFIG 0x10
  23. #define OMAP4_KBD_SYSSTATUS 0x14
  24. #define OMAP4_KBD_IRQSTATUS 0x18
  25. #define OMAP4_KBD_IRQENABLE 0x1C
  26. #define OMAP4_KBD_WAKEUPENABLE 0x20
  27. #define OMAP4_KBD_PENDING 0x24
  28. #define OMAP4_KBD_CTRL 0x28
  29. #define OMAP4_KBD_DEBOUNCINGTIME 0x2C
  30. #define OMAP4_KBD_LONGKEYTIME 0x30
  31. #define OMAP4_KBD_TIMEOUT 0x34
  32. #define OMAP4_KBD_STATEMACHINE 0x38
  33. #define OMAP4_KBD_ROWINPUTS 0x3C
  34. #define OMAP4_KBD_COLUMNOUTPUTS 0x40
  35. #define OMAP4_KBD_FULLCODE31_0 0x44
  36. #define OMAP4_KBD_FULLCODE63_32 0x48
  37. /* OMAP4 bit definitions */
  38. #define OMAP4_DEF_IRQENABLE_EVENTEN BIT(0)
  39. #define OMAP4_DEF_IRQENABLE_LONGKEY BIT(1)
  40. #define OMAP4_DEF_WUP_EVENT_ENA BIT(0)
  41. #define OMAP4_DEF_WUP_LONG_KEY_ENA BIT(1)
  42. #define OMAP4_DEF_CTRL_NOSOFTMODE BIT(1)
  43. #define OMAP4_DEF_CTRL_PTV_SHIFT 2
  44. /* OMAP4 values */
  45. #define OMAP4_VAL_IRQDISABLE 0x0
  46. /*
  47. * Errata i689: If a key is released for a time shorter than debounce time,
  48. * the keyboard will idle and never detect the key release. The workaround
  49. * is to use at least a 12ms debounce time. See omap5432 TRM chapter
  50. * "26.4.6.2 Keyboard Controller Timer" for more information.
  51. */
  52. #define OMAP4_KEYPAD_PTV_DIV_128 0x6
  53. #define OMAP4_KEYPAD_DEBOUNCINGTIME_MS(dbms, ptv) \
  54. ((((dbms) * 1000) / ((1 << ((ptv) + 1)) * (1000000 / 32768))) - 1)
  55. #define OMAP4_VAL_DEBOUNCINGTIME_16MS \
  56. OMAP4_KEYPAD_DEBOUNCINGTIME_MS(16, OMAP4_KEYPAD_PTV_DIV_128)
  57. enum {
  58. KBD_REVISION_OMAP4 = 0,
  59. KBD_REVISION_OMAP5,
  60. };
  61. struct omap4_keypad {
  62. struct input_dev *input;
  63. void __iomem *base;
  64. bool irq_wake_enabled;
  65. unsigned int irq;
  66. unsigned int rows;
  67. unsigned int cols;
  68. u32 reg_offset;
  69. u32 irqreg_offset;
  70. unsigned int row_shift;
  71. bool no_autorepeat;
  72. unsigned char key_state[8];
  73. unsigned short *keymap;
  74. };
  75. static int kbd_readl(struct omap4_keypad *keypad_data, u32 offset)
  76. {
  77. return __raw_readl(keypad_data->base +
  78. keypad_data->reg_offset + offset);
  79. }
  80. static void kbd_writel(struct omap4_keypad *keypad_data, u32 offset, u32 value)
  81. {
  82. __raw_writel(value,
  83. keypad_data->base + keypad_data->reg_offset + offset);
  84. }
  85. static int kbd_read_irqreg(struct omap4_keypad *keypad_data, u32 offset)
  86. {
  87. return __raw_readl(keypad_data->base +
  88. keypad_data->irqreg_offset + offset);
  89. }
  90. static void kbd_write_irqreg(struct omap4_keypad *keypad_data,
  91. u32 offset, u32 value)
  92. {
  93. __raw_writel(value,
  94. keypad_data->base + keypad_data->irqreg_offset + offset);
  95. }
  96. /* Interrupt handlers */
  97. static irqreturn_t omap4_keypad_irq_handler(int irq, void *dev_id)
  98. {
  99. struct omap4_keypad *keypad_data = dev_id;
  100. if (kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS))
  101. return IRQ_WAKE_THREAD;
  102. return IRQ_NONE;
  103. }
  104. static irqreturn_t omap4_keypad_irq_thread_fn(int irq, void *dev_id)
  105. {
  106. struct omap4_keypad *keypad_data = dev_id;
  107. struct input_dev *input_dev = keypad_data->input;
  108. unsigned char key_state[ARRAY_SIZE(keypad_data->key_state)];
  109. unsigned int col, row, code, changed;
  110. u32 *new_state = (u32 *) key_state;
  111. *new_state = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE31_0);
  112. *(new_state + 1) = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE63_32);
  113. for (row = 0; row < keypad_data->rows; row++) {
  114. changed = key_state[row] ^ keypad_data->key_state[row];
  115. if (!changed)
  116. continue;
  117. for (col = 0; col < keypad_data->cols; col++) {
  118. if (changed & (1 << col)) {
  119. code = MATRIX_SCAN_CODE(row, col,
  120. keypad_data->row_shift);
  121. input_event(input_dev, EV_MSC, MSC_SCAN, code);
  122. input_report_key(input_dev,
  123. keypad_data->keymap[code],
  124. key_state[row] & (1 << col));
  125. }
  126. }
  127. }
  128. input_sync(input_dev);
  129. memcpy(keypad_data->key_state, key_state,
  130. sizeof(keypad_data->key_state));
  131. /* clear pending interrupts */
  132. kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS,
  133. kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS));
  134. return IRQ_HANDLED;
  135. }
  136. static int omap4_keypad_open(struct input_dev *input)
  137. {
  138. struct omap4_keypad *keypad_data = input_get_drvdata(input);
  139. pm_runtime_get_sync(input->dev.parent);
  140. disable_irq(keypad_data->irq);
  141. kbd_writel(keypad_data, OMAP4_KBD_CTRL,
  142. OMAP4_DEF_CTRL_NOSOFTMODE |
  143. (OMAP4_KEYPAD_PTV_DIV_128 << OMAP4_DEF_CTRL_PTV_SHIFT));
  144. kbd_writel(keypad_data, OMAP4_KBD_DEBOUNCINGTIME,
  145. OMAP4_VAL_DEBOUNCINGTIME_16MS);
  146. /* clear pending interrupts */
  147. kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS,
  148. kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS));
  149. kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQENABLE,
  150. OMAP4_DEF_IRQENABLE_EVENTEN |
  151. OMAP4_DEF_IRQENABLE_LONGKEY);
  152. kbd_writel(keypad_data, OMAP4_KBD_WAKEUPENABLE,
  153. OMAP4_DEF_WUP_EVENT_ENA | OMAP4_DEF_WUP_LONG_KEY_ENA);
  154. enable_irq(keypad_data->irq);
  155. return 0;
  156. }
  157. static void omap4_keypad_stop(struct omap4_keypad *keypad_data)
  158. {
  159. /* Disable interrupts and wake-up events */
  160. kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQENABLE,
  161. OMAP4_VAL_IRQDISABLE);
  162. kbd_writel(keypad_data, OMAP4_KBD_WAKEUPENABLE, 0);
  163. /* clear pending interrupts */
  164. kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS,
  165. kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS));
  166. }
  167. static void omap4_keypad_close(struct input_dev *input)
  168. {
  169. struct omap4_keypad *keypad_data;
  170. keypad_data = input_get_drvdata(input);
  171. disable_irq(keypad_data->irq);
  172. omap4_keypad_stop(keypad_data);
  173. enable_irq(keypad_data->irq);
  174. pm_runtime_put_sync(input->dev.parent);
  175. }
  176. static int omap4_keypad_parse_dt(struct device *dev,
  177. struct omap4_keypad *keypad_data)
  178. {
  179. struct device_node *np = dev->of_node;
  180. int err;
  181. err = matrix_keypad_parse_properties(dev, &keypad_data->rows,
  182. &keypad_data->cols);
  183. if (err)
  184. return err;
  185. if (of_get_property(np, "linux,input-no-autorepeat", NULL))
  186. keypad_data->no_autorepeat = true;
  187. return 0;
  188. }
  189. static int omap4_keypad_check_revision(struct device *dev,
  190. struct omap4_keypad *keypad_data)
  191. {
  192. unsigned int rev;
  193. rev = __raw_readl(keypad_data->base + OMAP4_KBD_REVISION);
  194. rev &= 0x03 << 30;
  195. rev >>= 30;
  196. switch (rev) {
  197. case KBD_REVISION_OMAP4:
  198. keypad_data->reg_offset = 0x00;
  199. keypad_data->irqreg_offset = 0x00;
  200. break;
  201. case KBD_REVISION_OMAP5:
  202. keypad_data->reg_offset = 0x10;
  203. keypad_data->irqreg_offset = 0x0c;
  204. break;
  205. default:
  206. dev_err(dev, "Keypad reports unsupported revision %d", rev);
  207. return -EINVAL;
  208. }
  209. return 0;
  210. }
  211. static int omap4_keypad_probe(struct platform_device *pdev)
  212. {
  213. struct omap4_keypad *keypad_data;
  214. struct input_dev *input_dev;
  215. struct resource *res;
  216. unsigned int max_keys;
  217. int irq;
  218. int error;
  219. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  220. if (!res) {
  221. dev_err(&pdev->dev, "no base address specified\n");
  222. return -EINVAL;
  223. }
  224. irq = platform_get_irq(pdev, 0);
  225. if (irq < 0)
  226. return irq;
  227. keypad_data = kzalloc(sizeof(struct omap4_keypad), GFP_KERNEL);
  228. if (!keypad_data) {
  229. dev_err(&pdev->dev, "keypad_data memory allocation failed\n");
  230. return -ENOMEM;
  231. }
  232. keypad_data->irq = irq;
  233. error = omap4_keypad_parse_dt(&pdev->dev, keypad_data);
  234. if (error)
  235. goto err_free_keypad;
  236. res = request_mem_region(res->start, resource_size(res), pdev->name);
  237. if (!res) {
  238. dev_err(&pdev->dev, "can't request mem region\n");
  239. error = -EBUSY;
  240. goto err_free_keypad;
  241. }
  242. keypad_data->base = ioremap(res->start, resource_size(res));
  243. if (!keypad_data->base) {
  244. dev_err(&pdev->dev, "can't ioremap mem resource\n");
  245. error = -ENOMEM;
  246. goto err_release_mem;
  247. }
  248. pm_runtime_enable(&pdev->dev);
  249. /*
  250. * Enable clocks for the keypad module so that we can read
  251. * revision register.
  252. */
  253. error = pm_runtime_get_sync(&pdev->dev);
  254. if (error) {
  255. dev_err(&pdev->dev, "pm_runtime_get_sync() failed\n");
  256. pm_runtime_put_noidle(&pdev->dev);
  257. } else {
  258. error = omap4_keypad_check_revision(&pdev->dev,
  259. keypad_data);
  260. if (!error) {
  261. /* Ensure device does not raise interrupts */
  262. omap4_keypad_stop(keypad_data);
  263. }
  264. pm_runtime_put_sync(&pdev->dev);
  265. }
  266. if (error)
  267. goto err_pm_disable;
  268. /* input device allocation */
  269. keypad_data->input = input_dev = input_allocate_device();
  270. if (!input_dev) {
  271. error = -ENOMEM;
  272. goto err_pm_disable;
  273. }
  274. input_dev->name = pdev->name;
  275. input_dev->dev.parent = &pdev->dev;
  276. input_dev->id.bustype = BUS_HOST;
  277. input_dev->id.vendor = 0x0001;
  278. input_dev->id.product = 0x0001;
  279. input_dev->id.version = 0x0001;
  280. input_dev->open = omap4_keypad_open;
  281. input_dev->close = omap4_keypad_close;
  282. input_set_capability(input_dev, EV_MSC, MSC_SCAN);
  283. if (!keypad_data->no_autorepeat)
  284. __set_bit(EV_REP, input_dev->evbit);
  285. input_set_drvdata(input_dev, keypad_data);
  286. keypad_data->row_shift = get_count_order(keypad_data->cols);
  287. max_keys = keypad_data->rows << keypad_data->row_shift;
  288. keypad_data->keymap = kcalloc(max_keys,
  289. sizeof(keypad_data->keymap[0]),
  290. GFP_KERNEL);
  291. if (!keypad_data->keymap) {
  292. dev_err(&pdev->dev, "Not enough memory for keymap\n");
  293. error = -ENOMEM;
  294. goto err_free_input;
  295. }
  296. error = matrix_keypad_build_keymap(NULL, NULL,
  297. keypad_data->rows, keypad_data->cols,
  298. keypad_data->keymap, input_dev);
  299. if (error) {
  300. dev_err(&pdev->dev, "failed to build keymap\n");
  301. goto err_free_keymap;
  302. }
  303. error = request_threaded_irq(keypad_data->irq, omap4_keypad_irq_handler,
  304. omap4_keypad_irq_thread_fn, IRQF_ONESHOT,
  305. "omap4-keypad", keypad_data);
  306. if (error) {
  307. dev_err(&pdev->dev, "failed to register interrupt\n");
  308. goto err_free_keymap;
  309. }
  310. error = input_register_device(keypad_data->input);
  311. if (error < 0) {
  312. dev_err(&pdev->dev, "failed to register input device\n");
  313. goto err_free_irq;
  314. }
  315. device_init_wakeup(&pdev->dev, true);
  316. platform_set_drvdata(pdev, keypad_data);
  317. return 0;
  318. err_free_irq:
  319. free_irq(keypad_data->irq, keypad_data);
  320. err_free_keymap:
  321. kfree(keypad_data->keymap);
  322. err_free_input:
  323. input_free_device(input_dev);
  324. err_pm_disable:
  325. pm_runtime_disable(&pdev->dev);
  326. iounmap(keypad_data->base);
  327. err_release_mem:
  328. release_mem_region(res->start, resource_size(res));
  329. err_free_keypad:
  330. kfree(keypad_data);
  331. return error;
  332. }
  333. static int omap4_keypad_remove(struct platform_device *pdev)
  334. {
  335. struct omap4_keypad *keypad_data = platform_get_drvdata(pdev);
  336. struct resource *res;
  337. free_irq(keypad_data->irq, keypad_data);
  338. pm_runtime_disable(&pdev->dev);
  339. input_unregister_device(keypad_data->input);
  340. iounmap(keypad_data->base);
  341. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  342. release_mem_region(res->start, resource_size(res));
  343. kfree(keypad_data->keymap);
  344. kfree(keypad_data);
  345. return 0;
  346. }
  347. static const struct of_device_id omap_keypad_dt_match[] = {
  348. { .compatible = "ti,omap4-keypad" },
  349. {},
  350. };
  351. MODULE_DEVICE_TABLE(of, omap_keypad_dt_match);
  352. #ifdef CONFIG_PM_SLEEP
  353. static int omap4_keypad_suspend(struct device *dev)
  354. {
  355. struct platform_device *pdev = to_platform_device(dev);
  356. struct omap4_keypad *keypad_data = platform_get_drvdata(pdev);
  357. int error;
  358. if (device_may_wakeup(&pdev->dev)) {
  359. error = enable_irq_wake(keypad_data->irq);
  360. if (!error)
  361. keypad_data->irq_wake_enabled = true;
  362. }
  363. return 0;
  364. }
  365. static int omap4_keypad_resume(struct device *dev)
  366. {
  367. struct platform_device *pdev = to_platform_device(dev);
  368. struct omap4_keypad *keypad_data = platform_get_drvdata(pdev);
  369. if (device_may_wakeup(&pdev->dev) && keypad_data->irq_wake_enabled) {
  370. disable_irq_wake(keypad_data->irq);
  371. keypad_data->irq_wake_enabled = false;
  372. }
  373. return 0;
  374. }
  375. #endif
  376. static SIMPLE_DEV_PM_OPS(omap4_keypad_pm_ops,
  377. omap4_keypad_suspend, omap4_keypad_resume);
  378. static struct platform_driver omap4_keypad_driver = {
  379. .probe = omap4_keypad_probe,
  380. .remove = omap4_keypad_remove,
  381. .driver = {
  382. .name = "omap4-keypad",
  383. .pm = &omap4_keypad_pm_ops,
  384. .of_match_table = omap_keypad_dt_match,
  385. },
  386. };
  387. module_platform_driver(omap4_keypad_driver);
  388. MODULE_AUTHOR("Texas Instruments");
  389. MODULE_DESCRIPTION("OMAP4 Keypad Driver");
  390. MODULE_LICENSE("GPL");
  391. MODULE_ALIAS("platform:omap4-keypad");