1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33#include <linux/init.h>
34#include <linux/module.h>
35#include <linux/fs.h>
36#include <linux/slab.h>
37#include <linux/sched.h>
38#include <linux/seq_file.h>
39#include <linux/termios.h>
40#include <linux/tty.h>
41#include <linux/tty_flip.h>
42#include <linux/interrupt.h>
43#include <linux/device.h>
44
45#include <asm/uaccess.h>
46
47#include <net/irda/irda.h>
48#include <net/irda/irmod.h>
49
50#include <net/irda/ircomm_core.h>
51#include <net/irda/ircomm_param.h>
52#include <net/irda/ircomm_tty_attach.h>
53#include <net/irda/ircomm_tty.h>
54
55static int ircomm_tty_install(struct tty_driver *driver,
56 struct tty_struct *tty);
57static int ircomm_tty_open(struct tty_struct *tty, struct file *filp);
58static void ircomm_tty_close(struct tty_struct * tty, struct file *filp);
59static int ircomm_tty_write(struct tty_struct * tty,
60 const unsigned char *buf, int count);
61static int ircomm_tty_write_room(struct tty_struct *tty);
62static void ircomm_tty_throttle(struct tty_struct *tty);
63static void ircomm_tty_unthrottle(struct tty_struct *tty);
64static int ircomm_tty_chars_in_buffer(struct tty_struct *tty);
65static void ircomm_tty_flush_buffer(struct tty_struct *tty);
66static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch);
67static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout);
68static void ircomm_tty_hangup(struct tty_struct *tty);
69static void ircomm_tty_do_softint(struct work_struct *work);
70static void ircomm_tty_shutdown(struct ircomm_tty_cb *self);
71static void ircomm_tty_stop(struct tty_struct *tty);
72
73static int ircomm_tty_data_indication(void *instance, void *sap,
74 struct sk_buff *skb);
75static int ircomm_tty_control_indication(void *instance, void *sap,
76 struct sk_buff *skb);
77static void ircomm_tty_flow_indication(void *instance, void *sap,
78 LOCAL_FLOW cmd);
79#ifdef CONFIG_PROC_FS
80static const struct file_operations ircomm_tty_proc_fops;
81#endif
82static struct tty_driver *driver;
83
84static hashbin_t *ircomm_tty = NULL;
85
86static const struct tty_operations ops = {
87 .install = ircomm_tty_install,
88 .open = ircomm_tty_open,
89 .close = ircomm_tty_close,
90 .write = ircomm_tty_write,
91 .write_room = ircomm_tty_write_room,
92 .chars_in_buffer = ircomm_tty_chars_in_buffer,
93 .flush_buffer = ircomm_tty_flush_buffer,
94 .ioctl = ircomm_tty_ioctl,
95 .tiocmget = ircomm_tty_tiocmget,
96 .tiocmset = ircomm_tty_tiocmset,
97 .throttle = ircomm_tty_throttle,
98 .unthrottle = ircomm_tty_unthrottle,
99 .send_xchar = ircomm_tty_send_xchar,
100 .set_termios = ircomm_tty_set_termios,
101 .stop = ircomm_tty_stop,
102 .start = ircomm_tty_start,
103 .hangup = ircomm_tty_hangup,
104 .wait_until_sent = ircomm_tty_wait_until_sent,
105#ifdef CONFIG_PROC_FS
106 .proc_fops = &ircomm_tty_proc_fops,
107#endif
108};
109
110static void ircomm_port_raise_dtr_rts(struct tty_port *port, int raise)
111{
112 struct ircomm_tty_cb *self = container_of(port, struct ircomm_tty_cb,
113 port);
114
115
116
117
118
119 if (raise)
120 self->settings.dte |= IRCOMM_RTS | IRCOMM_DTR;
121 else
122 self->settings.dte &= ~(IRCOMM_RTS | IRCOMM_DTR);
123
124 ircomm_param_request(self, IRCOMM_DTE, TRUE);
125}
126
127static int ircomm_port_carrier_raised(struct tty_port *port)
128{
129 struct ircomm_tty_cb *self = container_of(port, struct ircomm_tty_cb,
130 port);
131 return self->settings.dce & IRCOMM_CD;
132}
133
134static const struct tty_port_operations ircomm_port_ops = {
135 .dtr_rts = ircomm_port_raise_dtr_rts,
136 .carrier_raised = ircomm_port_carrier_raised,
137};
138
139
140
141
142
143
144
145static int __init ircomm_tty_init(void)
146{
147 driver = alloc_tty_driver(IRCOMM_TTY_PORTS);
148 if (!driver)
149 return -ENOMEM;
150 ircomm_tty = hashbin_new(HB_LOCK);
151 if (ircomm_tty == NULL) {
152 IRDA_ERROR("%s(), can't allocate hashbin!\n", __func__);
153 put_tty_driver(driver);
154 return -ENOMEM;
155 }
156
157 driver->driver_name = "ircomm";
158 driver->name = "ircomm";
159 driver->major = IRCOMM_TTY_MAJOR;
160 driver->minor_start = IRCOMM_TTY_MINOR;
161 driver->type = TTY_DRIVER_TYPE_SERIAL;
162 driver->subtype = SERIAL_TYPE_NORMAL;
163 driver->init_termios = tty_std_termios;
164 driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
165 driver->flags = TTY_DRIVER_REAL_RAW;
166 tty_set_operations(driver, &ops);
167 if (tty_register_driver(driver)) {
168 IRDA_ERROR("%s(): Couldn't register serial driver\n",
169 __func__);
170 put_tty_driver(driver);
171 return -1;
172 }
173 return 0;
174}
175
176static void __exit __ircomm_tty_cleanup(struct ircomm_tty_cb *self)
177{
178 IRDA_DEBUG(0, "%s()\n", __func__ );
179
180 IRDA_ASSERT(self != NULL, return;);
181 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
182
183 ircomm_tty_shutdown(self);
184
185 self->magic = 0;
186 tty_port_destroy(&self->port);
187 kfree(self);
188}
189
190
191
192
193
194
195
196static void __exit ircomm_tty_cleanup(void)
197{
198 int ret;
199
200 IRDA_DEBUG(4, "%s()\n", __func__ );
201
202 ret = tty_unregister_driver(driver);
203 if (ret) {
204 IRDA_ERROR("%s(), failed to unregister driver\n",
205 __func__);
206 return;
207 }
208
209 hashbin_delete(ircomm_tty, (FREE_FUNC) __ircomm_tty_cleanup);
210 put_tty_driver(driver);
211}
212
213
214
215
216
217
218
219static int ircomm_tty_startup(struct ircomm_tty_cb *self)
220{
221 notify_t notify;
222 int ret = -ENODEV;
223
224 IRDA_DEBUG(2, "%s()\n", __func__ );
225
226 IRDA_ASSERT(self != NULL, return -1;);
227 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
228
229
230 if (test_and_set_bit(ASYNCB_INITIALIZED, &self->port.flags)) {
231 IRDA_DEBUG(2, "%s(), already open so break out!\n", __func__ );
232 return 0;
233 }
234
235
236 irda_notify_init(¬ify);
237
238 notify.data_indication = ircomm_tty_data_indication;
239 notify.udata_indication = ircomm_tty_control_indication;
240 notify.flow_indication = ircomm_tty_flow_indication;
241
242
243 notify.disconnect_indication = ircomm_tty_disconnect_indication;
244 notify.connect_confirm = ircomm_tty_connect_confirm;
245 notify.connect_indication = ircomm_tty_connect_indication;
246 strlcpy(notify.name, "ircomm_tty", sizeof(notify.name));
247 notify.instance = self;
248
249 if (!self->ircomm) {
250 self->ircomm = ircomm_open(¬ify, self->service_type,
251 self->line);
252 }
253 if (!self->ircomm)
254 goto err;
255
256 self->slsap_sel = self->ircomm->slsap_sel;
257
258
259 ret = ircomm_tty_attach_cable(self);
260 if (ret < 0) {
261 IRDA_ERROR("%s(), error attaching cable!\n", __func__);
262 goto err;
263 }
264
265 return 0;
266err:
267 clear_bit(ASYNCB_INITIALIZED, &self->port.flags);
268 return ret;
269}
270
271
272
273
274
275
276
277static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self,
278 struct tty_struct *tty, struct file *filp)
279{
280 struct tty_port *port = &self->port;
281 DECLARE_WAITQUEUE(wait, current);
282 int retval;
283 int do_clocal = 0;
284 unsigned long flags;
285
286 IRDA_DEBUG(2, "%s()\n", __func__ );
287
288
289
290
291
292 if (test_bit(TTY_IO_ERROR, &tty->flags)) {
293 port->flags |= ASYNC_NORMAL_ACTIVE;
294 return 0;
295 }
296
297 if (filp->f_flags & O_NONBLOCK) {
298
299 if (tty->termios.c_cflag & CBAUD)
300 tty_port_raise_dtr_rts(port);
301 port->flags |= ASYNC_NORMAL_ACTIVE;
302 IRDA_DEBUG(1, "%s(), O_NONBLOCK requested!\n", __func__ );
303 return 0;
304 }
305
306 if (tty->termios.c_cflag & CLOCAL) {
307 IRDA_DEBUG(1, "%s(), doing CLOCAL!\n", __func__ );
308 do_clocal = 1;
309 }
310
311
312
313
314
315
316
317
318 retval = 0;
319 add_wait_queue(&port->open_wait, &wait);
320
321 IRDA_DEBUG(2, "%s(%d):block_til_ready before block on %s open_count=%d\n",
322 __FILE__, __LINE__, tty->driver->name, port->count);
323
324 spin_lock_irqsave(&port->lock, flags);
325 if (!tty_hung_up_p(filp))
326 port->count--;
327 port->blocked_open++;
328 spin_unlock_irqrestore(&port->lock, flags);
329
330 while (1) {
331 if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
332 tty_port_raise_dtr_rts(port);
333
334 set_current_state(TASK_INTERRUPTIBLE);
335
336 if (tty_hung_up_p(filp) ||
337 !test_bit(ASYNCB_INITIALIZED, &port->flags)) {
338 retval = (port->flags & ASYNC_HUP_NOTIFY) ?
339 -EAGAIN : -ERESTARTSYS;
340 break;
341 }
342
343
344
345
346
347
348 if (!test_bit(ASYNCB_CLOSING, &port->flags) &&
349 (do_clocal || tty_port_carrier_raised(port)) &&
350 self->state == IRCOMM_TTY_READY)
351 {
352 break;
353 }
354
355 if (signal_pending(current)) {
356 retval = -ERESTARTSYS;
357 break;
358 }
359
360 IRDA_DEBUG(1, "%s(%d):block_til_ready blocking on %s open_count=%d\n",
361 __FILE__, __LINE__, tty->driver->name, port->count);
362
363 schedule();
364 }
365
366 __set_current_state(TASK_RUNNING);
367 remove_wait_queue(&port->open_wait, &wait);
368
369 spin_lock_irqsave(&port->lock, flags);
370 if (!tty_hung_up_p(filp))
371 port->count++;
372 port->blocked_open--;
373 spin_unlock_irqrestore(&port->lock, flags);
374
375 IRDA_DEBUG(1, "%s(%d):block_til_ready after blocking on %s open_count=%d\n",
376 __FILE__, __LINE__, tty->driver->name, port->count);
377
378 if (!retval)
379 port->flags |= ASYNC_NORMAL_ACTIVE;
380
381 return retval;
382}
383
384
385static int ircomm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
386{
387 struct ircomm_tty_cb *self;
388 unsigned int line = tty->index;
389
390
391 self = hashbin_lock_find(ircomm_tty, line, NULL);
392 if (!self) {
393
394 self = kzalloc(sizeof(struct ircomm_tty_cb), GFP_KERNEL);
395 if (self == NULL) {
396 IRDA_ERROR("%s(), kmalloc failed!\n", __func__);
397 return -ENOMEM;
398 }
399
400 tty_port_init(&self->port);
401 self->port.ops = &ircomm_port_ops;
402 self->magic = IRCOMM_TTY_MAGIC;
403 self->flow = FLOW_STOP;
404
405 self->line = line;
406 INIT_WORK(&self->tqueue, ircomm_tty_do_softint);
407 self->max_header_size = IRCOMM_TTY_HDR_UNINITIALISED;
408 self->max_data_size = IRCOMM_TTY_DATA_UNINITIALISED;
409
410
411 init_timer(&self->watchdog_timer);
412 spin_lock_init(&self->spinlock);
413
414
415
416
417
418
419
420
421 tty->termios.c_iflag = 0;
422 tty->termios.c_oflag = 0;
423
424
425 hashbin_insert(ircomm_tty, (irda_queue_t *) self, line, NULL);
426 }
427
428 tty->driver_data = self;
429
430 return tty_port_install(&self->port, driver, tty);
431}
432
433
434
435
436
437
438
439
440static int ircomm_tty_open(struct tty_struct *tty, struct file *filp)
441{
442 struct ircomm_tty_cb *self = tty->driver_data;
443 unsigned long flags;
444 int ret;
445
446 IRDA_DEBUG(2, "%s()\n", __func__ );
447
448
449 spin_lock_irqsave(&self->port.lock, flags);
450 self->port.count++;
451 spin_unlock_irqrestore(&self->port.lock, flags);
452 tty_port_tty_set(&self->port, tty);
453
454 IRDA_DEBUG(1, "%s(), %s%d, count = %d\n", __func__ , tty->driver->name,
455 self->line, self->port.count);
456
457
458 self->port.low_latency = (self->port.flags & ASYNC_LOW_LATENCY) ? 1 : 0;
459
460
461
462
463 if (tty_hung_up_p(filp) ||
464 test_bit(ASYNCB_CLOSING, &self->port.flags)) {
465
466
467
468
469
470
471
472
473
474 if (wait_event_interruptible(self->port.close_wait,
475 !test_bit(ASYNCB_CLOSING, &self->port.flags))) {
476 IRDA_WARNING("%s - got signal while blocking on ASYNC_CLOSING!\n",
477 __func__);
478 return -ERESTARTSYS;
479 }
480
481#ifdef SERIAL_DO_RESTART
482 return (self->port.flags & ASYNC_HUP_NOTIFY) ?
483 -EAGAIN : -ERESTARTSYS;
484#else
485 return -EAGAIN;
486#endif
487 }
488
489
490 if (self->line < 0x10) {
491 self->service_type = IRCOMM_3_WIRE | IRCOMM_9_WIRE;
492 self->settings.service_type = IRCOMM_9_WIRE;
493
494 self->settings.dce = IRCOMM_CTS | IRCOMM_CD | IRCOMM_DSR | IRCOMM_RI;
495 IRDA_DEBUG(2, "%s(), IrCOMM device\n", __func__ );
496 } else {
497 IRDA_DEBUG(2, "%s(), IrLPT device\n", __func__ );
498 self->service_type = IRCOMM_3_WIRE_RAW;
499 self->settings.service_type = IRCOMM_3_WIRE_RAW;
500 }
501
502 ret = ircomm_tty_startup(self);
503 if (ret)
504 return ret;
505
506 ret = ircomm_tty_block_til_ready(self, tty, filp);
507 if (ret) {
508 IRDA_DEBUG(2,
509 "%s(), returning after block_til_ready with %d\n", __func__ ,
510 ret);
511
512 return ret;
513 }
514 return 0;
515}
516
517
518
519
520
521
522
523static void ircomm_tty_close(struct tty_struct *tty, struct file *filp)
524{
525 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
526 struct tty_port *port = &self->port;
527
528 IRDA_DEBUG(0, "%s()\n", __func__ );
529
530 IRDA_ASSERT(self != NULL, return;);
531 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
532
533 if (tty_port_close_start(port, tty, filp) == 0)
534 return;
535
536 ircomm_tty_shutdown(self);
537
538 tty_driver_flush_buffer(tty);
539
540 tty_port_close_end(port, tty);
541 tty_port_tty_set(port, NULL);
542}
543
544
545
546
547
548
549
550static void ircomm_tty_flush_buffer(struct tty_struct *tty)
551{
552 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
553
554 IRDA_ASSERT(self != NULL, return;);
555 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
556
557
558
559
560
561 schedule_work(&self->tqueue);
562}
563
564
565
566
567
568
569
570
571static void ircomm_tty_do_softint(struct work_struct *work)
572{
573 struct ircomm_tty_cb *self =
574 container_of(work, struct ircomm_tty_cb, tqueue);
575 struct tty_struct *tty;
576 unsigned long flags;
577 struct sk_buff *skb, *ctrl_skb;
578
579 IRDA_DEBUG(2, "%s()\n", __func__ );
580
581 if (!self || self->magic != IRCOMM_TTY_MAGIC)
582 return;
583
584 tty = tty_port_tty_get(&self->port);
585 if (!tty)
586 return;
587
588
589 spin_lock_irqsave(&self->spinlock, flags);
590
591 ctrl_skb = self->ctrl_skb;
592 self->ctrl_skb = NULL;
593
594 spin_unlock_irqrestore(&self->spinlock, flags);
595
596
597 if(ctrl_skb) {
598 if(self->flow == FLOW_START)
599 ircomm_control_request(self->ircomm, ctrl_skb);
600
601 dev_kfree_skb(ctrl_skb);
602 }
603
604 if (tty->hw_stopped)
605 goto put;
606
607
608 spin_lock_irqsave(&self->spinlock, flags);
609
610 skb = self->tx_skb;
611 self->tx_skb = NULL;
612
613 spin_unlock_irqrestore(&self->spinlock, flags);
614
615
616 if (skb) {
617 ircomm_tty_do_event(self, IRCOMM_TTY_DATA_REQUEST, skb, NULL);
618
619 dev_kfree_skb(skb);
620 }
621
622
623 tty_wakeup(tty);
624put:
625 tty_kref_put(tty);
626}
627
628
629
630
631
632
633
634
635
636static int ircomm_tty_write(struct tty_struct *tty,
637 const unsigned char *buf, int count)
638{
639 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
640 unsigned long flags;
641 struct sk_buff *skb;
642 int tailroom = 0;
643 int len = 0;
644 int size;
645
646 IRDA_DEBUG(2, "%s(), count=%d, hw_stopped=%d\n", __func__ , count,
647 tty->hw_stopped);
648
649 IRDA_ASSERT(self != NULL, return -1;);
650 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668 if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED) {
669 IRDA_DEBUG(1, "%s() : not initialised\n", __func__);
670#ifdef IRCOMM_NO_TX_BEFORE_INIT
671
672 return 0;
673#endif
674 }
675
676 if (count < 1)
677 return 0;
678
679
680 spin_lock_irqsave(&self->spinlock, flags);
681
682
683 skb = self->tx_skb;
684
685
686
687
688
689
690
691
692
693 while (count) {
694 size = count;
695
696
697 if (size > self->max_data_size)
698 size = self->max_data_size;
699
700
701
702
703
704 if (skb) {
705
706
707
708
709
710
711
712
713
714 if ((tailroom = (self->tx_data_size - skb->len)) > 0) {
715
716 if (size > tailroom)
717 size = tailroom;
718 } else {
719
720
721
722
723 break;
724 }
725 } else {
726
727 skb = alloc_skb(self->max_data_size+
728 self->max_header_size,
729 GFP_ATOMIC);
730 if (!skb) {
731 spin_unlock_irqrestore(&self->spinlock, flags);
732 return -ENOBUFS;
733 }
734 skb_reserve(skb, self->max_header_size);
735 self->tx_skb = skb;
736
737
738 self->tx_data_size = self->max_data_size;
739 }
740
741
742 memcpy(skb_put(skb,size), buf + len, size);
743
744 count -= size;
745 len += size;
746 }
747
748 spin_unlock_irqrestore(&self->spinlock, flags);
749
750
751
752
753
754
755
756
757 schedule_work(&self->tqueue);
758
759 return len;
760}
761
762
763
764
765
766
767
768
769static int ircomm_tty_write_room(struct tty_struct *tty)
770{
771 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
772 unsigned long flags;
773 int ret;
774
775 IRDA_ASSERT(self != NULL, return -1;);
776 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
777
778#ifdef IRCOMM_NO_TX_BEFORE_INIT
779
780 if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED)
781
782 return 0;
783#endif
784
785
786
787
788 if (tty->hw_stopped)
789 ret = 0;
790 else {
791 spin_lock_irqsave(&self->spinlock, flags);
792 if (self->tx_skb)
793 ret = self->tx_data_size - self->tx_skb->len;
794 else
795 ret = self->max_data_size;
796 spin_unlock_irqrestore(&self->spinlock, flags);
797 }
798 IRDA_DEBUG(2, "%s(), ret=%d\n", __func__ , ret);
799
800 return ret;
801}
802
803
804
805
806
807
808
809static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
810{
811 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
812 unsigned long orig_jiffies, poll_time;
813 unsigned long flags;
814
815 IRDA_DEBUG(2, "%s()\n", __func__ );
816
817 IRDA_ASSERT(self != NULL, return;);
818 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
819
820 orig_jiffies = jiffies;
821
822
823 poll_time = IRDA_MIN(timeout, msecs_to_jiffies(200));
824
825 spin_lock_irqsave(&self->spinlock, flags);
826 while (self->tx_skb && self->tx_skb->len) {
827 spin_unlock_irqrestore(&self->spinlock, flags);
828 schedule_timeout_interruptible(poll_time);
829 spin_lock_irqsave(&self->spinlock, flags);
830 if (signal_pending(current))
831 break;
832 if (timeout && time_after(jiffies, orig_jiffies + timeout))
833 break;
834 }
835 spin_unlock_irqrestore(&self->spinlock, flags);
836 current->state = TASK_RUNNING;
837}
838
839
840
841
842
843
844
845
846static void ircomm_tty_throttle(struct tty_struct *tty)
847{
848 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
849
850 IRDA_DEBUG(2, "%s()\n", __func__ );
851
852 IRDA_ASSERT(self != NULL, return;);
853 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
854
855
856 if (I_IXOFF(tty))
857 ircomm_tty_send_xchar(tty, STOP_CHAR(tty));
858
859
860 if (tty->termios.c_cflag & CRTSCTS) {
861 self->settings.dte &= ~IRCOMM_RTS;
862 self->settings.dte |= IRCOMM_DELTA_RTS;
863
864 ircomm_param_request(self, IRCOMM_DTE, TRUE);
865 }
866
867 ircomm_flow_request(self->ircomm, FLOW_STOP);
868}
869
870
871
872
873
874
875
876
877static void ircomm_tty_unthrottle(struct tty_struct *tty)
878{
879 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
880
881 IRDA_DEBUG(2, "%s()\n", __func__ );
882
883 IRDA_ASSERT(self != NULL, return;);
884 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
885
886
887 if (I_IXOFF(tty)) {
888 ircomm_tty_send_xchar(tty, START_CHAR(tty));
889 }
890
891
892 if (tty->termios.c_cflag & CRTSCTS) {
893 self->settings.dte |= (IRCOMM_RTS|IRCOMM_DELTA_RTS);
894
895 ircomm_param_request(self, IRCOMM_DTE, TRUE);
896 IRDA_DEBUG(1, "%s(), FLOW_START\n", __func__ );
897 }
898 ircomm_flow_request(self->ircomm, FLOW_START);
899}
900
901
902
903
904
905
906
907static int ircomm_tty_chars_in_buffer(struct tty_struct *tty)
908{
909 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
910 unsigned long flags;
911 int len = 0;
912
913 IRDA_ASSERT(self != NULL, return -1;);
914 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
915
916 spin_lock_irqsave(&self->spinlock, flags);
917
918 if (self->tx_skb)
919 len = self->tx_skb->len;
920
921 spin_unlock_irqrestore(&self->spinlock, flags);
922
923 return len;
924}
925
926static void ircomm_tty_shutdown(struct ircomm_tty_cb *self)
927{
928 unsigned long flags;
929
930 IRDA_ASSERT(self != NULL, return;);
931 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
932
933 IRDA_DEBUG(0, "%s()\n", __func__ );
934
935 if (!test_and_clear_bit(ASYNCB_INITIALIZED, &self->port.flags))
936 return;
937
938 ircomm_tty_detach_cable(self);
939
940 spin_lock_irqsave(&self->spinlock, flags);
941
942 del_timer(&self->watchdog_timer);
943
944
945 if (self->ctrl_skb) {
946 dev_kfree_skb(self->ctrl_skb);
947 self->ctrl_skb = NULL;
948 }
949
950
951 if (self->tx_skb) {
952 dev_kfree_skb(self->tx_skb);
953 self->tx_skb = NULL;
954 }
955
956 if (self->ircomm) {
957 ircomm_close(self->ircomm);
958 self->ircomm = NULL;
959 }
960
961 spin_unlock_irqrestore(&self->spinlock, flags);
962}
963
964
965
966
967
968
969
970
971static void ircomm_tty_hangup(struct tty_struct *tty)
972{
973 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
974 struct tty_port *port = &self->port;
975 unsigned long flags;
976
977 IRDA_DEBUG(0, "%s()\n", __func__ );
978
979 IRDA_ASSERT(self != NULL, return;);
980 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
981
982
983 ircomm_tty_shutdown(self);
984
985 spin_lock_irqsave(&port->lock, flags);
986 port->flags &= ~ASYNC_NORMAL_ACTIVE;
987 if (port->tty) {
988 set_bit(TTY_IO_ERROR, &port->tty->flags);
989 tty_kref_put(port->tty);
990 }
991 port->tty = NULL;
992 port->count = 0;
993 spin_unlock_irqrestore(&port->lock, flags);
994
995 wake_up_interruptible(&port->open_wait);
996}
997
998
999
1000
1001
1002
1003
1004static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch)
1005{
1006 IRDA_DEBUG(0, "%s(), not impl\n", __func__ );
1007}
1008
1009
1010
1011
1012
1013
1014
1015void ircomm_tty_start(struct tty_struct *tty)
1016{
1017 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
1018
1019 ircomm_flow_request(self->ircomm, FLOW_START);
1020}
1021
1022
1023
1024
1025
1026
1027
1028static void ircomm_tty_stop(struct tty_struct *tty)
1029{
1030 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
1031
1032 IRDA_ASSERT(self != NULL, return;);
1033 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
1034
1035 ircomm_flow_request(self->ircomm, FLOW_STOP);
1036}
1037
1038
1039
1040
1041
1042
1043
1044
1045void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self)
1046{
1047 struct tty_struct *tty;
1048 int status;
1049
1050 IRDA_DEBUG(0, "%s()\n", __func__ );
1051
1052 IRDA_ASSERT(self != NULL, return;);
1053 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
1054
1055 tty = tty_port_tty_get(&self->port);
1056
1057 status = self->settings.dce;
1058
1059 if (status & IRCOMM_DCE_DELTA_ANY) {
1060
1061 }
1062 if ((self->port.flags & ASYNC_CHECK_CD) && (status & IRCOMM_DELTA_CD)) {
1063 IRDA_DEBUG(2,
1064 "%s(), ircomm%d CD now %s...\n", __func__ , self->line,
1065 (status & IRCOMM_CD) ? "on" : "off");
1066
1067 if (status & IRCOMM_CD) {
1068 wake_up_interruptible(&self->port.open_wait);
1069 } else {
1070 IRDA_DEBUG(2,
1071 "%s(), Doing serial hangup..\n", __func__ );
1072 if (tty)
1073 tty_hangup(tty);
1074
1075
1076 goto put;
1077 }
1078 }
1079 if (tty && tty_port_cts_enabled(&self->port)) {
1080 if (tty->hw_stopped) {
1081 if (status & IRCOMM_CTS) {
1082 IRDA_DEBUG(2,
1083 "%s(), CTS tx start...\n", __func__ );
1084 tty->hw_stopped = 0;
1085
1086
1087 wake_up_interruptible(&self->port.open_wait);
1088
1089 schedule_work(&self->tqueue);
1090 goto put;
1091 }
1092 } else {
1093 if (!(status & IRCOMM_CTS)) {
1094 IRDA_DEBUG(2,
1095 "%s(), CTS tx stop...\n", __func__ );
1096 tty->hw_stopped = 1;
1097 }
1098 }
1099 }
1100put:
1101 tty_kref_put(tty);
1102}
1103
1104
1105
1106
1107
1108
1109
1110static int ircomm_tty_data_indication(void *instance, void *sap,
1111 struct sk_buff *skb)
1112{
1113 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
1114 struct tty_struct *tty;
1115
1116 IRDA_DEBUG(2, "%s()\n", __func__ );
1117
1118 IRDA_ASSERT(self != NULL, return -1;);
1119 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
1120 IRDA_ASSERT(skb != NULL, return -1;);
1121
1122 tty = tty_port_tty_get(&self->port);
1123 if (!tty) {
1124 IRDA_DEBUG(0, "%s(), no tty!\n", __func__ );
1125 return 0;
1126 }
1127
1128
1129
1130
1131
1132
1133
1134 if (tty->hw_stopped && (self->flow == FLOW_START)) {
1135 IRDA_DEBUG(0, "%s(), polling for line settings!\n", __func__ );
1136 ircomm_param_request(self, IRCOMM_POLL, TRUE);
1137
1138
1139 ircomm_tty_send_initial_parameters(self);
1140 ircomm_tty_link_established(self);
1141 }
1142 tty_kref_put(tty);
1143
1144
1145
1146
1147
1148 tty_insert_flip_string(&self->port, skb->data, skb->len);
1149 tty_flip_buffer_push(&self->port);
1150
1151
1152
1153 return 0;
1154}
1155
1156
1157
1158
1159
1160
1161
1162static int ircomm_tty_control_indication(void *instance, void *sap,
1163 struct sk_buff *skb)
1164{
1165 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
1166 int clen;
1167
1168 IRDA_DEBUG(4, "%s()\n", __func__ );
1169
1170 IRDA_ASSERT(self != NULL, return -1;);
1171 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
1172 IRDA_ASSERT(skb != NULL, return -1;);
1173
1174 clen = skb->data[0];
1175
1176 irda_param_extract_all(self, skb->data+1, IRDA_MIN(skb->len-1, clen),
1177 &ircomm_param_info);
1178
1179
1180
1181 return 0;
1182}
1183
1184
1185
1186
1187
1188
1189
1190
1191static void ircomm_tty_flow_indication(void *instance, void *sap,
1192 LOCAL_FLOW cmd)
1193{
1194 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
1195 struct tty_struct *tty;
1196
1197 IRDA_ASSERT(self != NULL, return;);
1198 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
1199
1200 tty = tty_port_tty_get(&self->port);
1201
1202 switch (cmd) {
1203 case FLOW_START:
1204 IRDA_DEBUG(2, "%s(), hw start!\n", __func__ );
1205 if (tty)
1206 tty->hw_stopped = 0;
1207
1208
1209 schedule_work(&self->tqueue);
1210 break;
1211 default:
1212 case FLOW_STOP:
1213 IRDA_DEBUG(2, "%s(), hw stopped!\n", __func__ );
1214 if (tty)
1215 tty->hw_stopped = 1;
1216 break;
1217 }
1218
1219 tty_kref_put(tty);
1220 self->flow = cmd;
1221}
1222
1223#ifdef CONFIG_PROC_FS
1224static void ircomm_tty_line_info(struct ircomm_tty_cb *self, struct seq_file *m)
1225{
1226 struct tty_struct *tty;
1227 char sep;
1228
1229 seq_printf(m, "State: %s\n", ircomm_tty_state[self->state]);
1230
1231 seq_puts(m, "Service type: ");
1232 if (self->service_type & IRCOMM_9_WIRE)
1233 seq_puts(m, "9_WIRE");
1234 else if (self->service_type & IRCOMM_3_WIRE)
1235 seq_puts(m, "3_WIRE");
1236 else if (self->service_type & IRCOMM_3_WIRE_RAW)
1237 seq_puts(m, "3_WIRE_RAW");
1238 else
1239 seq_puts(m, "No common service type!\n");
1240 seq_putc(m, '\n');
1241
1242 seq_printf(m, "Port name: %s\n", self->settings.port_name);
1243
1244 seq_printf(m, "DTE status:");
1245 sep = ' ';
1246 if (self->settings.dte & IRCOMM_RTS) {
1247 seq_printf(m, "%cRTS", sep);
1248 sep = '|';
1249 }
1250 if (self->settings.dte & IRCOMM_DTR) {
1251 seq_printf(m, "%cDTR", sep);
1252 sep = '|';
1253 }
1254 seq_putc(m, '\n');
1255
1256 seq_puts(m, "DCE status:");
1257 sep = ' ';
1258 if (self->settings.dce & IRCOMM_CTS) {
1259 seq_printf(m, "%cCTS", sep);
1260 sep = '|';
1261 }
1262 if (self->settings.dce & IRCOMM_DSR) {
1263 seq_printf(m, "%cDSR", sep);
1264 sep = '|';
1265 }
1266 if (self->settings.dce & IRCOMM_CD) {
1267 seq_printf(m, "%cCD", sep);
1268 sep = '|';
1269 }
1270 if (self->settings.dce & IRCOMM_RI) {
1271 seq_printf(m, "%cRI", sep);
1272 sep = '|';
1273 }
1274 seq_putc(m, '\n');
1275
1276 seq_puts(m, "Configuration: ");
1277 if (!self->settings.null_modem)
1278 seq_puts(m, "DTE <-> DCE\n");
1279 else
1280 seq_puts(m, "DTE <-> DTE (null modem emulation)\n");
1281
1282 seq_printf(m, "Data rate: %d\n", self->settings.data_rate);
1283
1284 seq_puts(m, "Flow control:");
1285 sep = ' ';
1286 if (self->settings.flow_control & IRCOMM_XON_XOFF_IN) {
1287 seq_printf(m, "%cXON_XOFF_IN", sep);
1288 sep = '|';
1289 }
1290 if (self->settings.flow_control & IRCOMM_XON_XOFF_OUT) {
1291 seq_printf(m, "%cXON_XOFF_OUT", sep);
1292 sep = '|';
1293 }
1294 if (self->settings.flow_control & IRCOMM_RTS_CTS_IN) {
1295 seq_printf(m, "%cRTS_CTS_IN", sep);
1296 sep = '|';
1297 }
1298 if (self->settings.flow_control & IRCOMM_RTS_CTS_OUT) {
1299 seq_printf(m, "%cRTS_CTS_OUT", sep);
1300 sep = '|';
1301 }
1302 if (self->settings.flow_control & IRCOMM_DSR_DTR_IN) {
1303 seq_printf(m, "%cDSR_DTR_IN", sep);
1304 sep = '|';
1305 }
1306 if (self->settings.flow_control & IRCOMM_DSR_DTR_OUT) {
1307 seq_printf(m, "%cDSR_DTR_OUT", sep);
1308 sep = '|';
1309 }
1310 if (self->settings.flow_control & IRCOMM_ENQ_ACK_IN) {
1311 seq_printf(m, "%cENQ_ACK_IN", sep);
1312 sep = '|';
1313 }
1314 if (self->settings.flow_control & IRCOMM_ENQ_ACK_OUT) {
1315 seq_printf(m, "%cENQ_ACK_OUT", sep);
1316 sep = '|';
1317 }
1318 seq_putc(m, '\n');
1319
1320 seq_puts(m, "Flags:");
1321 sep = ' ';
1322 if (tty_port_cts_enabled(&self->port)) {
1323 seq_printf(m, "%cASYNC_CTS_FLOW", sep);
1324 sep = '|';
1325 }
1326 if (self->port.flags & ASYNC_CHECK_CD) {
1327 seq_printf(m, "%cASYNC_CHECK_CD", sep);
1328 sep = '|';
1329 }
1330 if (self->port.flags & ASYNC_INITIALIZED) {
1331 seq_printf(m, "%cASYNC_INITIALIZED", sep);
1332 sep = '|';
1333 }
1334 if (self->port.flags & ASYNC_LOW_LATENCY) {
1335 seq_printf(m, "%cASYNC_LOW_LATENCY", sep);
1336 sep = '|';
1337 }
1338 if (self->port.flags & ASYNC_CLOSING) {
1339 seq_printf(m, "%cASYNC_CLOSING", sep);
1340 sep = '|';
1341 }
1342 if (self->port.flags & ASYNC_NORMAL_ACTIVE) {
1343 seq_printf(m, "%cASYNC_NORMAL_ACTIVE", sep);
1344 sep = '|';
1345 }
1346 seq_putc(m, '\n');
1347
1348 seq_printf(m, "Role: %s\n", self->client ? "client" : "server");
1349 seq_printf(m, "Open count: %d\n", self->port.count);
1350 seq_printf(m, "Max data size: %d\n", self->max_data_size);
1351 seq_printf(m, "Max header size: %d\n", self->max_header_size);
1352
1353 tty = tty_port_tty_get(&self->port);
1354 if (tty) {
1355 seq_printf(m, "Hardware: %s\n",
1356 tty->hw_stopped ? "Stopped" : "Running");
1357 tty_kref_put(tty);
1358 }
1359}
1360
1361static int ircomm_tty_proc_show(struct seq_file *m, void *v)
1362{
1363 struct ircomm_tty_cb *self;
1364 unsigned long flags;
1365
1366 spin_lock_irqsave(&ircomm_tty->hb_spinlock, flags);
1367
1368 self = (struct ircomm_tty_cb *) hashbin_get_first(ircomm_tty);
1369 while (self != NULL) {
1370 if (self->magic != IRCOMM_TTY_MAGIC)
1371 break;
1372
1373 ircomm_tty_line_info(self, m);
1374 self = (struct ircomm_tty_cb *) hashbin_get_next(ircomm_tty);
1375 }
1376 spin_unlock_irqrestore(&ircomm_tty->hb_spinlock, flags);
1377 return 0;
1378}
1379
1380static int ircomm_tty_proc_open(struct inode *inode, struct file *file)
1381{
1382 return single_open(file, ircomm_tty_proc_show, NULL);
1383}
1384
1385static const struct file_operations ircomm_tty_proc_fops = {
1386 .owner = THIS_MODULE,
1387 .open = ircomm_tty_proc_open,
1388 .read = seq_read,
1389 .llseek = seq_lseek,
1390 .release = single_release,
1391};
1392#endif
1393
1394MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
1395MODULE_DESCRIPTION("IrCOMM serial TTY driver");
1396MODULE_LICENSE("GPL");
1397MODULE_ALIAS_CHARDEV_MAJOR(IRCOMM_TTY_MAJOR);
1398
1399module_init(ircomm_tty_init);
1400module_exit(ircomm_tty_cleanup);
1401