serport.c 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312
  1. /*
  2. * Input device TTY line discipline
  3. *
  4. * Copyright (c) 1999-2002 Vojtech Pavlik
  5. *
  6. * This is a module that converts a tty line into a much simpler
  7. * 'serial io port' abstraction that the input device drivers use.
  8. */
  9. /*
  10. * This program is free software; you can redistribute it and/or modify it
  11. * under the terms of the GNU General Public License version 2 as published by
  12. * the Free Software Foundation.
  13. */
  14. #include <asm/uaccess.h>
  15. #include <linux/kernel.h>
  16. #include <linux/sched.h>
  17. #include <linux/slab.h>
  18. #include <linux/module.h>
  19. #include <linux/init.h>
  20. #include <linux/serio.h>
  21. #include <linux/tty.h>
  22. #include <linux/compat.h>
  23. MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
  24. MODULE_DESCRIPTION("Input device TTY line discipline");
  25. MODULE_LICENSE("GPL");
  26. MODULE_ALIAS_LDISC(N_MOUSE);
  27. #define SERPORT_BUSY 1
  28. #define SERPORT_ACTIVE 2
  29. #define SERPORT_DEAD 3
  30. struct serport {
  31. struct tty_struct *tty;
  32. wait_queue_head_t wait;
  33. struct serio *serio;
  34. struct serio_device_id id;
  35. spinlock_t lock;
  36. unsigned long flags;
  37. };
  38. /*
  39. * Callback functions from the serio code.
  40. */
  41. static int serport_serio_write(struct serio *serio, unsigned char data)
  42. {
  43. struct serport *serport = serio->port_data;
  44. return -(serport->tty->ops->write(serport->tty, &data, 1) != 1);
  45. }
  46. static int serport_serio_open(struct serio *serio)
  47. {
  48. struct serport *serport = serio->port_data;
  49. unsigned long flags;
  50. spin_lock_irqsave(&serport->lock, flags);
  51. set_bit(SERPORT_ACTIVE, &serport->flags);
  52. spin_unlock_irqrestore(&serport->lock, flags);
  53. return 0;
  54. }
  55. static void serport_serio_close(struct serio *serio)
  56. {
  57. struct serport *serport = serio->port_data;
  58. unsigned long flags;
  59. spin_lock_irqsave(&serport->lock, flags);
  60. clear_bit(SERPORT_ACTIVE, &serport->flags);
  61. spin_unlock_irqrestore(&serport->lock, flags);
  62. }
  63. /*
  64. * serport_ldisc_open() is the routine that is called upon setting our line
  65. * discipline on a tty. It prepares the serio struct.
  66. */
  67. static int serport_ldisc_open(struct tty_struct *tty)
  68. {
  69. struct serport *serport;
  70. if (!capable(CAP_SYS_ADMIN))
  71. return -EPERM;
  72. serport = kzalloc(sizeof(struct serport), GFP_KERNEL);
  73. if (!serport)
  74. return -ENOMEM;
  75. serport->tty = tty;
  76. spin_lock_init(&serport->lock);
  77. init_waitqueue_head(&serport->wait);
  78. tty->disc_data = serport;
  79. tty->receive_room = 256;
  80. set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
  81. return 0;
  82. }
  83. /*
  84. * serport_ldisc_close() is the opposite of serport_ldisc_open()
  85. */
  86. static void serport_ldisc_close(struct tty_struct *tty)
  87. {
  88. struct serport *serport = (struct serport *) tty->disc_data;
  89. kfree(serport);
  90. }
  91. /*
  92. * serport_ldisc_receive() is called by the low level tty driver when characters
  93. * are ready for us. We forward the characters and flags, one by one to the
  94. * 'interrupt' routine.
  95. */
  96. static void serport_ldisc_receive(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
  97. {
  98. struct serport *serport = (struct serport*) tty->disc_data;
  99. unsigned long flags;
  100. unsigned int ch_flags = 0;
  101. int i;
  102. spin_lock_irqsave(&serport->lock, flags);
  103. if (!test_bit(SERPORT_ACTIVE, &serport->flags))
  104. goto out;
  105. for (i = 0; i < count; i++) {
  106. if (fp) {
  107. switch (fp[i]) {
  108. case TTY_FRAME:
  109. ch_flags = SERIO_FRAME;
  110. break;
  111. case TTY_PARITY:
  112. ch_flags = SERIO_PARITY;
  113. break;
  114. default:
  115. ch_flags = 0;
  116. break;
  117. }
  118. }
  119. serio_interrupt(serport->serio, cp[i], ch_flags);
  120. }
  121. out:
  122. spin_unlock_irqrestore(&serport->lock, flags);
  123. }
  124. /*
  125. * serport_ldisc_read() just waits indefinitely if everything goes well.
  126. * However, when the serio driver closes the serio port, it finishes,
  127. * returning 0 characters.
  128. */
  129. static ssize_t serport_ldisc_read(struct tty_struct * tty, struct file * file, unsigned char __user * buf, size_t nr)
  130. {
  131. struct serport *serport = (struct serport*) tty->disc_data;
  132. struct serio *serio;
  133. if (test_and_set_bit(SERPORT_BUSY, &serport->flags))
  134. return -EBUSY;
  135. serport->serio = serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
  136. if (!serio)
  137. return -ENOMEM;
  138. strlcpy(serio->name, "Serial port", sizeof(serio->name));
  139. snprintf(serio->phys, sizeof(serio->phys), "%s/serio0", tty_name(tty));
  140. serio->id = serport->id;
  141. serio->id.type = SERIO_RS232;
  142. serio->write = serport_serio_write;
  143. serio->open = serport_serio_open;
  144. serio->close = serport_serio_close;
  145. serio->port_data = serport;
  146. serio->dev.parent = tty->dev;
  147. serio_register_port(serport->serio);
  148. printk(KERN_INFO "serio: Serial port %s\n", tty_name(tty));
  149. wait_event_interruptible(serport->wait, test_bit(SERPORT_DEAD, &serport->flags));
  150. serio_unregister_port(serport->serio);
  151. serport->serio = NULL;
  152. clear_bit(SERPORT_DEAD, &serport->flags);
  153. clear_bit(SERPORT_BUSY, &serport->flags);
  154. return 0;
  155. }
  156. static void serport_set_type(struct tty_struct *tty, unsigned long type)
  157. {
  158. struct serport *serport = tty->disc_data;
  159. serport->id.proto = type & 0x000000ff;
  160. serport->id.id = (type & 0x0000ff00) >> 8;
  161. serport->id.extra = (type & 0x00ff0000) >> 16;
  162. }
  163. /*
  164. * serport_ldisc_ioctl() allows to set the port protocol, and device ID
  165. */
  166. static int serport_ldisc_ioctl(struct tty_struct *tty, struct file *file,
  167. unsigned int cmd, unsigned long arg)
  168. {
  169. if (cmd == SPIOCSTYPE) {
  170. unsigned long type;
  171. if (get_user(type, (unsigned long __user *) arg))
  172. return -EFAULT;
  173. serport_set_type(tty, type);
  174. return 0;
  175. }
  176. return -EINVAL;
  177. }
  178. #ifdef CONFIG_COMPAT
  179. #define COMPAT_SPIOCSTYPE _IOW('q', 0x01, compat_ulong_t)
  180. static long serport_ldisc_compat_ioctl(struct tty_struct *tty,
  181. struct file *file,
  182. unsigned int cmd, unsigned long arg)
  183. {
  184. if (cmd == COMPAT_SPIOCSTYPE) {
  185. void __user *uarg = compat_ptr(arg);
  186. compat_ulong_t compat_type;
  187. if (get_user(compat_type, (compat_ulong_t __user *)uarg))
  188. return -EFAULT;
  189. serport_set_type(tty, compat_type);
  190. return 0;
  191. }
  192. return -EINVAL;
  193. }
  194. #endif
  195. static int serport_ldisc_hangup(struct tty_struct *tty)
  196. {
  197. struct serport *serport = (struct serport *) tty->disc_data;
  198. unsigned long flags;
  199. spin_lock_irqsave(&serport->lock, flags);
  200. set_bit(SERPORT_DEAD, &serport->flags);
  201. spin_unlock_irqrestore(&serport->lock, flags);
  202. wake_up_interruptible(&serport->wait);
  203. return 0;
  204. }
  205. static void serport_ldisc_write_wakeup(struct tty_struct * tty)
  206. {
  207. struct serport *serport = (struct serport *) tty->disc_data;
  208. unsigned long flags;
  209. spin_lock_irqsave(&serport->lock, flags);
  210. if (test_bit(SERPORT_ACTIVE, &serport->flags))
  211. serio_drv_write_wakeup(serport->serio);
  212. spin_unlock_irqrestore(&serport->lock, flags);
  213. }
  214. /*
  215. * The line discipline structure.
  216. */
  217. static struct tty_ldisc_ops serport_ldisc = {
  218. .owner = THIS_MODULE,
  219. .name = "input",
  220. .open = serport_ldisc_open,
  221. .close = serport_ldisc_close,
  222. .read = serport_ldisc_read,
  223. .ioctl = serport_ldisc_ioctl,
  224. #ifdef CONFIG_COMPAT
  225. .compat_ioctl = serport_ldisc_compat_ioctl,
  226. #endif
  227. .receive_buf = serport_ldisc_receive,
  228. .hangup = serport_ldisc_hangup,
  229. .write_wakeup = serport_ldisc_write_wakeup
  230. };
  231. /*
  232. * The functions for insering/removing us as a module.
  233. */
  234. static int __init serport_init(void)
  235. {
  236. int retval;
  237. retval = tty_register_ldisc(N_MOUSE, &serport_ldisc);
  238. if (retval)
  239. printk(KERN_ERR "serport.c: Error registering line discipline.\n");
  240. return retval;
  241. }
  242. static void __exit serport_exit(void)
  243. {
  244. tty_unregister_ldisc(N_MOUSE);
  245. }
  246. module_init(serport_init);
  247. module_exit(serport_exit);