st-keyscan.c 6.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * STMicroelectronics Key Scanning driver
  4. *
  5. * Copyright (c) 2014 STMicroelectonics Ltd.
  6. * Author: Stuart Menefy <stuart.menefy@st.com>
  7. *
  8. * Based on sh_keysc.c, copyright 2008 Magnus Damm
  9. */
  10. #include <linux/module.h>
  11. #include <linux/interrupt.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/clk.h>
  14. #include <linux/io.h>
  15. #include <linux/input/matrix_keypad.h>
  16. #define ST_KEYSCAN_MAXKEYS 16
  17. #define KEYSCAN_CONFIG_OFF 0x0
  18. #define KEYSCAN_CONFIG_ENABLE 0x1
  19. #define KEYSCAN_DEBOUNCE_TIME_OFF 0x4
  20. #define KEYSCAN_MATRIX_STATE_OFF 0x8
  21. #define KEYSCAN_MATRIX_DIM_OFF 0xc
  22. #define KEYSCAN_MATRIX_DIM_X_SHIFT 0x0
  23. #define KEYSCAN_MATRIX_DIM_Y_SHIFT 0x2
  24. struct st_keyscan {
  25. void __iomem *base;
  26. int irq;
  27. struct clk *clk;
  28. struct input_dev *input_dev;
  29. unsigned long last_state;
  30. unsigned int n_rows;
  31. unsigned int n_cols;
  32. unsigned int debounce_us;
  33. };
  34. static irqreturn_t keyscan_isr(int irq, void *dev_id)
  35. {
  36. struct st_keyscan *keypad = dev_id;
  37. unsigned short *keycode = keypad->input_dev->keycode;
  38. unsigned long state, change;
  39. int bit_nr;
  40. state = readl(keypad->base + KEYSCAN_MATRIX_STATE_OFF) & 0xffff;
  41. change = keypad->last_state ^ state;
  42. keypad->last_state = state;
  43. for_each_set_bit(bit_nr, &change, BITS_PER_LONG)
  44. input_report_key(keypad->input_dev,
  45. keycode[bit_nr], state & BIT(bit_nr));
  46. input_sync(keypad->input_dev);
  47. return IRQ_HANDLED;
  48. }
  49. static int keyscan_start(struct st_keyscan *keypad)
  50. {
  51. int error;
  52. error = clk_enable(keypad->clk);
  53. if (error)
  54. return error;
  55. writel(keypad->debounce_us * (clk_get_rate(keypad->clk) / 1000000),
  56. keypad->base + KEYSCAN_DEBOUNCE_TIME_OFF);
  57. writel(((keypad->n_cols - 1) << KEYSCAN_MATRIX_DIM_X_SHIFT) |
  58. ((keypad->n_rows - 1) << KEYSCAN_MATRIX_DIM_Y_SHIFT),
  59. keypad->base + KEYSCAN_MATRIX_DIM_OFF);
  60. writel(KEYSCAN_CONFIG_ENABLE, keypad->base + KEYSCAN_CONFIG_OFF);
  61. return 0;
  62. }
  63. static void keyscan_stop(struct st_keyscan *keypad)
  64. {
  65. writel(0, keypad->base + KEYSCAN_CONFIG_OFF);
  66. clk_disable(keypad->clk);
  67. }
  68. static int keyscan_open(struct input_dev *dev)
  69. {
  70. struct st_keyscan *keypad = input_get_drvdata(dev);
  71. return keyscan_start(keypad);
  72. }
  73. static void keyscan_close(struct input_dev *dev)
  74. {
  75. struct st_keyscan *keypad = input_get_drvdata(dev);
  76. keyscan_stop(keypad);
  77. }
  78. static int keypad_matrix_key_parse_dt(struct st_keyscan *keypad_data)
  79. {
  80. struct device *dev = keypad_data->input_dev->dev.parent;
  81. struct device_node *np = dev->of_node;
  82. int error;
  83. error = matrix_keypad_parse_properties(dev, &keypad_data->n_rows,
  84. &keypad_data->n_cols);
  85. if (error) {
  86. dev_err(dev, "failed to parse keypad params\n");
  87. return error;
  88. }
  89. of_property_read_u32(np, "st,debounce-us", &keypad_data->debounce_us);
  90. dev_dbg(dev, "n_rows=%d n_col=%d debounce=%d\n",
  91. keypad_data->n_rows, keypad_data->n_cols,
  92. keypad_data->debounce_us);
  93. return 0;
  94. }
  95. static int keyscan_probe(struct platform_device *pdev)
  96. {
  97. struct st_keyscan *keypad_data;
  98. struct input_dev *input_dev;
  99. struct resource *res;
  100. int error;
  101. if (!pdev->dev.of_node) {
  102. dev_err(&pdev->dev, "no DT data present\n");
  103. return -EINVAL;
  104. }
  105. keypad_data = devm_kzalloc(&pdev->dev, sizeof(*keypad_data),
  106. GFP_KERNEL);
  107. if (!keypad_data)
  108. return -ENOMEM;
  109. input_dev = devm_input_allocate_device(&pdev->dev);
  110. if (!input_dev) {
  111. dev_err(&pdev->dev, "failed to allocate the input device\n");
  112. return -ENOMEM;
  113. }
  114. input_dev->name = pdev->name;
  115. input_dev->phys = "keyscan-keys/input0";
  116. input_dev->dev.parent = &pdev->dev;
  117. input_dev->open = keyscan_open;
  118. input_dev->close = keyscan_close;
  119. input_dev->id.bustype = BUS_HOST;
  120. keypad_data->input_dev = input_dev;
  121. error = keypad_matrix_key_parse_dt(keypad_data);
  122. if (error)
  123. return error;
  124. error = matrix_keypad_build_keymap(NULL, NULL,
  125. keypad_data->n_rows,
  126. keypad_data->n_cols,
  127. NULL, input_dev);
  128. if (error) {
  129. dev_err(&pdev->dev, "failed to build keymap\n");
  130. return error;
  131. }
  132. input_set_drvdata(input_dev, keypad_data);
  133. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  134. keypad_data->base = devm_ioremap_resource(&pdev->dev, res);
  135. if (IS_ERR(keypad_data->base))
  136. return PTR_ERR(keypad_data->base);
  137. keypad_data->clk = devm_clk_get(&pdev->dev, NULL);
  138. if (IS_ERR(keypad_data->clk)) {
  139. dev_err(&pdev->dev, "cannot get clock\n");
  140. return PTR_ERR(keypad_data->clk);
  141. }
  142. error = clk_enable(keypad_data->clk);
  143. if (error) {
  144. dev_err(&pdev->dev, "failed to enable clock\n");
  145. return error;
  146. }
  147. keyscan_stop(keypad_data);
  148. keypad_data->irq = platform_get_irq(pdev, 0);
  149. if (keypad_data->irq < 0)
  150. return -EINVAL;
  151. error = devm_request_irq(&pdev->dev, keypad_data->irq, keyscan_isr, 0,
  152. pdev->name, keypad_data);
  153. if (error) {
  154. dev_err(&pdev->dev, "failed to request IRQ\n");
  155. return error;
  156. }
  157. error = input_register_device(input_dev);
  158. if (error) {
  159. dev_err(&pdev->dev, "failed to register input device\n");
  160. return error;
  161. }
  162. platform_set_drvdata(pdev, keypad_data);
  163. device_set_wakeup_capable(&pdev->dev, 1);
  164. return 0;
  165. }
  166. #ifdef CONFIG_PM_SLEEP
  167. static int keyscan_suspend(struct device *dev)
  168. {
  169. struct platform_device *pdev = to_platform_device(dev);
  170. struct st_keyscan *keypad = platform_get_drvdata(pdev);
  171. struct input_dev *input = keypad->input_dev;
  172. mutex_lock(&input->mutex);
  173. if (device_may_wakeup(dev))
  174. enable_irq_wake(keypad->irq);
  175. else if (input->users)
  176. keyscan_stop(keypad);
  177. mutex_unlock(&input->mutex);
  178. return 0;
  179. }
  180. static int keyscan_resume(struct device *dev)
  181. {
  182. struct platform_device *pdev = to_platform_device(dev);
  183. struct st_keyscan *keypad = platform_get_drvdata(pdev);
  184. struct input_dev *input = keypad->input_dev;
  185. int retval = 0;
  186. mutex_lock(&input->mutex);
  187. if (device_may_wakeup(dev))
  188. disable_irq_wake(keypad->irq);
  189. else if (input->users)
  190. retval = keyscan_start(keypad);
  191. mutex_unlock(&input->mutex);
  192. return retval;
  193. }
  194. #endif
  195. static SIMPLE_DEV_PM_OPS(keyscan_dev_pm_ops, keyscan_suspend, keyscan_resume);
  196. static const struct of_device_id keyscan_of_match[] = {
  197. { .compatible = "st,sti-keyscan" },
  198. { },
  199. };
  200. MODULE_DEVICE_TABLE(of, keyscan_of_match);
  201. static struct platform_driver keyscan_device_driver = {
  202. .probe = keyscan_probe,
  203. .driver = {
  204. .name = "st-keyscan",
  205. .pm = &keyscan_dev_pm_ops,
  206. .of_match_table = of_match_ptr(keyscan_of_match),
  207. }
  208. };
  209. module_platform_driver(keyscan_device_driver);
  210. MODULE_AUTHOR("Stuart Menefy <stuart.menefy@st.com>");
  211. MODULE_DESCRIPTION("STMicroelectronics keyscan device driver");
  212. MODULE_LICENSE("GPL");