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