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