1
2
3
4
5
6
7#include <linux/delay.h>
8#include <linux/interrupt.h>
9#include <linux/module.h>
10#include <linux/slab.h>
11#include <linux/sysfs.h>
12#include <linux/tty.h>
13#include <linux/tty_flip.h>
14#include <asm/vio.h>
15#include <asm/ldc.h>
16
17#define DRV_MODULE_NAME "vcc"
18#define DRV_MODULE_VERSION "1.1"
19#define DRV_MODULE_RELDATE "July 1, 2017"
20
21static char version[] =
22 DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")";
23
24MODULE_DESCRIPTION("Sun LDOM virtual console concentrator driver");
25MODULE_LICENSE("GPL");
26MODULE_VERSION(DRV_MODULE_VERSION);
27
28struct vcc_port {
29 struct vio_driver_state vio;
30
31 spinlock_t lock;
32 char *domain;
33 struct tty_struct *tty;
34 unsigned long index;
35
36 u64 refcnt;
37 bool excl_locked;
38
39 bool removed;
40
41
42
43
44
45 int chars_in_buffer;
46 struct vio_vcc buffer;
47
48 struct timer_list rx_timer;
49 struct timer_list tx_timer;
50};
51
52
53#define VCC_REF_DELAY 100
54
55#define VCC_MAX_PORTS 1024
56#define VCC_MINOR_START 0
57#define VCC_BUFF_LEN VIO_VCC_MTU_SIZE
58
59#define VCC_CTL_BREAK -1
60#define VCC_CTL_HUP -2
61
62static const char vcc_driver_name[] = "vcc";
63static const char vcc_device_node[] = "vcc";
64static struct tty_driver *vcc_tty_driver;
65
66static struct vcc_port *vcc_table[VCC_MAX_PORTS];
67static DEFINE_SPINLOCK(vcc_table_lock);
68
69int vcc_dbg;
70int vcc_dbg_ldc;
71int vcc_dbg_vio;
72
73module_param(vcc_dbg, uint, 0664);
74module_param(vcc_dbg_ldc, uint, 0664);
75module_param(vcc_dbg_vio, uint, 0664);
76
77#define VCC_DBG_DRV 0x1
78#define VCC_DBG_LDC 0x2
79#define VCC_DBG_PKT 0x4
80
81#define vccdbg(f, a...) \
82 do { \
83 if (vcc_dbg & VCC_DBG_DRV) \
84 pr_info(f, ## a); \
85 } while (0) \
86
87#define vccdbgl(l) \
88 do { \
89 if (vcc_dbg & VCC_DBG_LDC) \
90 ldc_print(l); \
91 } while (0) \
92
93#define vccdbgp(pkt) \
94 do { \
95 if (vcc_dbg & VCC_DBG_PKT) { \
96 int i; \
97 for (i = 0; i < pkt.tag.stype; i++) \
98 pr_info("[%c]", pkt.data[i]); \
99 } \
100 } while (0) \
101
102
103
104
105
106static const struct ktermios vcc_tty_termios = {
107 .c_iflag = IGNBRK | IGNPAR,
108 .c_oflag = OPOST,
109 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
110 .c_cc = INIT_C_CC,
111 .c_ispeed = 38400,
112 .c_ospeed = 38400
113};
114
115
116
117
118
119
120
121
122static int vcc_table_add(struct vcc_port *port)
123{
124 unsigned long flags;
125 int i;
126
127 spin_lock_irqsave(&vcc_table_lock, flags);
128 for (i = VCC_MINOR_START; i < VCC_MAX_PORTS; i++) {
129 if (!vcc_table[i]) {
130 vcc_table[i] = port;
131 break;
132 }
133 }
134 spin_unlock_irqrestore(&vcc_table_lock, flags);
135
136 if (i < VCC_MAX_PORTS)
137 return i;
138 else
139 return -1;
140}
141
142
143
144
145
146static void vcc_table_remove(unsigned long index)
147{
148 unsigned long flags;
149
150 if (WARN_ON(index >= VCC_MAX_PORTS))
151 return;
152
153 spin_lock_irqsave(&vcc_table_lock, flags);
154 vcc_table[index] = NULL;
155 spin_unlock_irqrestore(&vcc_table_lock, flags);
156}
157
158
159
160
161
162
163
164
165
166static struct vcc_port *vcc_get(unsigned long index, bool excl)
167{
168 struct vcc_port *port;
169 unsigned long flags;
170
171try_again:
172 spin_lock_irqsave(&vcc_table_lock, flags);
173
174 port = vcc_table[index];
175 if (!port) {
176 spin_unlock_irqrestore(&vcc_table_lock, flags);
177 return NULL;
178 }
179
180 if (!excl) {
181 if (port->excl_locked) {
182 spin_unlock_irqrestore(&vcc_table_lock, flags);
183 udelay(VCC_REF_DELAY);
184 goto try_again;
185 }
186 port->refcnt++;
187 spin_unlock_irqrestore(&vcc_table_lock, flags);
188 return port;
189 }
190
191 if (port->refcnt) {
192 spin_unlock_irqrestore(&vcc_table_lock, flags);
193
194
195
196
197 udelay(VCC_REF_DELAY/2);
198 goto try_again;
199 }
200
201 port->refcnt++;
202 port->excl_locked = true;
203 spin_unlock_irqrestore(&vcc_table_lock, flags);
204
205 return port;
206}
207
208
209
210
211
212
213
214
215
216static void vcc_put(struct vcc_port *port, bool excl)
217{
218 unsigned long flags;
219
220 if (!port)
221 return;
222
223 spin_lock_irqsave(&vcc_table_lock, flags);
224
225
226 if (WARN_ON((excl && !port->excl_locked) ||
227 (!excl && port->excl_locked)))
228 goto done;
229
230 port->refcnt--;
231
232 if (excl)
233 port->excl_locked = false;
234
235done:
236 spin_unlock_irqrestore(&vcc_table_lock, flags);
237}
238
239
240
241
242
243
244
245
246
247
248static struct vcc_port *vcc_get_ne(unsigned long index)
249{
250 struct vcc_port *port;
251
252 port = vcc_get(index, false);
253
254 if (port && port->removed) {
255 vcc_put(port, false);
256 return NULL;
257 }
258
259 return port;
260}
261
262static void vcc_kick_rx(struct vcc_port *port)
263{
264 struct vio_driver_state *vio = &port->vio;
265
266 assert_spin_locked(&port->lock);
267
268 if (!timer_pending(&port->rx_timer) && !port->removed) {
269 disable_irq_nosync(vio->vdev->rx_irq);
270 port->rx_timer.expires = (jiffies + 1);
271 add_timer(&port->rx_timer);
272 }
273}
274
275static void vcc_kick_tx(struct vcc_port *port)
276{
277 assert_spin_locked(&port->lock);
278
279 if (!timer_pending(&port->tx_timer) && !port->removed) {
280 port->tx_timer.expires = (jiffies + 1);
281 add_timer(&port->tx_timer);
282 }
283}
284
285static int vcc_rx_check(struct tty_struct *tty, int size)
286{
287 if (WARN_ON(!tty || !tty->port))
288 return 1;
289
290
291
292
293 if (test_bit(TTY_THROTTLED, &tty->flags) ||
294 (tty_buffer_request_room(tty->port, VCC_BUFF_LEN) < VCC_BUFF_LEN))
295 return 0;
296
297 return 1;
298}
299
300static int vcc_rx(struct tty_struct *tty, char *buf, int size)
301{
302 int len = 0;
303
304 if (WARN_ON(!tty || !tty->port))
305 return len;
306
307 len = tty_insert_flip_string(tty->port, buf, size);
308 if (len)
309 tty_flip_buffer_push(tty->port);
310
311 return len;
312}
313
314static int vcc_ldc_read(struct vcc_port *port)
315{
316 struct vio_driver_state *vio = &port->vio;
317 struct tty_struct *tty;
318 struct vio_vcc pkt;
319 int rv = 0;
320
321 tty = port->tty;
322 if (!tty) {
323 rv = ldc_rx_reset(vio->lp);
324 vccdbg("VCC: reset rx q: rv=%d\n", rv);
325 goto done;
326 }
327
328
329 while (1) {
330 if (!vcc_rx_check(tty, VIO_VCC_MTU_SIZE)) {
331 vcc_kick_rx(port);
332 break;
333 }
334
335 vccdbgl(vio->lp);
336
337 rv = ldc_read(vio->lp, &pkt, sizeof(pkt));
338 if (rv <= 0)
339 break;
340
341 vccdbg("VCC: ldc_read()=%d\n", rv);
342 vccdbg("TAG [%02x:%02x:%04x:%08x]\n",
343 pkt.tag.type, pkt.tag.stype,
344 pkt.tag.stype_env, pkt.tag.sid);
345
346 if (pkt.tag.type == VIO_TYPE_DATA) {
347 vccdbgp(pkt);
348
349 vcc_rx(tty, pkt.data, pkt.tag.stype);
350 } else {
351 pr_err("VCC: unknown msg [%02x:%02x:%04x:%08x]\n",
352 pkt.tag.type, pkt.tag.stype,
353 pkt.tag.stype_env, pkt.tag.sid);
354 rv = -ECONNRESET;
355 break;
356 }
357
358 WARN_ON(rv != LDC_PACKET_SIZE);
359 }
360
361done:
362 return rv;
363}
364
365static void vcc_rx_timer(struct timer_list *t)
366{
367 struct vcc_port *port = from_timer(port, t, rx_timer);
368 struct vio_driver_state *vio;
369 unsigned long flags;
370 int rv;
371
372 spin_lock_irqsave(&port->lock, flags);
373 port->rx_timer.expires = 0;
374
375 vio = &port->vio;
376
377 enable_irq(vio->vdev->rx_irq);
378
379 if (!port->tty || port->removed)
380 goto done;
381
382 rv = vcc_ldc_read(port);
383 if (rv == -ECONNRESET)
384 vio_conn_reset(vio);
385
386done:
387 spin_unlock_irqrestore(&port->lock, flags);
388 vcc_put(port, false);
389}
390
391static void vcc_tx_timer(struct timer_list *t)
392{
393 struct vcc_port *port = from_timer(port, t, tx_timer);
394 struct vio_vcc *pkt;
395 unsigned long flags;
396 int tosend = 0;
397 int rv;
398
399 spin_lock_irqsave(&port->lock, flags);
400 port->tx_timer.expires = 0;
401
402 if (!port->tty || port->removed)
403 goto done;
404
405 tosend = min(VCC_BUFF_LEN, port->chars_in_buffer);
406 if (!tosend)
407 goto done;
408
409 pkt = &port->buffer;
410 pkt->tag.type = VIO_TYPE_DATA;
411 pkt->tag.stype = tosend;
412 vccdbgl(port->vio.lp);
413
414 rv = ldc_write(port->vio.lp, pkt, (VIO_TAG_SIZE + tosend));
415 WARN_ON(!rv);
416
417 if (rv < 0) {
418 vccdbg("VCC: ldc_write()=%d\n", rv);
419 vcc_kick_tx(port);
420 } else {
421 struct tty_struct *tty = port->tty;
422
423 port->chars_in_buffer = 0;
424 if (tty)
425 tty_wakeup(tty);
426 }
427
428done:
429 spin_unlock_irqrestore(&port->lock, flags);
430 vcc_put(port, false);
431}
432
433
434
435
436
437
438
439
440static void vcc_event(void *arg, int event)
441{
442 struct vio_driver_state *vio;
443 struct vcc_port *port;
444 unsigned long flags;
445 int rv;
446
447 port = arg;
448 vio = &port->vio;
449
450 spin_lock_irqsave(&port->lock, flags);
451
452 switch (event) {
453 case LDC_EVENT_RESET:
454 case LDC_EVENT_UP:
455 vio_link_state_change(vio, event);
456 break;
457
458 case LDC_EVENT_DATA_READY:
459 rv = vcc_ldc_read(port);
460 if (rv == -ECONNRESET)
461 vio_conn_reset(vio);
462 break;
463
464 default:
465 pr_err("VCC: unexpected LDC event(%d)\n", event);
466 }
467
468 spin_unlock_irqrestore(&port->lock, flags);
469}
470
471static struct ldc_channel_config vcc_ldc_cfg = {
472 .event = vcc_event,
473 .mtu = VIO_VCC_MTU_SIZE,
474 .mode = LDC_MODE_RAW,
475 .debug = 0,
476};
477
478
479static struct vio_version vcc_versions[] = {
480 { .major = 1, .minor = 0 },
481};
482
483static struct tty_port_operations vcc_port_ops = { 0 };
484
485static ssize_t vcc_sysfs_domain_show(struct device *dev,
486 struct device_attribute *attr,
487 char *buf)
488{
489 struct vcc_port *port;
490 int rv;
491
492 port = dev_get_drvdata(dev);
493 if (!port)
494 return -ENODEV;
495
496 rv = scnprintf(buf, PAGE_SIZE, "%s\n", port->domain);
497
498 return rv;
499}
500
501static int vcc_send_ctl(struct vcc_port *port, int ctl)
502{
503 struct vio_vcc pkt;
504 int rv;
505
506 pkt.tag.type = VIO_TYPE_CTRL;
507 pkt.tag.sid = ctl;
508 pkt.tag.stype = 0;
509
510 rv = ldc_write(port->vio.lp, &pkt, sizeof(pkt.tag));
511 WARN_ON(!rv);
512 vccdbg("VCC: ldc_write(%ld)=%d\n", sizeof(pkt.tag), rv);
513
514 return rv;
515}
516
517static ssize_t vcc_sysfs_break_store(struct device *dev,
518 struct device_attribute *attr,
519 const char *buf, size_t count)
520{
521 struct vcc_port *port;
522 unsigned long flags;
523 int rv = count;
524 int brk;
525
526 port = dev_get_drvdata(dev);
527 if (!port)
528 return -ENODEV;
529
530 spin_lock_irqsave(&port->lock, flags);
531
532 if (sscanf(buf, "%ud", &brk) != 1 || brk != 1)
533 rv = -EINVAL;
534 else if (vcc_send_ctl(port, VCC_CTL_BREAK) < 0)
535 vcc_kick_tx(port);
536
537 spin_unlock_irqrestore(&port->lock, flags);
538
539 return rv;
540}
541
542static DEVICE_ATTR(domain, 0400, vcc_sysfs_domain_show, NULL);
543static DEVICE_ATTR(break, 0200, NULL, vcc_sysfs_break_store);
544
545static struct attribute *vcc_sysfs_entries[] = {
546 &dev_attr_domain.attr,
547 &dev_attr_break.attr,
548 NULL
549};
550
551static struct attribute_group vcc_attribute_group = {
552 .name = NULL,
553 .attrs = vcc_sysfs_entries,
554};
555
556
557
558
559
560
561
562
563
564
565
566
567
568static int vcc_probe(struct vio_dev *vdev, const struct vio_device_id *id)
569{
570 struct mdesc_handle *hp;
571 struct vcc_port *port;
572 struct device *dev;
573 const char *domain;
574 char *name;
575 u64 node;
576 int rv;
577
578 vccdbg("VCC: name=%s\n", dev_name(&vdev->dev));
579
580 if (!vcc_tty_driver) {
581 pr_err("VCC: TTY driver not registered\n");
582 return -ENODEV;
583 }
584
585 port = kzalloc(sizeof(struct vcc_port), GFP_KERNEL);
586 if (!port)
587 return -ENOMEM;
588
589 name = kstrdup(dev_name(&vdev->dev), GFP_KERNEL);
590
591 rv = vio_driver_init(&port->vio, vdev, VDEV_CONSOLE_CON, vcc_versions,
592 ARRAY_SIZE(vcc_versions), NULL, name);
593 if (rv)
594 goto free_port;
595
596 port->vio.debug = vcc_dbg_vio;
597 vcc_ldc_cfg.debug = vcc_dbg_ldc;
598
599 rv = vio_ldc_alloc(&port->vio, &vcc_ldc_cfg, port);
600 if (rv)
601 goto free_port;
602
603 spin_lock_init(&port->lock);
604
605 port->index = vcc_table_add(port);
606 if (port->index == -1) {
607 pr_err("VCC: no more TTY indices left for allocation\n");
608 rv = -ENOMEM;
609 goto free_ldc;
610 }
611
612
613 dev = tty_register_device(vcc_tty_driver, port->index, &vdev->dev);
614 if (IS_ERR(dev)) {
615 rv = PTR_ERR(dev);
616 goto free_table;
617 }
618
619 hp = mdesc_grab();
620
621 node = vio_vdev_node(hp, vdev);
622 if (node == MDESC_NODE_NULL) {
623 rv = -ENXIO;
624 mdesc_release(hp);
625 goto unreg_tty;
626 }
627
628 domain = mdesc_get_property(hp, node, "vcc-domain-name", NULL);
629 if (!domain) {
630 rv = -ENXIO;
631 mdesc_release(hp);
632 goto unreg_tty;
633 }
634 port->domain = kstrdup(domain, GFP_KERNEL);
635
636 mdesc_release(hp);
637
638 rv = sysfs_create_group(&vdev->dev.kobj, &vcc_attribute_group);
639 if (rv)
640 goto free_domain;
641
642 timer_setup(&port->rx_timer, vcc_rx_timer, 0);
643 timer_setup(&port->tx_timer, vcc_tx_timer, 0);
644
645 dev_set_drvdata(&vdev->dev, port);
646
647
648
649
650 disable_irq_nosync(vdev->rx_irq);
651 vio_port_up(&port->vio);
652 enable_irq(vdev->rx_irq);
653
654 return 0;
655
656free_domain:
657 kfree(port->domain);
658unreg_tty:
659 tty_unregister_device(vcc_tty_driver, port->index);
660free_table:
661 vcc_table_remove(port->index);
662free_ldc:
663 vio_ldc_free(&port->vio);
664free_port:
665 kfree(name);
666 kfree(port);
667
668 return rv;
669}
670
671
672
673
674
675
676
677
678
679
680static int vcc_remove(struct vio_dev *vdev)
681{
682 struct vcc_port *port = dev_get_drvdata(&vdev->dev);
683
684 del_timer_sync(&port->rx_timer);
685 del_timer_sync(&port->tx_timer);
686
687
688
689
690
691 if (port->tty)
692 tty_vhangup(port->tty);
693
694
695
696
697 vcc_get(port->index, true);
698
699 tty_unregister_device(vcc_tty_driver, port->index);
700
701 del_timer_sync(&port->vio.timer);
702 vio_ldc_free(&port->vio);
703 sysfs_remove_group(&vdev->dev.kobj, &vcc_attribute_group);
704 dev_set_drvdata(&vdev->dev, NULL);
705 if (port->tty) {
706 port->removed = true;
707 vcc_put(port, true);
708 } else {
709 vcc_table_remove(port->index);
710
711 kfree(port->vio.name);
712 kfree(port->domain);
713 kfree(port);
714 }
715
716 return 0;
717}
718
719static const struct vio_device_id vcc_match[] = {
720 {
721 .type = "vcc-port",
722 },
723 {},
724};
725MODULE_DEVICE_TABLE(vio, vcc_match);
726
727static struct vio_driver vcc_driver = {
728 .id_table = vcc_match,
729 .probe = vcc_probe,
730 .remove = vcc_remove,
731 .name = "vcc",
732};
733
734static int vcc_open(struct tty_struct *tty, struct file *vcc_file)
735{
736 struct vcc_port *port;
737
738 if (unlikely(!tty)) {
739 pr_err("VCC: open: Invalid TTY handle\n");
740 return -ENXIO;
741 }
742
743 if (tty->count > 1)
744 return -EBUSY;
745
746 port = vcc_get_ne(tty->index);
747 if (unlikely(!port)) {
748 pr_err("VCC: open: Failed to find VCC port\n");
749 return -ENODEV;
750 }
751
752 if (unlikely(!port->vio.lp)) {
753 pr_err("VCC: open: LDC channel not configured\n");
754 vcc_put(port, false);
755 return -EPIPE;
756 }
757 vccdbgl(port->vio.lp);
758
759 vcc_put(port, false);
760
761 if (unlikely(!tty->port)) {
762 pr_err("VCC: open: TTY port not found\n");
763 return -ENXIO;
764 }
765
766 if (unlikely(!tty->port->ops)) {
767 pr_err("VCC: open: TTY ops not defined\n");
768 return -ENXIO;
769 }
770
771 return tty_port_open(tty->port, tty, vcc_file);
772}
773
774static void vcc_close(struct tty_struct *tty, struct file *vcc_file)
775{
776 if (unlikely(!tty)) {
777 pr_err("VCC: close: Invalid TTY handle\n");
778 return;
779 }
780
781 if (unlikely(tty->count > 1))
782 return;
783
784 if (unlikely(!tty->port)) {
785 pr_err("VCC: close: TTY port not found\n");
786 return;
787 }
788
789 tty_port_close(tty->port, tty, vcc_file);
790}
791
792static void vcc_ldc_hup(struct vcc_port *port)
793{
794 unsigned long flags;
795
796 spin_lock_irqsave(&port->lock, flags);
797
798 if (vcc_send_ctl(port, VCC_CTL_HUP) < 0)
799 vcc_kick_tx(port);
800
801 spin_unlock_irqrestore(&port->lock, flags);
802}
803
804static void vcc_hangup(struct tty_struct *tty)
805{
806 struct vcc_port *port;
807
808 if (unlikely(!tty)) {
809 pr_err("VCC: hangup: Invalid TTY handle\n");
810 return;
811 }
812
813 port = vcc_get_ne(tty->index);
814 if (unlikely(!port)) {
815 pr_err("VCC: hangup: Failed to find VCC port\n");
816 return;
817 }
818
819 if (unlikely(!tty->port)) {
820 pr_err("VCC: hangup: TTY port not found\n");
821 vcc_put(port, false);
822 return;
823 }
824
825 vcc_ldc_hup(port);
826
827 vcc_put(port, false);
828
829 tty_port_hangup(tty->port);
830}
831
832static int vcc_write(struct tty_struct *tty, const unsigned char *buf,
833 int count)
834{
835 struct vcc_port *port;
836 struct vio_vcc *pkt;
837 unsigned long flags;
838 int total_sent = 0;
839 int tosend = 0;
840 int rv = -EINVAL;
841
842 if (unlikely(!tty)) {
843 pr_err("VCC: write: Invalid TTY handle\n");
844 return -ENXIO;
845 }
846
847 port = vcc_get_ne(tty->index);
848 if (unlikely(!port)) {
849 pr_err("VCC: write: Failed to find VCC port");
850 return -ENODEV;
851 }
852
853 spin_lock_irqsave(&port->lock, flags);
854
855 pkt = &port->buffer;
856 pkt->tag.type = VIO_TYPE_DATA;
857
858 while (count > 0) {
859
860 tosend = min(count, (VCC_BUFF_LEN - port->chars_in_buffer));
861
862 if (!tosend)
863 break;
864
865 memcpy(&pkt->data[port->chars_in_buffer], &buf[total_sent],
866 tosend);
867 port->chars_in_buffer += tosend;
868 pkt->tag.stype = tosend;
869
870 vccdbg("TAG [%02x:%02x:%04x:%08x]\n", pkt->tag.type,
871 pkt->tag.stype, pkt->tag.stype_env, pkt->tag.sid);
872 vccdbg("DATA [%s]\n", pkt->data);
873 vccdbgl(port->vio.lp);
874
875
876
877
878
879 rv = ldc_write(port->vio.lp, pkt, (VIO_TAG_SIZE + tosend));
880 vccdbg("VCC: write: ldc_write(%d)=%d\n",
881 (VIO_TAG_SIZE + tosend), rv);
882
883 total_sent += tosend;
884 count -= tosend;
885 if (rv < 0) {
886 vcc_kick_tx(port);
887 break;
888 }
889
890 port->chars_in_buffer = 0;
891 }
892
893 spin_unlock_irqrestore(&port->lock, flags);
894
895 vcc_put(port, false);
896
897 vccdbg("VCC: write: total=%d rv=%d", total_sent, rv);
898
899 return total_sent ? total_sent : rv;
900}
901
902static int vcc_write_room(struct tty_struct *tty)
903{
904 struct vcc_port *port;
905 u64 num;
906
907 if (unlikely(!tty)) {
908 pr_err("VCC: write_room: Invalid TTY handle\n");
909 return -ENXIO;
910 }
911
912 port = vcc_get_ne(tty->index);
913 if (unlikely(!port)) {
914 pr_err("VCC: write_room: Failed to find VCC port\n");
915 return -ENODEV;
916 }
917
918 num = VCC_BUFF_LEN - port->chars_in_buffer;
919
920 vcc_put(port, false);
921
922 return num;
923}
924
925static int vcc_chars_in_buffer(struct tty_struct *tty)
926{
927 struct vcc_port *port;
928 u64 num;
929
930 if (unlikely(!tty)) {
931 pr_err("VCC: chars_in_buffer: Invalid TTY handle\n");
932 return -ENXIO;
933 }
934
935 port = vcc_get_ne(tty->index);
936 if (unlikely(!port)) {
937 pr_err("VCC: chars_in_buffer: Failed to find VCC port\n");
938 return -ENODEV;
939 }
940
941 num = port->chars_in_buffer;
942
943 vcc_put(port, false);
944
945 return num;
946}
947
948static int vcc_break_ctl(struct tty_struct *tty, int state)
949{
950 struct vcc_port *port;
951 unsigned long flags;
952
953 if (unlikely(!tty)) {
954 pr_err("VCC: break_ctl: Invalid TTY handle\n");
955 return -ENXIO;
956 }
957
958 port = vcc_get_ne(tty->index);
959 if (unlikely(!port)) {
960 pr_err("VCC: break_ctl: Failed to find VCC port\n");
961 return -ENODEV;
962 }
963
964
965 if (state == 0) {
966 vcc_put(port, false);
967 return 0;
968 }
969
970 spin_lock_irqsave(&port->lock, flags);
971
972 if (vcc_send_ctl(port, VCC_CTL_BREAK) < 0)
973 vcc_kick_tx(port);
974
975 spin_unlock_irqrestore(&port->lock, flags);
976
977 vcc_put(port, false);
978
979 return 0;
980}
981
982static int vcc_install(struct tty_driver *driver, struct tty_struct *tty)
983{
984 struct vcc_port *port_vcc;
985 struct tty_port *port_tty;
986 int ret;
987
988 if (unlikely(!tty)) {
989 pr_err("VCC: install: Invalid TTY handle\n");
990 return -ENXIO;
991 }
992
993 if (tty->index >= VCC_MAX_PORTS)
994 return -EINVAL;
995
996 ret = tty_standard_install(driver, tty);
997 if (ret)
998 return ret;
999
1000 port_tty = kzalloc(sizeof(struct tty_port), GFP_KERNEL);
1001 if (!port_tty)
1002 return -ENOMEM;
1003
1004 port_vcc = vcc_get(tty->index, true);
1005 if (!port_vcc) {
1006 pr_err("VCC: install: Failed to find VCC port\n");
1007 tty->port = NULL;
1008 kfree(port_tty);
1009 return -ENODEV;
1010 }
1011
1012 tty_port_init(port_tty);
1013 port_tty->ops = &vcc_port_ops;
1014 tty->port = port_tty;
1015
1016 port_vcc->tty = tty;
1017
1018 vcc_put(port_vcc, true);
1019
1020 return 0;
1021}
1022
1023static void vcc_cleanup(struct tty_struct *tty)
1024{
1025 struct vcc_port *port;
1026
1027 if (unlikely(!tty)) {
1028 pr_err("VCC: cleanup: Invalid TTY handle\n");
1029 return;
1030 }
1031
1032 port = vcc_get(tty->index, true);
1033 if (port) {
1034 port->tty = NULL;
1035
1036 if (port->removed) {
1037 vcc_table_remove(tty->index);
1038 kfree(port->vio.name);
1039 kfree(port->domain);
1040 kfree(port);
1041 } else {
1042 vcc_put(port, true);
1043 }
1044 }
1045
1046 tty_port_destroy(tty->port);
1047 kfree(tty->port);
1048 tty->port = NULL;
1049}
1050
1051static const struct tty_operations vcc_ops = {
1052 .open = vcc_open,
1053 .close = vcc_close,
1054 .hangup = vcc_hangup,
1055 .write = vcc_write,
1056 .write_room = vcc_write_room,
1057 .chars_in_buffer = vcc_chars_in_buffer,
1058 .break_ctl = vcc_break_ctl,
1059 .install = vcc_install,
1060 .cleanup = vcc_cleanup,
1061};
1062
1063#define VCC_TTY_FLAGS (TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_REAL_RAW)
1064
1065static int vcc_tty_init(void)
1066{
1067 int rv;
1068
1069 pr_info("VCC: %s\n", version);
1070
1071 vcc_tty_driver = tty_alloc_driver(VCC_MAX_PORTS, VCC_TTY_FLAGS);
1072 if (IS_ERR(vcc_tty_driver)) {
1073 pr_err("VCC: TTY driver alloc failed\n");
1074 return PTR_ERR(vcc_tty_driver);
1075 }
1076
1077 vcc_tty_driver->driver_name = vcc_driver_name;
1078 vcc_tty_driver->name = vcc_device_node;
1079
1080 vcc_tty_driver->minor_start = VCC_MINOR_START;
1081 vcc_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM;
1082 vcc_tty_driver->init_termios = vcc_tty_termios;
1083
1084 tty_set_operations(vcc_tty_driver, &vcc_ops);
1085
1086 rv = tty_register_driver(vcc_tty_driver);
1087 if (rv) {
1088 pr_err("VCC: TTY driver registration failed\n");
1089 put_tty_driver(vcc_tty_driver);
1090 vcc_tty_driver = NULL;
1091 return rv;
1092 }
1093
1094 vccdbg("VCC: TTY driver registered\n");
1095
1096 return 0;
1097}
1098
1099static void vcc_tty_exit(void)
1100{
1101 tty_unregister_driver(vcc_tty_driver);
1102 put_tty_driver(vcc_tty_driver);
1103 vccdbg("VCC: TTY driver unregistered\n");
1104
1105 vcc_tty_driver = NULL;
1106}
1107
1108static int __init vcc_init(void)
1109{
1110 int rv;
1111
1112 rv = vcc_tty_init();
1113 if (rv) {
1114 pr_err("VCC: TTY init failed\n");
1115 return rv;
1116 }
1117
1118 rv = vio_register_driver(&vcc_driver);
1119 if (rv) {
1120 pr_err("VCC: VIO driver registration failed\n");
1121 vcc_tty_exit();
1122 } else {
1123 vccdbg("VCC: VIO driver registered successfully\n");
1124 }
1125
1126 return rv;
1127}
1128
1129static void __exit vcc_exit(void)
1130{
1131 vio_unregister_driver(&vcc_driver);
1132 vccdbg("VCC: VIO driver unregistered\n");
1133 vcc_tty_exit();
1134 vccdbg("VCC: TTY driver unregistered\n");
1135}
1136
1137module_init(vcc_init);
1138module_exit(vcc_exit);
1139