spear-keyboard.c 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390
  1. /*
  2. * SPEAr Keyboard Driver
  3. * Based on omap-keypad driver
  4. *
  5. * Copyright (C) 2010 ST Microelectronics
  6. * Rajeev Kumar <rajeevkumar.linux@gmail.com>
  7. *
  8. * This file is licensed under the terms of the GNU General Public
  9. * License version 2. This program is licensed "as is" without any
  10. * warranty of any kind, whether express or implied.
  11. */
  12. #include <linux/clk.h>
  13. #include <linux/errno.h>
  14. #include <linux/interrupt.h>
  15. #include <linux/input.h>
  16. #include <linux/io.h>
  17. #include <linux/irq.h>
  18. #include <linux/kernel.h>
  19. #include <linux/module.h>
  20. #include <linux/of.h>
  21. #include <linux/platform_device.h>
  22. #include <linux/pm_wakeup.h>
  23. #include <linux/slab.h>
  24. #include <linux/types.h>
  25. #include <linux/platform_data/keyboard-spear.h>
  26. /* Keyboard Registers */
  27. #define MODE_CTL_REG 0x00
  28. #define STATUS_REG 0x0C
  29. #define DATA_REG 0x10
  30. #define INTR_MASK 0x54
  31. /* Register Values */
  32. #define NUM_ROWS 16
  33. #define NUM_COLS 16
  34. #define MODE_CTL_PCLK_FREQ_SHIFT 9
  35. #define MODE_CTL_PCLK_FREQ_MSK 0x7F
  36. #define MODE_CTL_KEYBOARD (0x2 << 0)
  37. #define MODE_CTL_SCAN_RATE_10 (0x0 << 2)
  38. #define MODE_CTL_SCAN_RATE_20 (0x1 << 2)
  39. #define MODE_CTL_SCAN_RATE_40 (0x2 << 2)
  40. #define MODE_CTL_SCAN_RATE_80 (0x3 << 2)
  41. #define MODE_CTL_KEYNUM_SHIFT 6
  42. #define MODE_CTL_START_SCAN (0x1 << 8)
  43. #define STATUS_DATA_AVAIL (0x1 << 1)
  44. #define DATA_ROW_MASK 0xF0
  45. #define DATA_COLUMN_MASK 0x0F
  46. #define ROW_SHIFT 4
  47. struct spear_kbd {
  48. struct input_dev *input;
  49. void __iomem *io_base;
  50. struct clk *clk;
  51. unsigned int irq;
  52. unsigned int mode;
  53. unsigned int suspended_rate;
  54. unsigned short last_key;
  55. unsigned short keycodes[NUM_ROWS * NUM_COLS];
  56. bool rep;
  57. bool irq_wake_enabled;
  58. u32 mode_ctl_reg;
  59. };
  60. static irqreturn_t spear_kbd_interrupt(int irq, void *dev_id)
  61. {
  62. struct spear_kbd *kbd = dev_id;
  63. struct input_dev *input = kbd->input;
  64. unsigned int key;
  65. u32 sts, val;
  66. sts = readl_relaxed(kbd->io_base + STATUS_REG);
  67. if (!(sts & STATUS_DATA_AVAIL))
  68. return IRQ_NONE;
  69. if (kbd->last_key != KEY_RESERVED) {
  70. input_report_key(input, kbd->last_key, 0);
  71. kbd->last_key = KEY_RESERVED;
  72. }
  73. /* following reads active (row, col) pair */
  74. val = readl_relaxed(kbd->io_base + DATA_REG) &
  75. (DATA_ROW_MASK | DATA_COLUMN_MASK);
  76. key = kbd->keycodes[val];
  77. input_event(input, EV_MSC, MSC_SCAN, val);
  78. input_report_key(input, key, 1);
  79. input_sync(input);
  80. kbd->last_key = key;
  81. /* clear interrupt */
  82. writel_relaxed(0, kbd->io_base + STATUS_REG);
  83. return IRQ_HANDLED;
  84. }
  85. static int spear_kbd_open(struct input_dev *dev)
  86. {
  87. struct spear_kbd *kbd = input_get_drvdata(dev);
  88. int error;
  89. u32 val;
  90. kbd->last_key = KEY_RESERVED;
  91. error = clk_enable(kbd->clk);
  92. if (error)
  93. return error;
  94. /* keyboard rate to be programmed is input clock (in MHz) - 1 */
  95. val = clk_get_rate(kbd->clk) / 1000000 - 1;
  96. val = (val & MODE_CTL_PCLK_FREQ_MSK) << MODE_CTL_PCLK_FREQ_SHIFT;
  97. /* program keyboard */
  98. val = MODE_CTL_SCAN_RATE_80 | MODE_CTL_KEYBOARD | val |
  99. (kbd->mode << MODE_CTL_KEYNUM_SHIFT);
  100. writel_relaxed(val, kbd->io_base + MODE_CTL_REG);
  101. writel_relaxed(1, kbd->io_base + STATUS_REG);
  102. /* start key scan */
  103. val = readl_relaxed(kbd->io_base + MODE_CTL_REG);
  104. val |= MODE_CTL_START_SCAN;
  105. writel_relaxed(val, kbd->io_base + MODE_CTL_REG);
  106. return 0;
  107. }
  108. static void spear_kbd_close(struct input_dev *dev)
  109. {
  110. struct spear_kbd *kbd = input_get_drvdata(dev);
  111. u32 val;
  112. /* stop key scan */
  113. val = readl_relaxed(kbd->io_base + MODE_CTL_REG);
  114. val &= ~MODE_CTL_START_SCAN;
  115. writel_relaxed(val, kbd->io_base + MODE_CTL_REG);
  116. clk_disable(kbd->clk);
  117. kbd->last_key = KEY_RESERVED;
  118. }
  119. #ifdef CONFIG_OF
  120. static int spear_kbd_parse_dt(struct platform_device *pdev,
  121. struct spear_kbd *kbd)
  122. {
  123. struct device_node *np = pdev->dev.of_node;
  124. int error;
  125. u32 val, suspended_rate;
  126. if (!np) {
  127. dev_err(&pdev->dev, "Missing DT data\n");
  128. return -EINVAL;
  129. }
  130. if (of_property_read_bool(np, "autorepeat"))
  131. kbd->rep = true;
  132. if (of_property_read_u32(np, "suspended_rate", &suspended_rate))
  133. kbd->suspended_rate = suspended_rate;
  134. error = of_property_read_u32(np, "st,mode", &val);
  135. if (error) {
  136. dev_err(&pdev->dev, "DT: Invalid or missing mode\n");
  137. return error;
  138. }
  139. kbd->mode = val;
  140. return 0;
  141. }
  142. #else
  143. static inline int spear_kbd_parse_dt(struct platform_device *pdev,
  144. struct spear_kbd *kbd)
  145. {
  146. return -ENOSYS;
  147. }
  148. #endif
  149. static int spear_kbd_probe(struct platform_device *pdev)
  150. {
  151. struct kbd_platform_data *pdata = dev_get_platdata(&pdev->dev);
  152. const struct matrix_keymap_data *keymap = pdata ? pdata->keymap : NULL;
  153. struct spear_kbd *kbd;
  154. struct input_dev *input_dev;
  155. struct resource *res;
  156. int irq;
  157. int error;
  158. irq = platform_get_irq(pdev, 0);
  159. if (irq < 0)
  160. return irq;
  161. kbd = devm_kzalloc(&pdev->dev, sizeof(*kbd), GFP_KERNEL);
  162. if (!kbd) {
  163. dev_err(&pdev->dev, "not enough memory for driver data\n");
  164. return -ENOMEM;
  165. }
  166. input_dev = devm_input_allocate_device(&pdev->dev);
  167. if (!input_dev) {
  168. dev_err(&pdev->dev, "unable to allocate input device\n");
  169. return -ENOMEM;
  170. }
  171. kbd->input = input_dev;
  172. kbd->irq = irq;
  173. if (!pdata) {
  174. error = spear_kbd_parse_dt(pdev, kbd);
  175. if (error)
  176. return error;
  177. } else {
  178. kbd->mode = pdata->mode;
  179. kbd->rep = pdata->rep;
  180. kbd->suspended_rate = pdata->suspended_rate;
  181. }
  182. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  183. kbd->io_base = devm_ioremap_resource(&pdev->dev, res);
  184. if (IS_ERR(kbd->io_base))
  185. return PTR_ERR(kbd->io_base);
  186. kbd->clk = devm_clk_get(&pdev->dev, NULL);
  187. if (IS_ERR(kbd->clk))
  188. return PTR_ERR(kbd->clk);
  189. input_dev->name = "Spear Keyboard";
  190. input_dev->phys = "keyboard/input0";
  191. input_dev->id.bustype = BUS_HOST;
  192. input_dev->id.vendor = 0x0001;
  193. input_dev->id.product = 0x0001;
  194. input_dev->id.version = 0x0100;
  195. input_dev->open = spear_kbd_open;
  196. input_dev->close = spear_kbd_close;
  197. error = matrix_keypad_build_keymap(keymap, NULL, NUM_ROWS, NUM_COLS,
  198. kbd->keycodes, input_dev);
  199. if (error) {
  200. dev_err(&pdev->dev, "Failed to build keymap\n");
  201. return error;
  202. }
  203. if (kbd->rep)
  204. __set_bit(EV_REP, input_dev->evbit);
  205. input_set_capability(input_dev, EV_MSC, MSC_SCAN);
  206. input_set_drvdata(input_dev, kbd);
  207. error = devm_request_irq(&pdev->dev, irq, spear_kbd_interrupt, 0,
  208. "keyboard", kbd);
  209. if (error) {
  210. dev_err(&pdev->dev, "request_irq failed\n");
  211. return error;
  212. }
  213. error = clk_prepare(kbd->clk);
  214. if (error)
  215. return error;
  216. error = input_register_device(input_dev);
  217. if (error) {
  218. dev_err(&pdev->dev, "Unable to register keyboard device\n");
  219. clk_unprepare(kbd->clk);
  220. return error;
  221. }
  222. device_init_wakeup(&pdev->dev, 1);
  223. platform_set_drvdata(pdev, kbd);
  224. return 0;
  225. }
  226. static int spear_kbd_remove(struct platform_device *pdev)
  227. {
  228. struct spear_kbd *kbd = platform_get_drvdata(pdev);
  229. input_unregister_device(kbd->input);
  230. clk_unprepare(kbd->clk);
  231. return 0;
  232. }
  233. static int __maybe_unused spear_kbd_suspend(struct device *dev)
  234. {
  235. struct platform_device *pdev = to_platform_device(dev);
  236. struct spear_kbd *kbd = platform_get_drvdata(pdev);
  237. struct input_dev *input_dev = kbd->input;
  238. unsigned int rate = 0, mode_ctl_reg, val;
  239. mutex_lock(&input_dev->mutex);
  240. /* explicitly enable clock as we may program device */
  241. clk_enable(kbd->clk);
  242. mode_ctl_reg = readl_relaxed(kbd->io_base + MODE_CTL_REG);
  243. if (device_may_wakeup(&pdev->dev)) {
  244. if (!enable_irq_wake(kbd->irq))
  245. kbd->irq_wake_enabled = true;
  246. /*
  247. * reprogram the keyboard operating frequency as on some
  248. * platform it may change during system suspended
  249. */
  250. if (kbd->suspended_rate)
  251. rate = kbd->suspended_rate / 1000000 - 1;
  252. else
  253. rate = clk_get_rate(kbd->clk) / 1000000 - 1;
  254. val = mode_ctl_reg &
  255. ~(MODE_CTL_PCLK_FREQ_MSK << MODE_CTL_PCLK_FREQ_SHIFT);
  256. val |= (rate & MODE_CTL_PCLK_FREQ_MSK)
  257. << MODE_CTL_PCLK_FREQ_SHIFT;
  258. writel_relaxed(val, kbd->io_base + MODE_CTL_REG);
  259. } else {
  260. if (input_dev->users) {
  261. writel_relaxed(mode_ctl_reg & ~MODE_CTL_START_SCAN,
  262. kbd->io_base + MODE_CTL_REG);
  263. clk_disable(kbd->clk);
  264. }
  265. }
  266. /* store current configuration */
  267. if (input_dev->users)
  268. kbd->mode_ctl_reg = mode_ctl_reg;
  269. /* restore previous clk state */
  270. clk_disable(kbd->clk);
  271. mutex_unlock(&input_dev->mutex);
  272. return 0;
  273. }
  274. static int __maybe_unused spear_kbd_resume(struct device *dev)
  275. {
  276. struct platform_device *pdev = to_platform_device(dev);
  277. struct spear_kbd *kbd = platform_get_drvdata(pdev);
  278. struct input_dev *input_dev = kbd->input;
  279. mutex_lock(&input_dev->mutex);
  280. if (device_may_wakeup(&pdev->dev)) {
  281. if (kbd->irq_wake_enabled) {
  282. kbd->irq_wake_enabled = false;
  283. disable_irq_wake(kbd->irq);
  284. }
  285. } else {
  286. if (input_dev->users)
  287. clk_enable(kbd->clk);
  288. }
  289. /* restore current configuration */
  290. if (input_dev->users)
  291. writel_relaxed(kbd->mode_ctl_reg, kbd->io_base + MODE_CTL_REG);
  292. mutex_unlock(&input_dev->mutex);
  293. return 0;
  294. }
  295. static SIMPLE_DEV_PM_OPS(spear_kbd_pm_ops, spear_kbd_suspend, spear_kbd_resume);
  296. #ifdef CONFIG_OF
  297. static const struct of_device_id spear_kbd_id_table[] = {
  298. { .compatible = "st,spear300-kbd" },
  299. {}
  300. };
  301. MODULE_DEVICE_TABLE(of, spear_kbd_id_table);
  302. #endif
  303. static struct platform_driver spear_kbd_driver = {
  304. .probe = spear_kbd_probe,
  305. .remove = spear_kbd_remove,
  306. .driver = {
  307. .name = "keyboard",
  308. .pm = &spear_kbd_pm_ops,
  309. .of_match_table = of_match_ptr(spear_kbd_id_table),
  310. },
  311. };
  312. module_platform_driver(spear_kbd_driver);
  313. MODULE_AUTHOR("Rajeev Kumar");
  314. MODULE_DESCRIPTION("SPEAr Keyboard Driver");
  315. MODULE_LICENSE("GPL");