Loading...
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/init.h>
16#include <linux/wait.h>
17#include <linux/bitops.h>
18#include <linux/delay.h>
19#include <linux/module.h>
20
21void tty_port_init(struct tty_port *port)
22{
23 memset(port, 0, sizeof(*port));
24 init_waitqueue_head(&port->open_wait);
25 init_waitqueue_head(&port->close_wait);
26 init_waitqueue_head(&port->delta_msr_wait);
27 mutex_init(&port->mutex);
28 mutex_init(&port->buf_mutex);
29 spin_lock_init(&port->lock);
30 port->close_delay = (50 * HZ) / 100;
31 port->closing_wait = (3000 * HZ) / 100;
32 kref_init(&port->kref);
33}
34EXPORT_SYMBOL(tty_port_init);
35
36int tty_port_alloc_xmit_buf(struct tty_port *port)
37{
38 /* We may sleep in get_zeroed_page() */
39 mutex_lock(&port->buf_mutex);
40 if (port->xmit_buf == NULL)
41 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
42 mutex_unlock(&port->buf_mutex);
43 if (port->xmit_buf == NULL)
44 return -ENOMEM;
45 return 0;
46}
47EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
48
49void tty_port_free_xmit_buf(struct tty_port *port)
50{
51 mutex_lock(&port->buf_mutex);
52 if (port->xmit_buf != NULL) {
53 free_page((unsigned long)port->xmit_buf);
54 port->xmit_buf = NULL;
55 }
56 mutex_unlock(&port->buf_mutex);
57}
58EXPORT_SYMBOL(tty_port_free_xmit_buf);
59
60static void tty_port_destructor(struct kref *kref)
61{
62 struct tty_port *port = container_of(kref, struct tty_port, kref);
63 if (port->xmit_buf)
64 free_page((unsigned long)port->xmit_buf);
65 if (port->ops->destruct)
66 port->ops->destruct(port);
67 else
68 kfree(port);
69}
70
71void tty_port_put(struct tty_port *port)
72{
73 if (port)
74 kref_put(&port->kref, tty_port_destructor);
75}
76EXPORT_SYMBOL(tty_port_put);
77
78/**
79 * tty_port_tty_get - get a tty reference
80 * @port: tty port
81 *
82 * Return a refcount protected tty instance or NULL if the port is not
83 * associated with a tty (eg due to close or hangup)
84 */
85
86struct tty_struct *tty_port_tty_get(struct tty_port *port)
87{
88 unsigned long flags;
89 struct tty_struct *tty;
90
91 spin_lock_irqsave(&port->lock, flags);
92 tty = tty_kref_get(port->tty);
93 spin_unlock_irqrestore(&port->lock, flags);
94 return tty;
95}
96EXPORT_SYMBOL(tty_port_tty_get);
97
98/**
99 * tty_port_tty_set - set the tty of a port
100 * @port: tty port
101 * @tty: the tty
102 *
103 * Associate the port and tty pair. Manages any internal refcounts.
104 * Pass NULL to deassociate a port
105 */
106
107void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
108{
109 unsigned long flags;
110
111 spin_lock_irqsave(&port->lock, flags);
112 if (port->tty)
113 tty_kref_put(port->tty);
114 port->tty = tty_kref_get(tty);
115 spin_unlock_irqrestore(&port->lock, flags);
116}
117EXPORT_SYMBOL(tty_port_tty_set);
118
119static void tty_port_shutdown(struct tty_port *port)
120{
121 mutex_lock(&port->mutex);
122 if (port->ops->shutdown && !port->console &&
123 test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags))
124 port->ops->shutdown(port);
125 mutex_unlock(&port->mutex);
126}
127
128/**
129 * tty_port_hangup - hangup helper
130 * @port: tty port
131 *
132 * Perform port level tty hangup flag and count changes. Drop the tty
133 * reference.
134 */
135
136void tty_port_hangup(struct tty_port *port)
137{
138 unsigned long flags;
139
140 spin_lock_irqsave(&port->lock, flags);
141 port->count = 0;
142 port->flags &= ~ASYNC_NORMAL_ACTIVE;
143 if (port->tty) {
144 set_bit(TTY_IO_ERROR, &port->tty->flags);
145 tty_kref_put(port->tty);
146 }
147 port->tty = NULL;
148 spin_unlock_irqrestore(&port->lock, flags);
149 wake_up_interruptible(&port->open_wait);
150 wake_up_interruptible(&port->delta_msr_wait);
151 tty_port_shutdown(port);
152}
153EXPORT_SYMBOL(tty_port_hangup);
154
155/**
156 * tty_port_carrier_raised - carrier raised check
157 * @port: tty port
158 *
159 * Wrapper for the carrier detect logic. For the moment this is used
160 * to hide some internal details. This will eventually become entirely
161 * internal to the tty port.
162 */
163
164int tty_port_carrier_raised(struct tty_port *port)
165{
166 if (port->ops->carrier_raised == NULL)
167 return 1;
168 return port->ops->carrier_raised(port);
169}
170EXPORT_SYMBOL(tty_port_carrier_raised);
171
172/**
173 * tty_port_raise_dtr_rts - Raise DTR/RTS
174 * @port: tty port
175 *
176 * Wrapper for the DTR/RTS raise logic. For the moment this is used
177 * to hide some internal details. This will eventually become entirely
178 * internal to the tty port.
179 */
180
181void tty_port_raise_dtr_rts(struct tty_port *port)
182{
183 if (port->ops->dtr_rts)
184 port->ops->dtr_rts(port, 1);
185}
186EXPORT_SYMBOL(tty_port_raise_dtr_rts);
187
188/**
189 * tty_port_lower_dtr_rts - Lower DTR/RTS
190 * @port: tty port
191 *
192 * Wrapper for the DTR/RTS raise logic. For the moment this is used
193 * to hide some internal details. This will eventually become entirely
194 * internal to the tty port.
195 */
196
197void tty_port_lower_dtr_rts(struct tty_port *port)
198{
199 if (port->ops->dtr_rts)
200 port->ops->dtr_rts(port, 0);
201}
202EXPORT_SYMBOL(tty_port_lower_dtr_rts);
203
204/**
205 * tty_port_block_til_ready - Waiting logic for tty open
206 * @port: the tty port being opened
207 * @tty: the tty device being bound
208 * @filp: the file pointer of the opener
209 *
210 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
211 * Handles:
212 * - hangup (both before and during)
213 * - non blocking open
214 * - rts/dtr/dcd
215 * - signals
216 * - port flags and counts
217 *
218 * The passed tty_port must implement the carrier_raised method if it can
219 * do carrier detect and the dtr_rts method if it supports software
220 * management of these lines. Note that the dtr/rts raise is done each
221 * iteration as a hangup may have previously dropped them while we wait.
222 */
223
224int tty_port_block_til_ready(struct tty_port *port,
225 struct tty_struct *tty, struct file *filp)
226{
227 int do_clocal = 0, retval;
228 unsigned long flags;
229 DEFINE_WAIT(wait);
230 int cd;
231
232 /* block if port is in the process of being closed */
233 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
234 wait_event_interruptible_tty(port->close_wait,
235 !(port->flags & ASYNC_CLOSING));
236 if (port->flags & ASYNC_HUP_NOTIFY)
237 return -EAGAIN;
238 else
239 return -ERESTARTSYS;
240 }
241
242 /* if non-blocking mode is set we can pass directly to open unless
243 the port has just hung up or is in another error state */
244 if (tty->flags & (1 << TTY_IO_ERROR)) {
245 port->flags |= ASYNC_NORMAL_ACTIVE;
246 return 0;
247 }
248 if (filp->f_flags & O_NONBLOCK) {
249 /* Indicate we are open */
250 if (tty->termios->c_cflag & CBAUD)
251 tty_port_raise_dtr_rts(port);
252 port->flags |= ASYNC_NORMAL_ACTIVE;
253 return 0;
254 }
255
256 if (C_CLOCAL(tty))
257 do_clocal = 1;
258
259 /* Block waiting until we can proceed. We may need to wait for the
260 carrier, but we must also wait for any close that is in progress
261 before the next open may complete */
262
263 retval = 0;
264
265 /* The port lock protects the port counts */
266 spin_lock_irqsave(&port->lock, flags);
267 if (!tty_hung_up_p(filp))
268 port->count--;
269 port->blocked_open++;
270 spin_unlock_irqrestore(&port->lock, flags);
271
272 while (1) {
273 /* Indicate we are open */
274 if (tty->termios->c_cflag & CBAUD)
275 tty_port_raise_dtr_rts(port);
276
277 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
278 /* Check for a hangup or uninitialised port.
279 Return accordingly */
280 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
281 if (port->flags & ASYNC_HUP_NOTIFY)
282 retval = -EAGAIN;
283 else
284 retval = -ERESTARTSYS;
285 break;
286 }
287 /* Probe the carrier. For devices with no carrier detect this
288 will always return true */
289 cd = tty_port_carrier_raised(port);
290 if (!(port->flags & ASYNC_CLOSING) &&
291 (do_clocal || cd))
292 break;
293 if (signal_pending(current)) {
294 retval = -ERESTARTSYS;
295 break;
296 }
297 tty_unlock();
298 schedule();
299 tty_lock();
300 }
301 finish_wait(&port->open_wait, &wait);
302
303 /* Update counts. A parallel hangup will have set count to zero and
304 we must not mess that up further */
305 spin_lock_irqsave(&port->lock, flags);
306 if (!tty_hung_up_p(filp))
307 port->count++;
308 port->blocked_open--;
309 if (retval == 0)
310 port->flags |= ASYNC_NORMAL_ACTIVE;
311 spin_unlock_irqrestore(&port->lock, flags);
312 return retval;
313}
314EXPORT_SYMBOL(tty_port_block_til_ready);
315
316int tty_port_close_start(struct tty_port *port,
317 struct tty_struct *tty, struct file *filp)
318{
319 unsigned long flags;
320
321 spin_lock_irqsave(&port->lock, flags);
322 if (tty_hung_up_p(filp)) {
323 spin_unlock_irqrestore(&port->lock, flags);
324 return 0;
325 }
326
327 if (tty->count == 1 && port->count != 1) {
328 printk(KERN_WARNING
329 "tty_port_close_start: tty->count = 1 port count = %d.\n",
330 port->count);
331 port->count = 1;
332 }
333 if (--port->count < 0) {
334 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
335 port->count);
336 port->count = 0;
337 }
338
339 if (port->count) {
340 spin_unlock_irqrestore(&port->lock, flags);
341 if (port->ops->drop)
342 port->ops->drop(port);
343 return 0;
344 }
345 set_bit(ASYNCB_CLOSING, &port->flags);
346 tty->closing = 1;
347 spin_unlock_irqrestore(&port->lock, flags);
348 /* Don't block on a stalled port, just pull the chain */
349 if (tty->flow_stopped)
350 tty_driver_flush_buffer(tty);
351 if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
352 port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
353 tty_wait_until_sent(tty, port->closing_wait);
354 if (port->drain_delay) {
355 unsigned int bps = tty_get_baud_rate(tty);
356 long timeout;
357
358 if (bps > 1200)
359 timeout = max_t(long,
360 (HZ * 10 * port->drain_delay) / bps, HZ / 10);
361 else
362 timeout = 2 * HZ;
363 schedule_timeout_interruptible(timeout);
364 }
365 /* Flush the ldisc buffering */
366 tty_ldisc_flush(tty);
367
368 /* Drop DTR/RTS if HUPCL is set. This causes any attached modem to
369 hang up the line */
370 if (tty->termios->c_cflag & HUPCL)
371 tty_port_lower_dtr_rts(port);
372
373 /* Don't call port->drop for the last reference. Callers will want
374 to drop the last active reference in ->shutdown() or the tty
375 shutdown path */
376 return 1;
377}
378EXPORT_SYMBOL(tty_port_close_start);
379
380void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
381{
382 unsigned long flags;
383
384 spin_lock_irqsave(&port->lock, flags);
385 tty->closing = 0;
386
387 if (port->blocked_open) {
388 spin_unlock_irqrestore(&port->lock, flags);
389 if (port->close_delay) {
390 msleep_interruptible(
391 jiffies_to_msecs(port->close_delay));
392 }
393 spin_lock_irqsave(&port->lock, flags);
394 wake_up_interruptible(&port->open_wait);
395 }
396 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
397 wake_up_interruptible(&port->close_wait);
398 spin_unlock_irqrestore(&port->lock, flags);
399}
400EXPORT_SYMBOL(tty_port_close_end);
401
402void tty_port_close(struct tty_port *port, struct tty_struct *tty,
403 struct file *filp)
404{
405 if (tty_port_close_start(port, tty, filp) == 0)
406 return;
407 tty_port_shutdown(port);
408 set_bit(TTY_IO_ERROR, &tty->flags);
409 tty_port_close_end(port, tty);
410 tty_port_tty_set(port, NULL);
411}
412EXPORT_SYMBOL(tty_port_close);
413
414int tty_port_open(struct tty_port *port, struct tty_struct *tty,
415 struct file *filp)
416{
417 spin_lock_irq(&port->lock);
418 if (!tty_hung_up_p(filp))
419 ++port->count;
420 spin_unlock_irq(&port->lock);
421 tty_port_tty_set(port, tty);
422
423 /*
424 * Do the device-specific open only if the hardware isn't
425 * already initialized. Serialize open and shutdown using the
426 * port mutex.
427 */
428
429 mutex_lock(&port->mutex);
430
431 if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
432 clear_bit(TTY_IO_ERROR, &tty->flags);
433 if (port->ops->activate) {
434 int retval = port->ops->activate(port, tty);
435 if (retval) {
436 mutex_unlock(&port->mutex);
437 return retval;
438 }
439 }
440 set_bit(ASYNCB_INITIALIZED, &port->flags);
441 }
442 mutex_unlock(&port->mutex);
443 return tty_port_block_til_ready(port, tty, filp);
444}
445
446EXPORT_SYMBOL(tty_port_open);
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
23static 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
46static 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
56const 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};
60EXPORT_SYMBOL_GPL(tty_port_default_client_ops);
61
62void 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}
76EXPORT_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 */
89void 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}
96EXPORT_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 */
109struct 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}
115EXPORT_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 */
130struct 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}
139EXPORT_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 */
153struct 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}
171EXPORT_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 */
183struct 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}
190EXPORT_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 */
202void 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}
213EXPORT_SYMBOL_GPL(tty_port_unregister_device);
214
215int 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}
226EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
227
228void 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}
237EXPORT_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 */
247void tty_port_destroy(struct tty_port *port)
248{
249 tty_buffer_cancel_work(port);
250 tty_buffer_free_all(port);
251}
252EXPORT_SYMBOL(tty_port_destroy);
253
254static 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
270void tty_port_put(struct tty_port *port)
271{
272 if (port)
273 kref_put(&port->kref, tty_port_destructor);
274}
275EXPORT_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 */
284struct 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}
294EXPORT_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 */
304void 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}
313EXPORT_SYMBOL(tty_port_tty_set);
314
315static 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 }
333out:
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 */
346void 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}
364EXPORT_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 */
372void 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}
380EXPORT_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 */
387void tty_port_tty_wakeup(struct tty_port *port)
388{
389 port->client_ops->write_wakeup(port);
390}
391EXPORT_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 */
401int 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}
407EXPORT_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 */
417void tty_port_raise_dtr_rts(struct tty_port *port)
418{
419 if (port->ops->dtr_rts)
420 port->ops->dtr_rts(port, 1);
421}
422EXPORT_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 */
432void tty_port_lower_dtr_rts(struct tty_port *port)
433{
434 if (port->ops->dtr_rts)
435 port->ops->dtr_rts(port, 0);
436}
437EXPORT_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 */
463int 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}
547EXPORT_SYMBOL(tty_port_block_til_ready);
548
549static 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. */
564int 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}
607EXPORT_SYMBOL(tty_port_close_start);
608
609/* Caller holds tty lock */
610void 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}
629EXPORT_SYMBOL(tty_port_close_end);
630
631/*
632 * tty_port_close
633 *
634 * Caller holds tty lock
635 */
636void 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}
647EXPORT_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 */
659int 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}
665EXPORT_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 */
675int 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}
706EXPORT_SYMBOL(tty_port_open);