Commit | Line | Data |
---|---|---|
e3b3d0f5 | 1 | // SPDX-License-Identifier: GPL-2.0 |
9e48565d AC |
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> | |
3e61696b | 11 | #include <linux/serial.h> |
9e48565d AC |
12 | #include <linux/timer.h> |
13 | #include <linux/string.h> | |
14 | #include <linux/slab.h> | |
174cd4b1 | 15 | #include <linux/sched/signal.h> |
9e48565d AC |
16 | #include <linux/wait.h> |
17 | #include <linux/bitops.h> | |
18 | #include <linux/delay.h> | |
19 | #include <linux/module.h> | |
8cde11b2 | 20 | #include <linux/serdev.h> |
98602c01 | 21 | #include "tty.h" |
9e48565d | 22 | |
0468a807 JSS |
23 | static size_t tty_port_default_receive_buf(struct tty_port *port, const u8 *p, |
24 | const u8 *f, size_t count) | |
c3485ee0 | 25 | { |
c3485ee0 | 26 | struct tty_struct *tty; |
c6e37fe0 | 27 | struct tty_ldisc *ld; |
c3485ee0 RH |
28 | |
29 | tty = READ_ONCE(port->itty); | |
30 | if (!tty) | |
31 | return 0; | |
32 | ||
c6e37fe0 JSS |
33 | ld = tty_ldisc_ref(tty); |
34 | if (!ld) | |
c3485ee0 RH |
35 | return 0; |
36 | ||
892bc209 | 37 | count = tty_ldisc_receive_buf(ld, p, f, count); |
c3485ee0 | 38 | |
c6e37fe0 | 39 | tty_ldisc_deref(ld); |
c3485ee0 | 40 | |
0468a807 | 41 | return count; |
c3485ee0 RH |
42 | } |
43 | ||
0b7a2b28 | 44 | static void tty_port_default_lookahead_buf(struct tty_port *port, const u8 *p, |
0468a807 | 45 | const u8 *f, size_t count) |
6bb6fa69 IJ |
46 | { |
47 | struct tty_struct *tty; | |
c6e37fe0 | 48 | struct tty_ldisc *ld; |
6bb6fa69 IJ |
49 | |
50 | tty = READ_ONCE(port->itty); | |
51 | if (!tty) | |
52 | return; | |
53 | ||
c6e37fe0 JSS |
54 | ld = tty_ldisc_ref(tty); |
55 | if (!ld) | |
6bb6fa69 IJ |
56 | return; |
57 | ||
c6e37fe0 JSS |
58 | if (ld->ops->lookahead_buf) |
59 | ld->ops->lookahead_buf(ld->tty, p, f, count); | |
6bb6fa69 | 60 | |
c6e37fe0 | 61 | tty_ldisc_deref(ld); |
6bb6fa69 IJ |
62 | } |
63 | ||
c3485ee0 RH |
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 | ||
0c5aae59 | 74 | const struct tty_port_client_operations tty_port_default_client_ops = { |
c3485ee0 | 75 | .receive_buf = tty_port_default_receive_buf, |
6bb6fa69 | 76 | .lookahead_buf = tty_port_default_lookahead_buf, |
c3485ee0 RH |
77 | .write_wakeup = tty_port_default_wakeup, |
78 | }; | |
0c5aae59 | 79 | EXPORT_SYMBOL_GPL(tty_port_default_client_ops); |
c3485ee0 | 80 | |
3be491d7 | 81 | /** |
c38f45ef | 82 | * tty_port_init - initialize tty_port |
3be491d7 JS |
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 | */ | |
9e48565d AC |
90 | void tty_port_init(struct tty_port *port) |
91 | { | |
92 | memset(port, 0, sizeof(*port)); | |
ecbbfd44 | 93 | tty_buffer_init(port); |
9e48565d | 94 | init_waitqueue_head(&port->open_wait); |
bdc04e31 | 95 | init_waitqueue_head(&port->delta_msr_wait); |
9e48565d | 96 | mutex_init(&port->mutex); |
44e4909e | 97 | mutex_init(&port->buf_mutex); |
4a90f09b | 98 | spin_lock_init(&port->lock); |
9e48565d AC |
99 | port->close_delay = (50 * HZ) / 100; |
100 | port->closing_wait = (3000 * HZ) / 100; | |
0c5aae59 | 101 | port->client_ops = &tty_port_default_client_ops; |
568aafc6 | 102 | kref_init(&port->kref); |
9e48565d AC |
103 | } |
104 | EXPORT_SYMBOL(tty_port_init); | |
105 | ||
2cb4ca02 JS |
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 | * | |
1926e5d3 | 112 | * Provide the tty layer with a link from a tty (specified by @index) to a |
cb6f6f98 JS |
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(). | |
2cb4ca02 JS |
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; | |
273f6329 | 122 | driver->ports[index] = port; |
2cb4ca02 JS |
123 | } |
124 | EXPORT_SYMBOL_GPL(tty_port_link_device); | |
125 | ||
72a33bf5 JS |
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 | * | |
cb6f6f98 JS |
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. | |
72a33bf5 | 136 | */ |
057eb856 JS |
137 | struct device *tty_port_register_device(struct tty_port *port, |
138 | struct tty_driver *driver, unsigned index, | |
139 | struct device *device) | |
140 | { | |
3086365d | 141 | return tty_port_register_device_attr(port, driver, index, device, NULL, NULL); |
057eb856 JS |
142 | } |
143 | EXPORT_SYMBOL_GPL(tty_port_register_device); | |
144 | ||
b1b79916 TH |
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 | * | |
cb6f6f98 JS |
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. | |
b1b79916 TH |
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 | ||
8cde11b2 JH |
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 | |
b286f4e8 TL |
174 | * @host: serial port hardware device |
175 | * @parent: parent if exists, otherwise NULL | |
8cde11b2 JH |
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, | |
b286f4e8 | 184 | struct device *host, struct device *parent, void *drvdata, |
8cde11b2 JH |
185 | const struct attribute_group **attr_grp) |
186 | { | |
187 | struct device *dev; | |
188 | ||
189 | tty_port_link_device(port, driver, index); | |
190 | ||
b286f4e8 | 191 | dev = serdev_tty_port_register(port, host, parent, driver, index); |
8cde11b2 JH |
192 | if (PTR_ERR(dev) != -ENODEV) { |
193 | /* Skip creating cdev if we registered a serdev device */ | |
194 | return dev; | |
195 | } | |
196 | ||
b286f4e8 | 197 | return tty_register_device_attr(driver, index, parent, drvdata, |
8cde11b2 JH |
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 | |
b286f4e8 TL |
207 | * @host: serial port hardware controller device |
208 | * @parent: parent if exists, otherwise NULL | |
8cde11b2 JH |
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, | |
b286f4e8 | 215 | struct device *host, struct device *parent) |
8cde11b2 JH |
216 | { |
217 | return tty_port_register_device_attr_serdev(port, driver, index, | |
b286f4e8 | 218 | host, parent, NULL, NULL); |
8cde11b2 JH |
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 | ||
9e48565d AC |
245 | int tty_port_alloc_xmit_buf(struct tty_port *port) |
246 | { | |
247 | /* We may sleep in get_zeroed_page() */ | |
44e4909e | 248 | mutex_lock(&port->buf_mutex); |
4e2a44c1 | 249 | if (port->xmit_buf == NULL) { |
49943393 | 250 | port->xmit_buf = (u8 *)get_zeroed_page(GFP_KERNEL); |
4e2a44c1 JS |
251 | if (port->xmit_buf) |
252 | kfifo_init(&port->xmit_fifo, port->xmit_buf, PAGE_SIZE); | |
253 | } | |
44e4909e | 254 | mutex_unlock(&port->buf_mutex); |
9e48565d AC |
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 | { | |
44e4909e | 263 | mutex_lock(&port->buf_mutex); |
3c5b2f5b AS |
264 | free_page((unsigned long)port->xmit_buf); |
265 | port->xmit_buf = NULL; | |
266 | INIT_KFIFO(port->xmit_fifo); | |
44e4909e | 267 | mutex_unlock(&port->buf_mutex); |
9e48565d AC |
268 | } |
269 | EXPORT_SYMBOL(tty_port_free_xmit_buf); | |
270 | ||
de274bfe | 271 | /** |
c38f45ef | 272 | * tty_port_destroy - destroy inited port |
1926e5d3 | 273 | * @port: tty port to be destroyed |
de274bfe | 274 | * |
cb6f6f98 JS |
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. | |
de274bfe JS |
278 | */ |
279 | void tty_port_destroy(struct tty_port *port) | |
280 | { | |
e176058f | 281 | tty_buffer_cancel_work(port); |
de274bfe JS |
282 | tty_buffer_free_all(port); |
283 | } | |
284 | EXPORT_SYMBOL(tty_port_destroy); | |
285 | ||
568aafc6 AC |
286 | static void tty_port_destructor(struct kref *kref) |
287 | { | |
288 | struct tty_port *port = container_of(kref, struct tty_port, kref); | |
e3bfea23 PH |
289 | |
290 | /* check if last port ref was dropped before tty release */ | |
291 | if (WARN_ON(port->itty)) | |
292 | return; | |
3c5b2f5b | 293 | free_page((unsigned long)port->xmit_buf); |
de274bfe | 294 | tty_port_destroy(port); |
81c79838 | 295 | if (port->ops && port->ops->destruct) |
568aafc6 AC |
296 | port->ops->destruct(port); |
297 | else | |
298 | kfree(port); | |
299 | } | |
300 | ||
3be491d7 | 301 | /** |
c38f45ef | 302 | * tty_port_put - drop a reference to tty_port |
3be491d7 JS |
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 | */ | |
568aafc6 AC |
308 | void tty_port_put(struct tty_port *port) |
309 | { | |
310 | if (port) | |
311 | kref_put(&port->kref, tty_port_destructor); | |
312 | } | |
313 | EXPORT_SYMBOL(tty_port_put); | |
9e48565d | 314 | |
4a90f09b | 315 | /** |
cb6f6f98 JS |
316 | * tty_port_tty_get - get a tty reference |
317 | * @port: tty port | |
4a90f09b | 318 | * |
cb6f6f98 JS |
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). | |
4a90f09b | 321 | */ |
4a90f09b AC |
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(port->tty); | |
329 | spin_unlock_irqrestore(&port->lock, flags); | |
330 | return tty; | |
331 | } | |
332 | EXPORT_SYMBOL(tty_port_tty_get); | |
333 | ||
334 | /** | |
cb6f6f98 JS |
335 | * tty_port_tty_set - set the tty of a port |
336 | * @port: tty port | |
337 | * @tty: the tty | |
4a90f09b | 338 | * |
cb6f6f98 JS |
339 | * Associate the port and tty pair. Manages any internal refcounts. Pass %NULL |
340 | * to deassociate a port. | |
4a90f09b | 341 | */ |
4a90f09b AC |
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); | |
a211b1af | 347 | tty_kref_put(port->tty); |
cb4bca35 | 348 | port->tty = tty_kref_get(tty); |
4a90f09b AC |
349 | spin_unlock_irqrestore(&port->lock, flags); |
350 | } | |
351 | EXPORT_SYMBOL(tty_port_tty_set); | |
31f35939 | 352 | |
3be491d7 JS |
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 | */ | |
957dacae | 363 | static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty) |
7ca0ff9a | 364 | { |
64bc3979 | 365 | mutex_lock(&port->mutex); |
8bde9658 JH |
366 | if (port->console) |
367 | goto out; | |
368 | ||
d41861ca | 369 | if (tty_port_initialized(port)) { |
515be7ba | 370 | tty_port_set_initialized(port, false); |
957dacae JH |
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 | ||
0d3cb6f6 | 378 | if (port->ops->shutdown) |
7ca0ff9a | 379 | port->ops->shutdown(port); |
8bde9658 JH |
380 | } |
381 | out: | |
64bc3979 | 382 | mutex_unlock(&port->mutex); |
7ca0ff9a AC |
383 | } |
384 | ||
3e61696b | 385 | /** |
cb6f6f98 JS |
386 | * tty_port_hangup - hangup helper |
387 | * @port: tty port | |
3e61696b | 388 | * |
cb6f6f98 JS |
389 | * Perform port level tty hangup flag and count changes. Drop the tty |
390 | * reference. | |
9c9928bd | 391 | * |
cb6f6f98 | 392 | * Caller holds tty lock. |
3e61696b | 393 | */ |
3e61696b AC |
394 | void tty_port_hangup(struct tty_port *port) |
395 | { | |
957dacae | 396 | struct tty_struct *tty; |
3e61696b AC |
397 | unsigned long flags; |
398 | ||
399 | spin_lock_irqsave(&port->lock, flags); | |
400 | port->count = 0; | |
957dacae JH |
401 | tty = port->tty; |
402 | if (tty) | |
403 | set_bit(TTY_IO_ERROR, &tty->flags); | |
3e61696b AC |
404 | port->tty = NULL; |
405 | spin_unlock_irqrestore(&port->lock, flags); | |
9b5aa549 | 406 | tty_port_set_active(port, false); |
957dacae JH |
407 | tty_port_shutdown(port, tty); |
408 | tty_kref_put(tty); | |
3e61696b | 409 | wake_up_interruptible(&port->open_wait); |
bdc04e31 | 410 | wake_up_interruptible(&port->delta_msr_wait); |
3e61696b AC |
411 | } |
412 | EXPORT_SYMBOL(tty_port_hangup); | |
413 | ||
aa27a094 JS |
414 | /** |
415 | * tty_port_tty_hangup - helper to hang up a tty | |
aa27a094 | 416 | * @port: tty port |
cb6f6f98 | 417 | * @check_clocal: hang only ttys with %CLOCAL unset? |
aa27a094 JS |
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 | ||
1d9e689c | 423 | if (tty && (!check_clocal || !C_CLOCAL(tty))) |
aa27a094 | 424 | tty_hangup(tty); |
1d9e689c | 425 | tty_kref_put(tty); |
aa27a094 JS |
426 | } |
427 | EXPORT_SYMBOL_GPL(tty_port_tty_hangup); | |
428 | ||
6aad04f2 JS |
429 | /** |
430 | * tty_port_tty_wakeup - helper to wake up a tty | |
6aad04f2 JS |
431 | * @port: tty port |
432 | */ | |
433 | void tty_port_tty_wakeup(struct tty_port *port) | |
434 | { | |
c3485ee0 | 435 | port->client_ops->write_wakeup(port); |
6aad04f2 JS |
436 | } |
437 | EXPORT_SYMBOL_GPL(tty_port_tty_wakeup); | |
438 | ||
31f35939 | 439 | /** |
cb6f6f98 JS |
440 | * tty_port_carrier_raised - carrier raised check |
441 | * @port: tty port | |
31f35939 | 442 | * |
cb6f6f98 JS |
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. | |
31f35939 | 446 | */ |
b300fb26 | 447 | bool tty_port_carrier_raised(struct tty_port *port) |
31f35939 | 448 | { |
0d3cb6f6 | 449 | if (port->ops->carrier_raised == NULL) |
b300fb26 | 450 | return true; |
31f35939 AC |
451 | return port->ops->carrier_raised(port); |
452 | } | |
453 | EXPORT_SYMBOL(tty_port_carrier_raised); | |
5d951fb4 AC |
454 | |
455 | /** | |
cb6f6f98 JS |
456 | * tty_port_raise_dtr_rts - Raise DTR/RTS |
457 | * @port: tty port | |
5d951fb4 | 458 | * |
cb6f6f98 JS |
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. | |
5d951fb4 | 462 | */ |
5d951fb4 AC |
463 | void tty_port_raise_dtr_rts(struct tty_port *port) |
464 | { | |
0d3cb6f6 | 465 | if (port->ops->dtr_rts) |
5d420399 | 466 | port->ops->dtr_rts(port, true); |
5d951fb4 AC |
467 | } |
468 | EXPORT_SYMBOL(tty_port_raise_dtr_rts); | |
36c621d8 | 469 | |
fcc8ac18 | 470 | /** |
cb6f6f98 JS |
471 | * tty_port_lower_dtr_rts - Lower DTR/RTS |
472 | * @port: tty port | |
fcc8ac18 | 473 | * |
cb6f6f98 JS |
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. | |
fcc8ac18 | 477 | */ |
fcc8ac18 AC |
478 | void tty_port_lower_dtr_rts(struct tty_port *port) |
479 | { | |
0d3cb6f6 | 480 | if (port->ops->dtr_rts) |
5d420399 | 481 | port->ops->dtr_rts(port, false); |
fcc8ac18 AC |
482 | } |
483 | EXPORT_SYMBOL(tty_port_lower_dtr_rts); | |
484 | ||
36c621d8 | 485 | /** |
cb6f6f98 JS |
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: | |
36c621d8 | 493 | * |
cb6f6f98 JS |
494 | * - hangup (both before and during) |
495 | * - non blocking open | |
496 | * - rts/dtr/dcd | |
497 | * - signals | |
498 | * - port flags and counts | |
36c621d8 | 499 | * |
cb6f6f98 JS |
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. | |
c590f6b6 | 504 | * |
cb6f6f98 | 505 | * Caller holds tty lock. |
c590f6b6 | 506 | * |
cb6f6f98 JS |
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). | |
36c621d8 | 509 | */ |
36c621d8 AC |
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; | |
6af9a43d | 515 | DEFINE_WAIT(wait); |
36c621d8 | 516 | |
36c621d8 | 517 | /* if non-blocking mode is set we can pass directly to open unless |
1df92640 XT |
518 | * the port has just hung up or is in another error state. |
519 | */ | |
18900ca6 | 520 | if (tty_io_error(tty)) { |
9b5aa549 | 521 | tty_port_set_active(port, true); |
8627b96d AC |
522 | return 0; |
523 | } | |
ed3f0af8 | 524 | if (filp == NULL || (filp->f_flags & O_NONBLOCK)) { |
4175f3e3 | 525 | /* Indicate we are open */ |
9db276f8 | 526 | if (C_BAUD(tty)) |
4175f3e3 | 527 | tty_port_raise_dtr_rts(port); |
9b5aa549 | 528 | tty_port_set_active(port, true); |
36c621d8 AC |
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 | |
1df92640 XT |
536 | * carrier, but we must also wait for any close that is in progress |
537 | * before the next open may complete. | |
538 | */ | |
36c621d8 AC |
539 | |
540 | retval = 0; | |
36c621d8 AC |
541 | |
542 | /* The port lock protects the port counts */ | |
543 | spin_lock_irqsave(&port->lock, flags); | |
e359a4e3 | 544 | port->count--; |
36c621d8 AC |
545 | port->blocked_open++; |
546 | spin_unlock_irqrestore(&port->lock, flags); | |
547 | ||
548 | while (1) { | |
549 | /* Indicate we are open */ | |
d41861ca | 550 | if (C_BAUD(tty) && tty_port_initialized(port)) |
7834909f | 551 | tty_port_raise_dtr_rts(port); |
36c621d8 | 552 | |
3e3b5c08 | 553 | prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE); |
d774a56d | 554 | /* Check for a hangup or uninitialised port. |
1df92640 XT |
555 | * Return accordingly. |
556 | */ | |
d41861ca | 557 | if (tty_hung_up_p(filp) || !tty_port_initialized(port)) { |
36c621d8 AC |
558 | if (port->flags & ASYNC_HUP_NOTIFY) |
559 | retval = -EAGAIN; | |
560 | else | |
561 | retval = -ERESTARTSYS; | |
562 | break; | |
563 | } | |
0eee50af JS |
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 | */ | |
fef062cb | 570 | if (do_clocal || tty_port_carrier_raised(port)) |
36c621d8 AC |
571 | break; |
572 | if (signal_pending(current)) { | |
573 | retval = -ERESTARTSYS; | |
574 | break; | |
575 | } | |
89c8d91e | 576 | tty_unlock(tty); |
36c621d8 | 577 | schedule(); |
89c8d91e | 578 | tty_lock(tty); |
36c621d8 | 579 | } |
3e3b5c08 | 580 | finish_wait(&port->open_wait, &wait); |
36c621d8 AC |
581 | |
582 | /* Update counts. A parallel hangup will have set count to zero and | |
1df92640 XT |
583 | * we must not mess that up further. |
584 | */ | |
36c621d8 AC |
585 | spin_lock_irqsave(&port->lock, flags); |
586 | if (!tty_hung_up_p(filp)) | |
587 | port->count++; | |
588 | port->blocked_open--; | |
36c621d8 | 589 | spin_unlock_irqrestore(&port->lock, flags); |
807c8d81 | 590 | if (retval == 0) |
9b5aa549 | 591 | tty_port_set_active(port, true); |
ecc2e05e | 592 | return retval; |
36c621d8 AC |
593 | } |
594 | EXPORT_SYMBOL(tty_port_block_til_ready); | |
595 | ||
b74414f5 JH |
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 | ||
3be491d7 JS |
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 | */ | |
d774a56d AC |
625 | int tty_port_close_start(struct tty_port *port, |
626 | struct tty_struct *tty, struct file *filp) | |
a6614999 AC |
627 | { |
628 | unsigned long flags; | |
629 | ||
633caba8 | 630 | if (tty_hung_up_p(filp)) |
a6614999 | 631 | return 0; |
a6614999 | 632 | |
633caba8 | 633 | spin_lock_irqsave(&port->lock, flags); |
d774a56d | 634 | if (tty->count == 1 && port->count != 1) { |
339f36ba PH |
635 | tty_warn(tty, "%s: tty->count = 1 port count = %d\n", __func__, |
636 | port->count); | |
a6614999 AC |
637 | port->count = 1; |
638 | } | |
639 | if (--port->count < 0) { | |
339f36ba PH |
640 | tty_warn(tty, "%s: bad port count (%d)\n", __func__, |
641 | port->count); | |
a6614999 AC |
642 | port->count = 0; |
643 | } | |
644 | ||
645 | if (port->count) { | |
646 | spin_unlock_irqrestore(&port->lock, flags); | |
647 | return 0; | |
648 | } | |
a6614999 | 649 | spin_unlock_irqrestore(&port->lock, flags); |
0b2588ca | 650 | |
ddc7b758 PH |
651 | tty->closing = 1; |
652 | ||
d41861ca | 653 | if (tty_port_initialized(port)) { |
0b2588ca | 654 | /* Don't block on a stalled port, just pull the chain */ |
6e94dbc7 | 655 | if (tty->flow.tco_stopped) |
0b2588ca JH |
656 | tty_driver_flush_buffer(tty); |
657 | if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE) | |
79c1faa4 | 658 | tty_wait_until_sent(tty, port->closing_wait); |
0b2588ca JH |
659 | if (port->drain_delay) |
660 | tty_port_drain_delay(port, tty); | |
661 | } | |
e707c35c AC |
662 | /* Flush the ldisc buffering */ |
663 | tty_ldisc_flush(tty); | |
664 | ||
469d6d06 | 665 | /* Report to caller this is the last port reference */ |
a6614999 AC |
666 | return 1; |
667 | } | |
668 | EXPORT_SYMBOL(tty_port_close_start); | |
669 | ||
3be491d7 JS |
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 | */ | |
a6614999 AC |
681 | void tty_port_close_end(struct tty_port *port, struct tty_struct *tty) |
682 | { | |
683 | unsigned long flags; | |
684 | ||
3f40f5b2 | 685 | tty_ldisc_flush(tty); |
a6614999 AC |
686 | tty->closing = 0; |
687 | ||
ddc7b758 PH |
688 | spin_lock_irqsave(&port->lock, flags); |
689 | ||
a6614999 AC |
690 | if (port->blocked_open) { |
691 | spin_unlock_irqrestore(&port->lock, flags); | |
5823323e PH |
692 | if (port->close_delay) |
693 | msleep_interruptible(jiffies_to_msecs(port->close_delay)); | |
a6614999 AC |
694 | spin_lock_irqsave(&port->lock, flags); |
695 | wake_up_interruptible(&port->open_wait); | |
696 | } | |
a6614999 | 697 | spin_unlock_irqrestore(&port->lock, flags); |
9b5aa549 | 698 | tty_port_set_active(port, false); |
a6614999 AC |
699 | } |
700 | EXPORT_SYMBOL(tty_port_close_end); | |
7ca0ff9a | 701 | |
cb6f6f98 JS |
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. | |
0733db91 | 712 | * |
cb6f6f98 | 713 | * Locking: Caller holds tty lock |
0733db91 | 714 | */ |
7ca0ff9a AC |
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; | |
957dacae | 720 | tty_port_shutdown(port, tty); |
2a486026 CP |
721 | if (!port->console) |
722 | set_bit(TTY_IO_ERROR, &tty->flags); | |
7ca0ff9a AC |
723 | tty_port_close_end(port, tty); |
724 | tty_port_tty_set(port, NULL); | |
725 | } | |
726 | EXPORT_SYMBOL(tty_port_close); | |
64bc3979 | 727 | |
72a33bf5 JS |
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 | * | |
cb6f6f98 JS |
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. | |
72a33bf5 | 737 | */ |
695586ca JS |
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 | ||
cb6f6f98 JS |
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 | |
addd4672 | 751 | * |
cb6f6f98 JS |
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 | * | |
d56738a3 JS |
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 | * | |
cb6f6f98 | 760 | * Locking: Caller holds tty lock. |
addd4672 | 761 | * |
cb6f6f98 JS |
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). | |
addd4672 | 764 | */ |
64bc3979 | 765 | int tty_port_open(struct tty_port *port, struct tty_struct *tty, |
d774a56d | 766 | struct file *filp) |
64bc3979 AC |
767 | { |
768 | spin_lock_irq(&port->lock); | |
e359a4e3 | 769 | ++port->count; |
64bc3979 AC |
770 | spin_unlock_irq(&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 | ||
d41861ca | 781 | if (!tty_port_initialized(port)) { |
a9a37ec3 | 782 | clear_bit(TTY_IO_ERROR, &tty->flags); |
0d3cb6f6 | 783 | if (port->ops->activate) { |
64bc3979 | 784 | int retval = port->ops->activate(port, tty); |
54ad59a2 | 785 | |
64bc3979 | 786 | if (retval) { |
d774a56d AC |
787 | mutex_unlock(&port->mutex); |
788 | return retval; | |
789 | } | |
790 | } | |
515be7ba | 791 | tty_port_set_initialized(port, true); |
64bc3979 AC |
792 | } |
793 | mutex_unlock(&port->mutex); | |
794 | return tty_port_block_til_ready(port, tty, filp); | |
795 | } | |
64bc3979 | 796 | EXPORT_SYMBOL(tty_port_open); |