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