xref: /openbmc/linux/drivers/tty/tty_port.c (revision 3e26a691)
1 /*
2  * Tty port functions
3  */
4 
5 #include <linux/types.h>
6 #include <linux/errno.h>
7 #include <linux/tty.h>
8 #include <linux/tty_driver.h>
9 #include <linux/tty_flip.h>
10 #include <linux/serial.h>
11 #include <linux/timer.h>
12 #include <linux/string.h>
13 #include <linux/slab.h>
14 #include <linux/sched.h>
15 #include <linux/wait.h>
16 #include <linux/bitops.h>
17 #include <linux/delay.h>
18 #include <linux/module.h>
19 
20 void tty_port_init(struct tty_port *port)
21 {
22 	memset(port, 0, sizeof(*port));
23 	tty_buffer_init(port);
24 	init_waitqueue_head(&port->open_wait);
25 	init_waitqueue_head(&port->delta_msr_wait);
26 	mutex_init(&port->mutex);
27 	mutex_init(&port->buf_mutex);
28 	spin_lock_init(&port->lock);
29 	port->close_delay = (50 * HZ) / 100;
30 	port->closing_wait = (3000 * HZ) / 100;
31 	kref_init(&port->kref);
32 }
33 EXPORT_SYMBOL(tty_port_init);
34 
35 /**
36  * tty_port_link_device - link tty and tty_port
37  * @port: tty_port of the device
38  * @driver: tty_driver for this device
39  * @index: index of the tty
40  *
41  * Provide the tty layer wit ha link from a tty (specified by @index) to a
42  * tty_port (@port). Use this only if neither tty_port_register_device nor
43  * tty_port_install is used in the driver. If used, this has to be called before
44  * tty_register_driver.
45  */
46 void tty_port_link_device(struct tty_port *port,
47 		struct tty_driver *driver, unsigned index)
48 {
49 	if (WARN_ON(index >= driver->num))
50 		return;
51 	driver->ports[index] = port;
52 }
53 EXPORT_SYMBOL_GPL(tty_port_link_device);
54 
55 /**
56  * tty_port_register_device - register tty device
57  * @port: tty_port of the device
58  * @driver: tty_driver for this device
59  * @index: index of the tty
60  * @device: parent if exists, otherwise NULL
61  *
62  * It is the same as tty_register_device except the provided @port is linked to
63  * a concrete tty specified by @index. Use this or tty_port_install (or both).
64  * Call tty_port_link_device as a last resort.
65  */
66 struct device *tty_port_register_device(struct tty_port *port,
67 		struct tty_driver *driver, unsigned index,
68 		struct device *device)
69 {
70 	tty_port_link_device(port, driver, index);
71 	return tty_register_device(driver, index, device);
72 }
73 EXPORT_SYMBOL_GPL(tty_port_register_device);
74 
75 /**
76  * tty_port_register_device_attr - register tty device
77  * @port: tty_port of the device
78  * @driver: tty_driver for this device
79  * @index: index of the tty
80  * @device: parent if exists, otherwise NULL
81  * @drvdata: Driver data to be set to device.
82  * @attr_grp: Attribute group to be set on device.
83  *
84  * It is the same as tty_register_device_attr except the provided @port is
85  * linked to a concrete tty specified by @index. Use this or tty_port_install
86  * (or both). Call tty_port_link_device as a last resort.
87  */
88 struct device *tty_port_register_device_attr(struct tty_port *port,
89 		struct tty_driver *driver, unsigned index,
90 		struct device *device, void *drvdata,
91 		const struct attribute_group **attr_grp)
92 {
93 	tty_port_link_device(port, driver, index);
94 	return tty_register_device_attr(driver, index, device, drvdata,
95 			attr_grp);
96 }
97 EXPORT_SYMBOL_GPL(tty_port_register_device_attr);
98 
99 int tty_port_alloc_xmit_buf(struct tty_port *port)
100 {
101 	/* We may sleep in get_zeroed_page() */
102 	mutex_lock(&port->buf_mutex);
103 	if (port->xmit_buf == NULL)
104 		port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
105 	mutex_unlock(&port->buf_mutex);
106 	if (port->xmit_buf == NULL)
107 		return -ENOMEM;
108 	return 0;
109 }
110 EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
111 
112 void tty_port_free_xmit_buf(struct tty_port *port)
113 {
114 	mutex_lock(&port->buf_mutex);
115 	if (port->xmit_buf != NULL) {
116 		free_page((unsigned long)port->xmit_buf);
117 		port->xmit_buf = NULL;
118 	}
119 	mutex_unlock(&port->buf_mutex);
120 }
121 EXPORT_SYMBOL(tty_port_free_xmit_buf);
122 
123 /**
124  * tty_port_destroy -- destroy inited port
125  * @port: tty port to be doestroyed
126  *
127  * When a port was initialized using tty_port_init, one has to destroy the
128  * port by this function. Either indirectly by using tty_port refcounting
129  * (tty_port_put) or directly if refcounting is not used.
130  */
131 void tty_port_destroy(struct tty_port *port)
132 {
133 	tty_buffer_cancel_work(port);
134 	tty_buffer_free_all(port);
135 }
136 EXPORT_SYMBOL(tty_port_destroy);
137 
138 static void tty_port_destructor(struct kref *kref)
139 {
140 	struct tty_port *port = container_of(kref, struct tty_port, kref);
141 
142 	/* check if last port ref was dropped before tty release */
143 	if (WARN_ON(port->itty))
144 		return;
145 	if (port->xmit_buf)
146 		free_page((unsigned long)port->xmit_buf);
147 	tty_port_destroy(port);
148 	if (port->ops && port->ops->destruct)
149 		port->ops->destruct(port);
150 	else
151 		kfree(port);
152 }
153 
154 void tty_port_put(struct tty_port *port)
155 {
156 	if (port)
157 		kref_put(&port->kref, tty_port_destructor);
158 }
159 EXPORT_SYMBOL(tty_port_put);
160 
161 /**
162  *	tty_port_tty_get	-	get a tty reference
163  *	@port: tty port
164  *
165  *	Return a refcount protected tty instance or NULL if the port is not
166  *	associated with a tty (eg due to close or hangup)
167  */
168 
169 struct tty_struct *tty_port_tty_get(struct tty_port *port)
170 {
171 	unsigned long flags;
172 	struct tty_struct *tty;
173 
174 	spin_lock_irqsave(&port->lock, flags);
175 	tty = tty_kref_get(port->tty);
176 	spin_unlock_irqrestore(&port->lock, flags);
177 	return tty;
178 }
179 EXPORT_SYMBOL(tty_port_tty_get);
180 
181 /**
182  *	tty_port_tty_set	-	set the tty of a port
183  *	@port: tty port
184  *	@tty: the tty
185  *
186  *	Associate the port and tty pair. Manages any internal refcounts.
187  *	Pass NULL to deassociate a port
188  */
189 
190 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
191 {
192 	unsigned long flags;
193 
194 	spin_lock_irqsave(&port->lock, flags);
195 	tty_kref_put(port->tty);
196 	port->tty = tty_kref_get(tty);
197 	spin_unlock_irqrestore(&port->lock, flags);
198 }
199 EXPORT_SYMBOL(tty_port_tty_set);
200 
201 static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
202 {
203 	mutex_lock(&port->mutex);
204 	if (port->console)
205 		goto out;
206 
207 	if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
208 		/*
209 		 * Drop DTR/RTS if HUPCL is set. This causes any attached
210 		 * modem to hang up the line.
211 		 */
212 		if (tty && C_HUPCL(tty))
213 			tty_port_lower_dtr_rts(port);
214 
215 		if (port->ops->shutdown)
216 			port->ops->shutdown(port);
217 	}
218 out:
219 	mutex_unlock(&port->mutex);
220 }
221 
222 /**
223  *	tty_port_hangup		-	hangup helper
224  *	@port: tty port
225  *
226  *	Perform port level tty hangup flag and count changes. Drop the tty
227  *	reference.
228  *
229  *	Caller holds tty lock.
230  */
231 
232 void tty_port_hangup(struct tty_port *port)
233 {
234 	struct tty_struct *tty;
235 	unsigned long flags;
236 
237 	spin_lock_irqsave(&port->lock, flags);
238 	port->count = 0;
239 	port->flags &= ~ASYNC_NORMAL_ACTIVE;
240 	tty = port->tty;
241 	if (tty)
242 		set_bit(TTY_IO_ERROR, &tty->flags);
243 	port->tty = NULL;
244 	spin_unlock_irqrestore(&port->lock, flags);
245 	tty_port_shutdown(port, tty);
246 	tty_kref_put(tty);
247 	wake_up_interruptible(&port->open_wait);
248 	wake_up_interruptible(&port->delta_msr_wait);
249 }
250 EXPORT_SYMBOL(tty_port_hangup);
251 
252 /**
253  * tty_port_tty_hangup - helper to hang up a tty
254  *
255  * @port: tty port
256  * @check_clocal: hang only ttys with CLOCAL unset?
257  */
258 void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
259 {
260 	struct tty_struct *tty = tty_port_tty_get(port);
261 
262 	if (tty && (!check_clocal || !C_CLOCAL(tty)))
263 		tty_hangup(tty);
264 	tty_kref_put(tty);
265 }
266 EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
267 
268 /**
269  * tty_port_tty_wakeup - helper to wake up a tty
270  *
271  * @port: tty port
272  */
273 void tty_port_tty_wakeup(struct tty_port *port)
274 {
275 	struct tty_struct *tty = tty_port_tty_get(port);
276 
277 	if (tty) {
278 		tty_wakeup(tty);
279 		tty_kref_put(tty);
280 	}
281 }
282 EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
283 
284 /**
285  *	tty_port_carrier_raised	-	carrier raised check
286  *	@port: tty port
287  *
288  *	Wrapper for the carrier detect logic. For the moment this is used
289  *	to hide some internal details. This will eventually become entirely
290  *	internal to the tty port.
291  */
292 
293 int tty_port_carrier_raised(struct tty_port *port)
294 {
295 	if (port->ops->carrier_raised == NULL)
296 		return 1;
297 	return port->ops->carrier_raised(port);
298 }
299 EXPORT_SYMBOL(tty_port_carrier_raised);
300 
301 /**
302  *	tty_port_raise_dtr_rts	-	Raise DTR/RTS
303  *	@port: tty port
304  *
305  *	Wrapper for the DTR/RTS raise logic. For the moment this is used
306  *	to hide some internal details. This will eventually become entirely
307  *	internal to the tty port.
308  */
309 
310 void tty_port_raise_dtr_rts(struct tty_port *port)
311 {
312 	if (port->ops->dtr_rts)
313 		port->ops->dtr_rts(port, 1);
314 }
315 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
316 
317 /**
318  *	tty_port_lower_dtr_rts	-	Lower DTR/RTS
319  *	@port: tty port
320  *
321  *	Wrapper for the DTR/RTS raise logic. For the moment this is used
322  *	to hide some internal details. This will eventually become entirely
323  *	internal to the tty port.
324  */
325 
326 void tty_port_lower_dtr_rts(struct tty_port *port)
327 {
328 	if (port->ops->dtr_rts)
329 		port->ops->dtr_rts(port, 0);
330 }
331 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
332 
333 /**
334  *	tty_port_block_til_ready	-	Waiting logic for tty open
335  *	@port: the tty port being opened
336  *	@tty: the tty device being bound
337  *	@filp: the file pointer of the opener
338  *
339  *	Implement the core POSIX/SuS tty behaviour when opening a tty device.
340  *	Handles:
341  *		- hangup (both before and during)
342  *		- non blocking open
343  *		- rts/dtr/dcd
344  *		- signals
345  *		- port flags and counts
346  *
347  *	The passed tty_port must implement the carrier_raised method if it can
348  *	do carrier detect and the dtr_rts method if it supports software
349  *	management of these lines. Note that the dtr/rts raise is done each
350  *	iteration as a hangup may have previously dropped them while we wait.
351  *
352  *	Caller holds tty lock.
353  *
354  *      NB: May drop and reacquire tty lock when blocking, so tty and tty_port
355  *      may have changed state (eg., may have been hung up).
356  */
357 
358 int tty_port_block_til_ready(struct tty_port *port,
359 				struct tty_struct *tty, struct file *filp)
360 {
361 	int do_clocal = 0, retval;
362 	unsigned long flags;
363 	DEFINE_WAIT(wait);
364 
365 	/* if non-blocking mode is set we can pass directly to open unless
366 	   the port has just hung up or is in another error state */
367 	if (tty->flags & (1 << TTY_IO_ERROR)) {
368 		port->flags |= ASYNC_NORMAL_ACTIVE;
369 		return 0;
370 	}
371 	if (filp->f_flags & O_NONBLOCK) {
372 		/* Indicate we are open */
373 		if (C_BAUD(tty))
374 			tty_port_raise_dtr_rts(port);
375 		port->flags |= ASYNC_NORMAL_ACTIVE;
376 		return 0;
377 	}
378 
379 	if (C_CLOCAL(tty))
380 		do_clocal = 1;
381 
382 	/* Block waiting until we can proceed. We may need to wait for the
383 	   carrier, but we must also wait for any close that is in progress
384 	   before the next open may complete */
385 
386 	retval = 0;
387 
388 	/* The port lock protects the port counts */
389 	spin_lock_irqsave(&port->lock, flags);
390 	port->count--;
391 	port->blocked_open++;
392 	spin_unlock_irqrestore(&port->lock, flags);
393 
394 	while (1) {
395 		/* Indicate we are open */
396 		if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
397 			tty_port_raise_dtr_rts(port);
398 
399 		prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
400 		/* Check for a hangup or uninitialised port.
401 							Return accordingly */
402 		if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
403 			if (port->flags & ASYNC_HUP_NOTIFY)
404 				retval = -EAGAIN;
405 			else
406 				retval = -ERESTARTSYS;
407 			break;
408 		}
409 		/*
410 		 * Probe the carrier. For devices with no carrier detect
411 		 * tty_port_carrier_raised will always return true.
412 		 * Never ask drivers if CLOCAL is set, this causes troubles
413 		 * on some hardware.
414 		 */
415 		if (do_clocal || tty_port_carrier_raised(port))
416 			break;
417 		if (signal_pending(current)) {
418 			retval = -ERESTARTSYS;
419 			break;
420 		}
421 		tty_unlock(tty);
422 		schedule();
423 		tty_lock(tty);
424 	}
425 	finish_wait(&port->open_wait, &wait);
426 
427 	/* Update counts. A parallel hangup will have set count to zero and
428 	   we must not mess that up further */
429 	spin_lock_irqsave(&port->lock, flags);
430 	if (!tty_hung_up_p(filp))
431 		port->count++;
432 	port->blocked_open--;
433 	if (retval == 0)
434 		port->flags |= ASYNC_NORMAL_ACTIVE;
435 	spin_unlock_irqrestore(&port->lock, flags);
436 	return retval;
437 }
438 EXPORT_SYMBOL(tty_port_block_til_ready);
439 
440 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
441 {
442 	unsigned int bps = tty_get_baud_rate(tty);
443 	long timeout;
444 
445 	if (bps > 1200) {
446 		timeout = (HZ * 10 * port->drain_delay) / bps;
447 		timeout = max_t(long, timeout, HZ / 10);
448 	} else {
449 		timeout = 2 * HZ;
450 	}
451 	schedule_timeout_interruptible(timeout);
452 }
453 
454 /* Caller holds tty lock. */
455 int tty_port_close_start(struct tty_port *port,
456 				struct tty_struct *tty, struct file *filp)
457 {
458 	unsigned long flags;
459 
460 	if (tty_hung_up_p(filp))
461 		return 0;
462 
463 	spin_lock_irqsave(&port->lock, flags);
464 	if (tty->count == 1 && port->count != 1) {
465 		tty_warn(tty, "%s: tty->count = 1 port count = %d\n", __func__,
466 			 port->count);
467 		port->count = 1;
468 	}
469 	if (--port->count < 0) {
470 		tty_warn(tty, "%s: bad port count (%d)\n", __func__,
471 			 port->count);
472 		port->count = 0;
473 	}
474 
475 	if (port->count) {
476 		spin_unlock_irqrestore(&port->lock, flags);
477 		return 0;
478 	}
479 	spin_unlock_irqrestore(&port->lock, flags);
480 
481 	tty->closing = 1;
482 
483 	if (test_bit(ASYNCB_INITIALIZED, &port->flags)) {
484 		/* Don't block on a stalled port, just pull the chain */
485 		if (tty->flow_stopped)
486 			tty_driver_flush_buffer(tty);
487 		if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
488 			tty_wait_until_sent(tty, port->closing_wait);
489 		if (port->drain_delay)
490 			tty_port_drain_delay(port, tty);
491 	}
492 	/* Flush the ldisc buffering */
493 	tty_ldisc_flush(tty);
494 
495 	/* Report to caller this is the last port reference */
496 	return 1;
497 }
498 EXPORT_SYMBOL(tty_port_close_start);
499 
500 /* Caller holds tty lock */
501 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
502 {
503 	unsigned long flags;
504 
505 	tty_ldisc_flush(tty);
506 	tty->closing = 0;
507 
508 	spin_lock_irqsave(&port->lock, flags);
509 
510 	if (port->blocked_open) {
511 		spin_unlock_irqrestore(&port->lock, flags);
512 		if (port->close_delay)
513 			msleep_interruptible(jiffies_to_msecs(port->close_delay));
514 		spin_lock_irqsave(&port->lock, flags);
515 		wake_up_interruptible(&port->open_wait);
516 	}
517 	port->flags &= ~ASYNC_NORMAL_ACTIVE;
518 	spin_unlock_irqrestore(&port->lock, flags);
519 }
520 EXPORT_SYMBOL(tty_port_close_end);
521 
522 /**
523  * tty_port_close
524  *
525  * Caller holds tty lock
526  */
527 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
528 							struct file *filp)
529 {
530 	if (tty_port_close_start(port, tty, filp) == 0)
531 		return;
532 	tty_port_shutdown(port, tty);
533 	set_bit(TTY_IO_ERROR, &tty->flags);
534 	tty_port_close_end(port, tty);
535 	tty_port_tty_set(port, NULL);
536 }
537 EXPORT_SYMBOL(tty_port_close);
538 
539 /**
540  * tty_port_install - generic tty->ops->install handler
541  * @port: tty_port of the device
542  * @driver: tty_driver for this device
543  * @tty: tty to be installed
544  *
545  * It is the same as tty_standard_install except the provided @port is linked
546  * to a concrete tty specified by @tty. Use this or tty_port_register_device
547  * (or both). Call tty_port_link_device as a last resort.
548  */
549 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
550 		struct tty_struct *tty)
551 {
552 	tty->port = port;
553 	return tty_standard_install(driver, tty);
554 }
555 EXPORT_SYMBOL_GPL(tty_port_install);
556 
557 /**
558  * tty_port_open
559  *
560  * Caller holds tty lock.
561  *
562  * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
563  * tty and tty_port may have changed state (eg., may be hung up now)
564  */
565 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
566 							struct file *filp)
567 {
568 	spin_lock_irq(&port->lock);
569 	++port->count;
570 	spin_unlock_irq(&port->lock);
571 	tty_port_tty_set(port, tty);
572 
573 	/*
574 	 * Do the device-specific open only if the hardware isn't
575 	 * already initialized. Serialize open and shutdown using the
576 	 * port mutex.
577 	 */
578 
579 	mutex_lock(&port->mutex);
580 
581 	if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
582 		clear_bit(TTY_IO_ERROR, &tty->flags);
583 		if (port->ops->activate) {
584 			int retval = port->ops->activate(port, tty);
585 			if (retval) {
586 				mutex_unlock(&port->mutex);
587 				return retval;
588 			}
589 		}
590 		set_bit(ASYNCB_INITIALIZED, &port->flags);
591 	}
592 	mutex_unlock(&port->mutex);
593 	return tty_port_block_til_ready(port, tty, filp);
594 }
595 
596 EXPORT_SYMBOL(tty_port_open);
597