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