arc_ps2.c 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
  4. *
  5. * Driver is originally developed by Pavel Sokolov <psokolov@synopsys.com>
  6. */
  7. #include <linux/err.h>
  8. #include <linux/module.h>
  9. #include <linux/interrupt.h>
  10. #include <linux/input.h>
  11. #include <linux/serio.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/of.h>
  14. #include <linux/io.h>
  15. #include <linux/kernel.h>
  16. #include <linux/slab.h>
  17. #define ARC_PS2_PORTS 2
  18. #define ARC_ARC_PS2_ID 0x0001f609
  19. #define STAT_TIMEOUT 128
  20. #define PS2_STAT_RX_FRM_ERR (1)
  21. #define PS2_STAT_RX_BUF_OVER (1 << 1)
  22. #define PS2_STAT_RX_INT_EN (1 << 2)
  23. #define PS2_STAT_RX_VAL (1 << 3)
  24. #define PS2_STAT_TX_ISNOT_FUL (1 << 4)
  25. #define PS2_STAT_TX_INT_EN (1 << 5)
  26. struct arc_ps2_port {
  27. void __iomem *data_addr;
  28. void __iomem *status_addr;
  29. struct serio *io;
  30. };
  31. struct arc_ps2_data {
  32. struct arc_ps2_port port[ARC_PS2_PORTS];
  33. void __iomem *addr;
  34. unsigned int frame_error;
  35. unsigned int buf_overflow;
  36. unsigned int total_int;
  37. };
  38. static void arc_ps2_check_rx(struct arc_ps2_data *arc_ps2,
  39. struct arc_ps2_port *port)
  40. {
  41. unsigned int timeout = 1000;
  42. unsigned int flag, status;
  43. unsigned char data;
  44. do {
  45. status = ioread32(port->status_addr);
  46. if (!(status & PS2_STAT_RX_VAL))
  47. return;
  48. data = ioread32(port->data_addr) & 0xff;
  49. flag = 0;
  50. arc_ps2->total_int++;
  51. if (status & PS2_STAT_RX_FRM_ERR) {
  52. arc_ps2->frame_error++;
  53. flag |= SERIO_PARITY;
  54. } else if (status & PS2_STAT_RX_BUF_OVER) {
  55. arc_ps2->buf_overflow++;
  56. flag |= SERIO_FRAME;
  57. }
  58. serio_interrupt(port->io, data, flag);
  59. } while (--timeout);
  60. dev_err(&port->io->dev, "PS/2 hardware stuck\n");
  61. }
  62. static irqreturn_t arc_ps2_interrupt(int irq, void *dev)
  63. {
  64. struct arc_ps2_data *arc_ps2 = dev;
  65. int i;
  66. for (i = 0; i < ARC_PS2_PORTS; i++)
  67. arc_ps2_check_rx(arc_ps2, &arc_ps2->port[i]);
  68. return IRQ_HANDLED;
  69. }
  70. static int arc_ps2_write(struct serio *io, unsigned char val)
  71. {
  72. unsigned status;
  73. struct arc_ps2_port *port = io->port_data;
  74. int timeout = STAT_TIMEOUT;
  75. do {
  76. status = ioread32(port->status_addr);
  77. cpu_relax();
  78. if (status & PS2_STAT_TX_ISNOT_FUL) {
  79. iowrite32(val & 0xff, port->data_addr);
  80. return 0;
  81. }
  82. } while (--timeout);
  83. dev_err(&io->dev, "write timeout\n");
  84. return -ETIMEDOUT;
  85. }
  86. static int arc_ps2_open(struct serio *io)
  87. {
  88. struct arc_ps2_port *port = io->port_data;
  89. iowrite32(PS2_STAT_RX_INT_EN, port->status_addr);
  90. return 0;
  91. }
  92. static void arc_ps2_close(struct serio *io)
  93. {
  94. struct arc_ps2_port *port = io->port_data;
  95. iowrite32(ioread32(port->status_addr) & ~PS2_STAT_RX_INT_EN,
  96. port->status_addr);
  97. }
  98. static void __iomem *arc_ps2_calc_addr(struct arc_ps2_data *arc_ps2,
  99. int index, bool status)
  100. {
  101. void __iomem *addr;
  102. addr = arc_ps2->addr + 4 + 4 * index;
  103. if (status)
  104. addr += ARC_PS2_PORTS * 4;
  105. return addr;
  106. }
  107. static void arc_ps2_inhibit_ports(struct arc_ps2_data *arc_ps2)
  108. {
  109. void __iomem *addr;
  110. u32 val;
  111. int i;
  112. for (i = 0; i < ARC_PS2_PORTS; i++) {
  113. addr = arc_ps2_calc_addr(arc_ps2, i, true);
  114. val = ioread32(addr);
  115. val &= ~(PS2_STAT_RX_INT_EN | PS2_STAT_TX_INT_EN);
  116. iowrite32(val, addr);
  117. }
  118. }
  119. static int arc_ps2_create_port(struct platform_device *pdev,
  120. struct arc_ps2_data *arc_ps2,
  121. int index)
  122. {
  123. struct arc_ps2_port *port = &arc_ps2->port[index];
  124. struct serio *io;
  125. io = kzalloc(sizeof(struct serio), GFP_KERNEL);
  126. if (!io)
  127. return -ENOMEM;
  128. io->id.type = SERIO_8042;
  129. io->write = arc_ps2_write;
  130. io->open = arc_ps2_open;
  131. io->close = arc_ps2_close;
  132. snprintf(io->name, sizeof(io->name), "ARC PS/2 port%d", index);
  133. snprintf(io->phys, sizeof(io->phys), "arc/serio%d", index);
  134. io->port_data = port;
  135. port->io = io;
  136. port->data_addr = arc_ps2_calc_addr(arc_ps2, index, false);
  137. port->status_addr = arc_ps2_calc_addr(arc_ps2, index, true);
  138. dev_dbg(&pdev->dev, "port%d is allocated (data = 0x%p, status = 0x%p)\n",
  139. index, port->data_addr, port->status_addr);
  140. serio_register_port(port->io);
  141. return 0;
  142. }
  143. static int arc_ps2_probe(struct platform_device *pdev)
  144. {
  145. struct arc_ps2_data *arc_ps2;
  146. struct resource *res;
  147. int irq;
  148. int error, id, i;
  149. irq = platform_get_irq_byname(pdev, "arc_ps2_irq");
  150. if (irq < 0)
  151. return -EINVAL;
  152. arc_ps2 = devm_kzalloc(&pdev->dev, sizeof(struct arc_ps2_data),
  153. GFP_KERNEL);
  154. if (!arc_ps2) {
  155. dev_err(&pdev->dev, "out of memory\n");
  156. return -ENOMEM;
  157. }
  158. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  159. arc_ps2->addr = devm_ioremap_resource(&pdev->dev, res);
  160. if (IS_ERR(arc_ps2->addr))
  161. return PTR_ERR(arc_ps2->addr);
  162. dev_info(&pdev->dev, "irq = %d, address = 0x%p, ports = %i\n",
  163. irq, arc_ps2->addr, ARC_PS2_PORTS);
  164. id = ioread32(arc_ps2->addr);
  165. if (id != ARC_ARC_PS2_ID) {
  166. dev_err(&pdev->dev, "device id does not match\n");
  167. return -ENXIO;
  168. }
  169. arc_ps2_inhibit_ports(arc_ps2);
  170. error = devm_request_irq(&pdev->dev, irq, arc_ps2_interrupt,
  171. 0, "arc_ps2", arc_ps2);
  172. if (error) {
  173. dev_err(&pdev->dev, "Could not allocate IRQ\n");
  174. return error;
  175. }
  176. for (i = 0; i < ARC_PS2_PORTS; i++) {
  177. error = arc_ps2_create_port(pdev, arc_ps2, i);
  178. if (error) {
  179. while (--i >= 0)
  180. serio_unregister_port(arc_ps2->port[i].io);
  181. return error;
  182. }
  183. }
  184. platform_set_drvdata(pdev, arc_ps2);
  185. return 0;
  186. }
  187. static int arc_ps2_remove(struct platform_device *pdev)
  188. {
  189. struct arc_ps2_data *arc_ps2 = platform_get_drvdata(pdev);
  190. int i;
  191. for (i = 0; i < ARC_PS2_PORTS; i++)
  192. serio_unregister_port(arc_ps2->port[i].io);
  193. dev_dbg(&pdev->dev, "interrupt count = %i\n", arc_ps2->total_int);
  194. dev_dbg(&pdev->dev, "frame error count = %i\n", arc_ps2->frame_error);
  195. dev_dbg(&pdev->dev, "buffer overflow count = %i\n",
  196. arc_ps2->buf_overflow);
  197. return 0;
  198. }
  199. #ifdef CONFIG_OF
  200. static const struct of_device_id arc_ps2_match[] = {
  201. { .compatible = "snps,arc_ps2" },
  202. { },
  203. };
  204. MODULE_DEVICE_TABLE(of, arc_ps2_match);
  205. #endif
  206. static struct platform_driver arc_ps2_driver = {
  207. .driver = {
  208. .name = "arc_ps2",
  209. .of_match_table = of_match_ptr(arc_ps2_match),
  210. },
  211. .probe = arc_ps2_probe,
  212. .remove = arc_ps2_remove,
  213. };
  214. module_platform_driver(arc_ps2_driver);
  215. MODULE_LICENSE("GPL");
  216. MODULE_AUTHOR("Pavel Sokolov <psokolov@synopsys.com>");
  217. MODULE_DESCRIPTION("ARC PS/2 Driver");