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