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 	int 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 	int 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 unsigned char * buf,int count)807 static int vcc_write(struct tty_struct *tty, const unsigned char *buf,
808 		     int count)
809 {
810 	struct vcc_port *port;
811 	struct vio_vcc *pkt;
812 	unsigned long flags;
813 	int total_sent = 0;
814 	int tosend = 0;
815 	int rv = -EINVAL;
816 
817 	port = vcc_get_ne(tty->index);
818 	if (unlikely(!port)) {
819 		pr_err("VCC: write: Failed to find VCC port");
820 		return -ENODEV;
821 	}
822 
823 	spin_lock_irqsave(&port->lock, flags);
824 
825 	pkt = &port->buffer;
826 	pkt->tag.type = VIO_TYPE_DATA;
827 
828 	while (count > 0) {
829 		/* Minimum of data to write and space available */
830 		tosend = min(count, (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(%d)=%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=%d 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