q40kbd.c 3.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (c) 2000-2001 Vojtech Pavlik
  4. *
  5. * Based on the work of:
  6. * Richard Zidlicky <Richard.Zidlicky@stud.informatik.uni-erlangen.de>
  7. */
  8. /*
  9. * Q40 PS/2 keyboard controller driver for Linux/m68k
  10. */
  11. /*
  12. */
  13. #include <linux/module.h>
  14. #include <linux/serio.h>
  15. #include <linux/interrupt.h>
  16. #include <linux/err.h>
  17. #include <linux/bitops.h>
  18. #include <linux/platform_device.h>
  19. #include <linux/slab.h>
  20. #include <asm/io.h>
  21. #include <linux/uaccess.h>
  22. #include <asm/q40_master.h>
  23. #include <asm/irq.h>
  24. #include <asm/q40ints.h>
  25. #define DRV_NAME "q40kbd"
  26. MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
  27. MODULE_DESCRIPTION("Q40 PS/2 keyboard controller driver");
  28. MODULE_LICENSE("GPL");
  29. MODULE_ALIAS("platform:" DRV_NAME);
  30. struct q40kbd {
  31. struct serio *port;
  32. spinlock_t lock;
  33. };
  34. static irqreturn_t q40kbd_interrupt(int irq, void *dev_id)
  35. {
  36. struct q40kbd *q40kbd = dev_id;
  37. unsigned long flags;
  38. spin_lock_irqsave(&q40kbd->lock, flags);
  39. if (Q40_IRQ_KEYB_MASK & master_inb(INTERRUPT_REG))
  40. serio_interrupt(q40kbd->port, master_inb(KEYCODE_REG), 0);
  41. master_outb(-1, KEYBOARD_UNLOCK_REG);
  42. spin_unlock_irqrestore(&q40kbd->lock, flags);
  43. return IRQ_HANDLED;
  44. }
  45. /*
  46. * q40kbd_flush() flushes all data that may be in the keyboard buffers
  47. */
  48. static void q40kbd_flush(struct q40kbd *q40kbd)
  49. {
  50. int maxread = 100;
  51. unsigned long flags;
  52. spin_lock_irqsave(&q40kbd->lock, flags);
  53. while (maxread-- && (Q40_IRQ_KEYB_MASK & master_inb(INTERRUPT_REG)))
  54. master_inb(KEYCODE_REG);
  55. spin_unlock_irqrestore(&q40kbd->lock, flags);
  56. }
  57. static void q40kbd_stop(void)
  58. {
  59. master_outb(0, KEY_IRQ_ENABLE_REG);
  60. master_outb(-1, KEYBOARD_UNLOCK_REG);
  61. }
  62. /*
  63. * q40kbd_open() is called when a port is open by the higher layer.
  64. * It allocates the interrupt and enables in in the chip.
  65. */
  66. static int q40kbd_open(struct serio *port)
  67. {
  68. struct q40kbd *q40kbd = port->port_data;
  69. q40kbd_flush(q40kbd);
  70. /* off we go */
  71. master_outb(-1, KEYBOARD_UNLOCK_REG);
  72. master_outb(1, KEY_IRQ_ENABLE_REG);
  73. return 0;
  74. }
  75. static void q40kbd_close(struct serio *port)
  76. {
  77. struct q40kbd *q40kbd = port->port_data;
  78. q40kbd_stop();
  79. q40kbd_flush(q40kbd);
  80. }
  81. static int q40kbd_probe(struct platform_device *pdev)
  82. {
  83. struct q40kbd *q40kbd;
  84. struct serio *port;
  85. int error;
  86. q40kbd = kzalloc(sizeof(struct q40kbd), GFP_KERNEL);
  87. port = kzalloc(sizeof(struct serio), GFP_KERNEL);
  88. if (!q40kbd || !port) {
  89. error = -ENOMEM;
  90. goto err_free_mem;
  91. }
  92. q40kbd->port = port;
  93. spin_lock_init(&q40kbd->lock);
  94. port->id.type = SERIO_8042;
  95. port->open = q40kbd_open;
  96. port->close = q40kbd_close;
  97. port->port_data = q40kbd;
  98. port->dev.parent = &pdev->dev;
  99. strlcpy(port->name, "Q40 Kbd Port", sizeof(port->name));
  100. strlcpy(port->phys, "Q40", sizeof(port->phys));
  101. q40kbd_stop();
  102. error = request_irq(Q40_IRQ_KEYBOARD, q40kbd_interrupt, 0,
  103. DRV_NAME, q40kbd);
  104. if (error) {
  105. dev_err(&pdev->dev, "Can't get irq %d.\n", Q40_IRQ_KEYBOARD);
  106. goto err_free_mem;
  107. }
  108. serio_register_port(q40kbd->port);
  109. platform_set_drvdata(pdev, q40kbd);
  110. printk(KERN_INFO "serio: Q40 kbd registered\n");
  111. return 0;
  112. err_free_mem:
  113. kfree(port);
  114. kfree(q40kbd);
  115. return error;
  116. }
  117. static int q40kbd_remove(struct platform_device *pdev)
  118. {
  119. struct q40kbd *q40kbd = platform_get_drvdata(pdev);
  120. /*
  121. * q40kbd_close() will be called as part of unregistering
  122. * and will ensure that IRQ is turned off, so it is safe
  123. * to unregister port first and free IRQ later.
  124. */
  125. serio_unregister_port(q40kbd->port);
  126. free_irq(Q40_IRQ_KEYBOARD, q40kbd);
  127. kfree(q40kbd);
  128. return 0;
  129. }
  130. static struct platform_driver q40kbd_driver = {
  131. .driver = {
  132. .name = "q40kbd",
  133. },
  134. .remove = q40kbd_remove,
  135. };
  136. module_platform_driver_probe(q40kbd_driver, q40kbd_probe);