pcips2.c 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * linux/drivers/input/serio/pcips2.c
  4. *
  5. * Copyright (C) 2003 Russell King, All Rights Reserved.
  6. *
  7. * I'm not sure if this is a generic PS/2 PCI interface or specific to
  8. * the Mobility Electronics docking station.
  9. */
  10. #include <linux/module.h>
  11. #include <linux/interrupt.h>
  12. #include <linux/ioport.h>
  13. #include <linux/input.h>
  14. #include <linux/pci.h>
  15. #include <linux/slab.h>
  16. #include <linux/serio.h>
  17. #include <linux/delay.h>
  18. #include <asm/io.h>
  19. #define PS2_CTRL (0)
  20. #define PS2_STATUS (1)
  21. #define PS2_DATA (2)
  22. #define PS2_CTRL_CLK (1<<0)
  23. #define PS2_CTRL_DAT (1<<1)
  24. #define PS2_CTRL_TXIRQ (1<<2)
  25. #define PS2_CTRL_ENABLE (1<<3)
  26. #define PS2_CTRL_RXIRQ (1<<4)
  27. #define PS2_STAT_CLK (1<<0)
  28. #define PS2_STAT_DAT (1<<1)
  29. #define PS2_STAT_PARITY (1<<2)
  30. #define PS2_STAT_RXFULL (1<<5)
  31. #define PS2_STAT_TXBUSY (1<<6)
  32. #define PS2_STAT_TXEMPTY (1<<7)
  33. struct pcips2_data {
  34. struct serio *io;
  35. unsigned int base;
  36. struct pci_dev *dev;
  37. };
  38. static int pcips2_write(struct serio *io, unsigned char val)
  39. {
  40. struct pcips2_data *ps2if = io->port_data;
  41. unsigned int stat;
  42. do {
  43. stat = inb(ps2if->base + PS2_STATUS);
  44. cpu_relax();
  45. } while (!(stat & PS2_STAT_TXEMPTY));
  46. outb(val, ps2if->base + PS2_DATA);
  47. return 0;
  48. }
  49. static irqreturn_t pcips2_interrupt(int irq, void *devid)
  50. {
  51. struct pcips2_data *ps2if = devid;
  52. unsigned char status, scancode;
  53. int handled = 0;
  54. do {
  55. unsigned int flag;
  56. status = inb(ps2if->base + PS2_STATUS);
  57. if (!(status & PS2_STAT_RXFULL))
  58. break;
  59. handled = 1;
  60. scancode = inb(ps2if->base + PS2_DATA);
  61. if (status == 0xff && scancode == 0xff)
  62. break;
  63. flag = (status & PS2_STAT_PARITY) ? 0 : SERIO_PARITY;
  64. if (hweight8(scancode) & 1)
  65. flag ^= SERIO_PARITY;
  66. serio_interrupt(ps2if->io, scancode, flag);
  67. } while (1);
  68. return IRQ_RETVAL(handled);
  69. }
  70. static void pcips2_flush_input(struct pcips2_data *ps2if)
  71. {
  72. unsigned char status, scancode;
  73. do {
  74. status = inb(ps2if->base + PS2_STATUS);
  75. if (!(status & PS2_STAT_RXFULL))
  76. break;
  77. scancode = inb(ps2if->base + PS2_DATA);
  78. if (status == 0xff && scancode == 0xff)
  79. break;
  80. } while (1);
  81. }
  82. static int pcips2_open(struct serio *io)
  83. {
  84. struct pcips2_data *ps2if = io->port_data;
  85. int ret, val = 0;
  86. outb(PS2_CTRL_ENABLE, ps2if->base);
  87. pcips2_flush_input(ps2if);
  88. ret = request_irq(ps2if->dev->irq, pcips2_interrupt, IRQF_SHARED,
  89. "pcips2", ps2if);
  90. if (ret == 0)
  91. val = PS2_CTRL_ENABLE | PS2_CTRL_RXIRQ;
  92. outb(val, ps2if->base);
  93. return ret;
  94. }
  95. static void pcips2_close(struct serio *io)
  96. {
  97. struct pcips2_data *ps2if = io->port_data;
  98. outb(0, ps2if->base);
  99. free_irq(ps2if->dev->irq, ps2if);
  100. }
  101. static int pcips2_probe(struct pci_dev *dev, const struct pci_device_id *id)
  102. {
  103. struct pcips2_data *ps2if;
  104. struct serio *serio;
  105. int ret;
  106. ret = pci_enable_device(dev);
  107. if (ret)
  108. goto out;
  109. ret = pci_request_regions(dev, "pcips2");
  110. if (ret)
  111. goto disable;
  112. ps2if = kzalloc(sizeof(struct pcips2_data), GFP_KERNEL);
  113. serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
  114. if (!ps2if || !serio) {
  115. ret = -ENOMEM;
  116. goto release;
  117. }
  118. serio->id.type = SERIO_8042;
  119. serio->write = pcips2_write;
  120. serio->open = pcips2_open;
  121. serio->close = pcips2_close;
  122. strlcpy(serio->name, pci_name(dev), sizeof(serio->name));
  123. strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys));
  124. serio->port_data = ps2if;
  125. serio->dev.parent = &dev->dev;
  126. ps2if->io = serio;
  127. ps2if->dev = dev;
  128. ps2if->base = pci_resource_start(dev, 0);
  129. pci_set_drvdata(dev, ps2if);
  130. serio_register_port(ps2if->io);
  131. return 0;
  132. release:
  133. kfree(ps2if);
  134. kfree(serio);
  135. pci_release_regions(dev);
  136. disable:
  137. pci_disable_device(dev);
  138. out:
  139. return ret;
  140. }
  141. static void pcips2_remove(struct pci_dev *dev)
  142. {
  143. struct pcips2_data *ps2if = pci_get_drvdata(dev);
  144. serio_unregister_port(ps2if->io);
  145. kfree(ps2if);
  146. pci_release_regions(dev);
  147. pci_disable_device(dev);
  148. }
  149. static const struct pci_device_id pcips2_ids[] = {
  150. {
  151. .vendor = 0x14f2, /* MOBILITY */
  152. .device = 0x0123, /* Keyboard */
  153. .subvendor = PCI_ANY_ID,
  154. .subdevice = PCI_ANY_ID,
  155. .class = PCI_CLASS_INPUT_KEYBOARD << 8,
  156. .class_mask = 0xffff00,
  157. },
  158. {
  159. .vendor = 0x14f2, /* MOBILITY */
  160. .device = 0x0124, /* Mouse */
  161. .subvendor = PCI_ANY_ID,
  162. .subdevice = PCI_ANY_ID,
  163. .class = PCI_CLASS_INPUT_MOUSE << 8,
  164. .class_mask = 0xffff00,
  165. },
  166. { 0, }
  167. };
  168. MODULE_DEVICE_TABLE(pci, pcips2_ids);
  169. static struct pci_driver pcips2_driver = {
  170. .name = "pcips2",
  171. .id_table = pcips2_ids,
  172. .probe = pcips2_probe,
  173. .remove = pcips2_remove,
  174. };
  175. module_pci_driver(pcips2_driver);
  176. MODULE_LICENSE("GPL");
  177. MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
  178. MODULE_DESCRIPTION("PCI PS/2 keyboard/mouse driver");