1 // SPDX-License-Identifier: GPL-2.0-only
3 * Input device TTY line discipline
5 * Copyright (c) 1999-2002 Vojtech Pavlik
7 * This is a module that converts a tty line into a much simpler
8 * 'serial io port' abstraction that the input device drivers use.
12 #include <linux/uaccess.h>
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
15 #include <linux/slab.h>
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/serio.h>
19 #include <linux/tty.h>
20 #include <linux/compat.h>
22 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
23 MODULE_DESCRIPTION("Input device TTY line discipline");
24 MODULE_LICENSE("GPL");
25 MODULE_ALIAS_LDISC(N_MOUSE
);
27 #define SERPORT_BUSY 1
28 #define SERPORT_ACTIVE 2
29 #define SERPORT_DEAD 3
32 struct tty_struct
*tty
;
33 wait_queue_head_t wait
;
35 struct serio_device_id id
;
41 * Callback functions from the serio code.
44 static int serport_serio_write(struct serio
*serio
, unsigned char data
)
46 struct serport
*serport
= serio
->port_data
;
47 return -(serport
->tty
->ops
->write(serport
->tty
, &data
, 1) != 1);
50 static int serport_serio_open(struct serio
*serio
)
52 struct serport
*serport
= serio
->port_data
;
55 spin_lock_irqsave(&serport
->lock
, flags
);
56 set_bit(SERPORT_ACTIVE
, &serport
->flags
);
57 spin_unlock_irqrestore(&serport
->lock
, flags
);
63 static void serport_serio_close(struct serio
*serio
)
65 struct serport
*serport
= serio
->port_data
;
68 spin_lock_irqsave(&serport
->lock
, flags
);
69 clear_bit(SERPORT_ACTIVE
, &serport
->flags
);
70 spin_unlock_irqrestore(&serport
->lock
, flags
);
74 * serport_ldisc_open() is the routine that is called upon setting our line
75 * discipline on a tty. It prepares the serio struct.
78 static int serport_ldisc_open(struct tty_struct
*tty
)
80 struct serport
*serport
;
82 if (!capable(CAP_SYS_ADMIN
))
85 serport
= kzalloc(sizeof(*serport
), GFP_KERNEL
);
90 spin_lock_init(&serport
->lock
);
91 init_waitqueue_head(&serport
->wait
);
93 tty
->disc_data
= serport
;
94 tty
->receive_room
= 256;
95 set_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
101 * serport_ldisc_close() is the opposite of serport_ldisc_open()
104 static void serport_ldisc_close(struct tty_struct
*tty
)
106 struct serport
*serport
= tty
->disc_data
;
112 * serport_ldisc_receive() is called by the low level tty driver when characters
113 * are ready for us. We forward the characters and flags, one by one to the
114 * 'interrupt' routine.
117 static void serport_ldisc_receive(struct tty_struct
*tty
, const u8
*cp
,
118 const u8
*fp
, size_t count
)
120 struct serport
*serport
= tty
->disc_data
;
122 unsigned int ch_flags
= 0;
125 spin_lock_irqsave(&serport
->lock
, flags
);
127 if (!test_bit(SERPORT_ACTIVE
, &serport
->flags
))
130 for (i
= 0; i
< count
; i
++) {
134 ch_flags
= SERIO_FRAME
;
138 ch_flags
= SERIO_PARITY
;
147 serio_interrupt(serport
->serio
, cp
[i
], ch_flags
);
151 spin_unlock_irqrestore(&serport
->lock
, flags
);
155 * serport_ldisc_read() just waits indefinitely if everything goes well.
156 * However, when the serio driver closes the serio port, it finishes,
157 * returning 0 characters.
160 static ssize_t
serport_ldisc_read(struct tty_struct
* tty
, struct file
* file
,
161 u8
*kbuf
, size_t nr
, void **cookie
,
162 unsigned long offset
)
164 struct serport
*serport
= tty
->disc_data
;
167 if (test_and_set_bit(SERPORT_BUSY
, &serport
->flags
))
170 serport
->serio
= serio
= kzalloc(sizeof(*serio
), GFP_KERNEL
);
174 strscpy(serio
->name
, "Serial port", sizeof(serio
->name
));
175 snprintf(serio
->phys
, sizeof(serio
->phys
), "%s/serio0", tty_name(tty
));
176 serio
->id
= serport
->id
;
177 serio
->id
.type
= SERIO_RS232
;
178 serio
->write
= serport_serio_write
;
179 serio
->open
= serport_serio_open
;
180 serio
->close
= serport_serio_close
;
181 serio
->port_data
= serport
;
182 serio
->dev
.parent
= tty
->dev
;
184 serio_register_port(serport
->serio
);
185 printk(KERN_INFO
"serio: Serial port %s\n", tty_name(tty
));
187 wait_event_interruptible(serport
->wait
, test_bit(SERPORT_DEAD
, &serport
->flags
));
188 serio_unregister_port(serport
->serio
);
189 serport
->serio
= NULL
;
191 clear_bit(SERPORT_DEAD
, &serport
->flags
);
192 clear_bit(SERPORT_BUSY
, &serport
->flags
);
197 static void serport_set_type(struct tty_struct
*tty
, unsigned long type
)
199 struct serport
*serport
= tty
->disc_data
;
201 serport
->id
.proto
= type
& 0x000000ff;
202 serport
->id
.id
= (type
& 0x0000ff00) >> 8;
203 serport
->id
.extra
= (type
& 0x00ff0000) >> 16;
207 * serport_ldisc_ioctl() allows to set the port protocol, and device ID
210 static int serport_ldisc_ioctl(struct tty_struct
*tty
, unsigned int cmd
,
213 if (cmd
== SPIOCSTYPE
) {
216 if (get_user(type
, (unsigned long __user
*) arg
))
219 serport_set_type(tty
, type
);
227 #define COMPAT_SPIOCSTYPE _IOW('q', 0x01, compat_ulong_t)
228 static int serport_ldisc_compat_ioctl(struct tty_struct
*tty
,
229 unsigned int cmd
, unsigned long arg
)
231 if (cmd
== COMPAT_SPIOCSTYPE
) {
232 void __user
*uarg
= compat_ptr(arg
);
233 compat_ulong_t compat_type
;
235 if (get_user(compat_type
, (compat_ulong_t __user
*)uarg
))
238 serport_set_type(tty
, compat_type
);
246 static void serport_ldisc_hangup(struct tty_struct
*tty
)
248 struct serport
*serport
= tty
->disc_data
;
251 spin_lock_irqsave(&serport
->lock
, flags
);
252 set_bit(SERPORT_DEAD
, &serport
->flags
);
253 spin_unlock_irqrestore(&serport
->lock
, flags
);
255 wake_up_interruptible(&serport
->wait
);
258 static void serport_ldisc_write_wakeup(struct tty_struct
* tty
)
260 struct serport
*serport
= tty
->disc_data
;
263 spin_lock_irqsave(&serport
->lock
, flags
);
264 if (test_bit(SERPORT_ACTIVE
, &serport
->flags
))
265 serio_drv_write_wakeup(serport
->serio
);
266 spin_unlock_irqrestore(&serport
->lock
, flags
);
270 * The line discipline structure.
273 static struct tty_ldisc_ops serport_ldisc
= {
274 .owner
= THIS_MODULE
,
277 .open
= serport_ldisc_open
,
278 .close
= serport_ldisc_close
,
279 .read
= serport_ldisc_read
,
280 .ioctl
= serport_ldisc_ioctl
,
282 .compat_ioctl
= serport_ldisc_compat_ioctl
,
284 .receive_buf
= serport_ldisc_receive
,
285 .hangup
= serport_ldisc_hangup
,
286 .write_wakeup
= serport_ldisc_write_wakeup
290 * The functions for insering/removing us as a module.
293 static int __init
serport_init(void)
296 retval
= tty_register_ldisc(&serport_ldisc
);
298 printk(KERN_ERR
"serport.c: Error registering line discipline.\n");
303 static void __exit
serport_exit(void)
305 tty_unregister_ldisc(&serport_ldisc
);
308 module_init(serport_init
);
309 module_exit(serport_exit
);