1
2
3
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
80
81
82
83
84
85
86
87
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
100
101
102
103
104
105
106
107
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
119
120
121
122
123
124
125
126
127
128
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
143
144
145
146
147
148
149
150
151
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
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
175
176
177
178
179
180
181
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
194
195
196
197
198
199
200
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
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
241
242
243
244
245
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
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
279
280
281
282
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
298
299
300
301
302
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
325
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
339
340
341
342
343
344
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
368
369
370
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
384
385
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
395
396
397
398
399
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
411
412
413
414
415
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
426
427
428
429
430
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
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
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
471
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
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
489
490
491
492
493 retval = 0;
494
495
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
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
508
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
519
520
521
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
536
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
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
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
602 tty_ldisc_flush(tty);
603
604
605 return 1;
606}
607EXPORT_SYMBOL(tty_port_close_start);
608
609
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
633
634
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
651
652
653
654
655
656
657
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
669
670
671
672
673
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
685
686
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);
707