1/*
2 * vio driver interface to hvc_console.c
3 *
4 * This code was moved here to allow the remaining code to be reused as a
5 * generic polling mode with semi-reliable transport driver core to the
6 * console and tty subsystems.
7 *
8 *
9 * Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
10 * Copyright (C) 2001 Paul Mackerras <paulus@au.ibm.com>, IBM
11 * Copyright (C) 2004 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
12 * Copyright (C) 2004 IBM Corporation
13 *
14 * Additional Author(s):
15 *  Ryan S. Arnold <rsa@us.ibm.com>
16 *
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
21 *
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25 * GNU General Public License for more details.
26 *
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
30 *
31 * TODO:
32 *
33 *   - handle error in sending hvsi protocol packets
34 *   - retry nego on subsequent sends ?
35 */
36
37#undef DEBUG
38
39#include <linux/types.h>
40#include <linux/init.h>
41#include <linux/delay.h>
42#include <linux/slab.h>
43#include <linux/console.h>
44#include <linux/module.h>
45
46#include <asm/hvconsole.h>
47#include <asm/vio.h>
48#include <asm/prom.h>
49#include <asm/hvsi.h>
50#include <asm/udbg.h>
51#include <asm/machdep.h>
52
53#include "hvc_console.h"
54
55static const char hvc_driver_name[] = "hvc_console";
56
57static struct vio_device_id hvc_driver_table[] = {
58	{"serial", "hvterm1"},
59#ifndef HVC_OLD_HVSI
60	{"serial", "hvterm-protocol"},
61#endif
62	{ "", "" }
63};
64MODULE_DEVICE_TABLE(vio, hvc_driver_table);
65
66typedef enum hv_protocol {
67	HV_PROTOCOL_RAW,
68	HV_PROTOCOL_HVSI
69} hv_protocol_t;
70
71struct hvterm_priv {
72	u32			termno;	/* HV term number */
73	hv_protocol_t		proto;	/* Raw data or HVSI packets */
74	struct hvsi_priv	hvsi;	/* HVSI specific data */
75	spinlock_t		buf_lock;
76	char			buf[SIZE_VIO_GET_CHARS];
77	int			left;
78	int			offset;
79};
80static struct hvterm_priv *hvterm_privs[MAX_NR_HVC_CONSOLES];
81/* For early boot console */
82static struct hvterm_priv hvterm_priv0;
83
84static int hvterm_raw_get_chars(uint32_t vtermno, char *buf, int count)
85{
86	struct hvterm_priv *pv = hvterm_privs[vtermno];
87	unsigned long i;
88	unsigned long flags;
89	int got;
90
91	if (WARN_ON(!pv))
92		return 0;
93
94	spin_lock_irqsave(&pv->buf_lock, flags);
95
96	if (pv->left == 0) {
97		pv->offset = 0;
98		pv->left = hvc_get_chars(pv->termno, pv->buf, count);
99
100		/*
101		 * Work around a HV bug where it gives us a null
102		 * after every \r.  -- paulus
103		 */
104		for (i = 1; i < pv->left; ++i) {
105			if (pv->buf[i] == 0 && pv->buf[i-1] == '\r') {
106				--pv->left;
107				if (i < pv->left) {
108					memmove(&pv->buf[i], &pv->buf[i+1],
109						pv->left - i);
110				}
111			}
112		}
113	}
114
115	got = min(count, pv->left);
116	memcpy(buf, &pv->buf[pv->offset], got);
117	pv->offset += got;
118	pv->left -= got;
119
120	spin_unlock_irqrestore(&pv->buf_lock, flags);
121
122	return got;
123}
124
125static int hvterm_raw_put_chars(uint32_t vtermno, const char *buf, int count)
126{
127	struct hvterm_priv *pv = hvterm_privs[vtermno];
128
129	if (WARN_ON(!pv))
130		return 0;
131
132	return hvc_put_chars(pv->termno, buf, count);
133}
134
135static const struct hv_ops hvterm_raw_ops = {
136	.get_chars = hvterm_raw_get_chars,
137	.put_chars = hvterm_raw_put_chars,
138	.notifier_add = notifier_add_irq,
139	.notifier_del = notifier_del_irq,
140	.notifier_hangup = notifier_hangup_irq,
141};
142
143static int hvterm_hvsi_get_chars(uint32_t vtermno, char *buf, int count)
144{
145	struct hvterm_priv *pv = hvterm_privs[vtermno];
146
147	if (WARN_ON(!pv))
148		return 0;
149
150	return hvsilib_get_chars(&pv->hvsi, buf, count);
151}
152
153static int hvterm_hvsi_put_chars(uint32_t vtermno, const char *buf, int count)
154{
155	struct hvterm_priv *pv = hvterm_privs[vtermno];
156
157	if (WARN_ON(!pv))
158		return 0;
159
160	return hvsilib_put_chars(&pv->hvsi, buf, count);
161}
162
163static int hvterm_hvsi_open(struct hvc_struct *hp, int data)
164{
165	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
166	int rc;
167
168	pr_devel("HVSI@%x: open !\n", pv->termno);
169
170	rc = notifier_add_irq(hp, data);
171	if (rc)
172		return rc;
173
174	return hvsilib_open(&pv->hvsi, hp);
175}
176
177static void hvterm_hvsi_close(struct hvc_struct *hp, int data)
178{
179	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
180
181	pr_devel("HVSI@%x: do close !\n", pv->termno);
182
183	hvsilib_close(&pv->hvsi, hp);
184
185	notifier_del_irq(hp, data);
186}
187
188void hvterm_hvsi_hangup(struct hvc_struct *hp, int data)
189{
190	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
191
192	pr_devel("HVSI@%x: do hangup !\n", pv->termno);
193
194	hvsilib_close(&pv->hvsi, hp);
195
196	notifier_hangup_irq(hp, data);
197}
198
199static int hvterm_hvsi_tiocmget(struct hvc_struct *hp)
200{
201	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
202
203	if (!pv)
204		return -EINVAL;
205	return pv->hvsi.mctrl;
206}
207
208static int hvterm_hvsi_tiocmset(struct hvc_struct *hp, unsigned int set,
209				unsigned int clear)
210{
211	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
212
213	pr_devel("HVSI@%x: Set modem control, set=%x,clr=%x\n",
214		 pv->termno, set, clear);
215
216	if (set & TIOCM_DTR)
217		hvsilib_write_mctrl(&pv->hvsi, 1);
218	else if (clear & TIOCM_DTR)
219		hvsilib_write_mctrl(&pv->hvsi, 0);
220
221	return 0;
222}
223
224static const struct hv_ops hvterm_hvsi_ops = {
225	.get_chars = hvterm_hvsi_get_chars,
226	.put_chars = hvterm_hvsi_put_chars,
227	.notifier_add = hvterm_hvsi_open,
228	.notifier_del = hvterm_hvsi_close,
229	.notifier_hangup = hvterm_hvsi_hangup,
230	.tiocmget = hvterm_hvsi_tiocmget,
231	.tiocmset = hvterm_hvsi_tiocmset,
232};
233
234static void udbg_hvc_putc(char c)
235{
236	int count = -1;
237
238	if (!hvterm_privs[0])
239		return;
240
241	if (c == '\n')
242		udbg_hvc_putc('\r');
243
244	do {
245		switch(hvterm_privs[0]->proto) {
246		case HV_PROTOCOL_RAW:
247			count = hvterm_raw_put_chars(0, &c, 1);
248			break;
249		case HV_PROTOCOL_HVSI:
250			count = hvterm_hvsi_put_chars(0, &c, 1);
251			break;
252		}
253	} while(count == 0);
254}
255
256static int udbg_hvc_getc_poll(void)
257{
258	int rc = 0;
259	char c;
260
261	if (!hvterm_privs[0])
262		return -1;
263
264	switch(hvterm_privs[0]->proto) {
265	case HV_PROTOCOL_RAW:
266		rc = hvterm_raw_get_chars(0, &c, 1);
267		break;
268	case HV_PROTOCOL_HVSI:
269		rc = hvterm_hvsi_get_chars(0, &c, 1);
270		break;
271	}
272	if (!rc)
273		return -1;
274	return c;
275}
276
277static int udbg_hvc_getc(void)
278{
279	int ch;
280
281	if (!hvterm_privs[0])
282		return -1;
283
284	for (;;) {
285		ch = udbg_hvc_getc_poll();
286		if (ch == -1) {
287			/* This shouldn't be needed...but... */
288			volatile unsigned long delay;
289			for (delay=0; delay < 2000000; delay++)
290				;
291		} else {
292			return ch;
293		}
294	}
295}
296
297static int hvc_vio_probe(struct vio_dev *vdev,
298				   const struct vio_device_id *id)
299{
300	const struct hv_ops *ops;
301	struct hvc_struct *hp;
302	struct hvterm_priv *pv;
303	hv_protocol_t proto;
304	int i, termno = -1;
305
306	/* probed with invalid parameters. */
307	if (!vdev || !id)
308		return -EPERM;
309
310	if (of_device_is_compatible(vdev->dev.of_node, "hvterm1")) {
311		proto = HV_PROTOCOL_RAW;
312		ops = &hvterm_raw_ops;
313	} else if (of_device_is_compatible(vdev->dev.of_node, "hvterm-protocol")) {
314		proto = HV_PROTOCOL_HVSI;
315		ops = &hvterm_hvsi_ops;
316	} else {
317		pr_err("hvc_vio: Unknown protocol for %s\n", vdev->dev.of_node->full_name);
318		return -ENXIO;
319	}
320
321	pr_devel("hvc_vio_probe() device %s, using %s protocol\n",
322		 vdev->dev.of_node->full_name,
323		 proto == HV_PROTOCOL_RAW ? "raw" : "hvsi");
324
325	/* Is it our boot one ? */
326	if (hvterm_privs[0] == &hvterm_priv0 &&
327	    vdev->unit_address == hvterm_priv0.termno) {
328		pv = hvterm_privs[0];
329		termno = 0;
330		pr_devel("->boot console, using termno 0\n");
331	}
332	/* nope, allocate a new one */
333	else {
334		for (i = 0; i < MAX_NR_HVC_CONSOLES && termno < 0; i++)
335			if (!hvterm_privs[i])
336				termno = i;
337		pr_devel("->non-boot console, using termno %d\n", termno);
338		if (termno < 0)
339			return -ENODEV;
340		pv = kzalloc(sizeof(struct hvterm_priv), GFP_KERNEL);
341		if (!pv)
342			return -ENOMEM;
343		pv->termno = vdev->unit_address;
344		pv->proto = proto;
345		spin_lock_init(&pv->buf_lock);
346		hvterm_privs[termno] = pv;
347		hvsilib_init(&pv->hvsi, hvc_get_chars, hvc_put_chars,
348			     pv->termno, 0);
349	}
350
351	hp = hvc_alloc(termno, vdev->irq, ops, MAX_VIO_PUT_CHARS);
352	if (IS_ERR(hp))
353		return PTR_ERR(hp);
354	dev_set_drvdata(&vdev->dev, hp);
355
356	/* register udbg if it's not there already for console 0 */
357	if (hp->index == 0 && !udbg_putc) {
358		udbg_putc = udbg_hvc_putc;
359		udbg_getc = udbg_hvc_getc;
360		udbg_getc_poll = udbg_hvc_getc_poll;
361	}
362
363	return 0;
364}
365
366static int hvc_vio_remove(struct vio_dev *vdev)
367{
368	struct hvc_struct *hp = dev_get_drvdata(&vdev->dev);
369	int rc, termno;
370
371	termno = hp->vtermno;
372	rc = hvc_remove(hp);
373	if (rc == 0) {
374		if (hvterm_privs[termno] != &hvterm_priv0)
375			kfree(hvterm_privs[termno]);
376		hvterm_privs[termno] = NULL;
377	}
378	return rc;
379}
380
381static struct vio_driver hvc_vio_driver = {
382	.id_table	= hvc_driver_table,
383	.probe		= hvc_vio_probe,
384	.remove		= hvc_vio_remove,
385	.name		= hvc_driver_name,
386};
387
388static int __init hvc_vio_init(void)
389{
390	int rc;
391
392	/* Register as a vio device to receive callbacks */
393	rc = vio_register_driver(&hvc_vio_driver);
394
395	return rc;
396}
397module_init(hvc_vio_init); /* after drivers/char/hvc_console.c */
398
399static void __exit hvc_vio_exit(void)
400{
401	vio_unregister_driver(&hvc_vio_driver);
402}
403module_exit(hvc_vio_exit);
404
405void __init hvc_vio_init_early(void)
406{
407	const __be32 *termno;
408	const char *name;
409	const struct hv_ops *ops;
410
411	/* find the boot console from /chosen/stdout */
412	if (!of_stdout)
413		return;
414	name = of_get_property(of_stdout, "name", NULL);
415	if (!name) {
416		printk(KERN_WARNING "stdout node missing 'name' property!\n");
417		return;
418	}
419
420	/* Check if it's a virtual terminal */
421	if (strncmp(name, "vty", 3) != 0)
422		return;
423	termno = of_get_property(of_stdout, "reg", NULL);
424	if (termno == NULL)
425		return;
426	hvterm_priv0.termno = of_read_number(termno, 1);
427	spin_lock_init(&hvterm_priv0.buf_lock);
428	hvterm_privs[0] = &hvterm_priv0;
429
430	/* Check the protocol */
431	if (of_device_is_compatible(of_stdout, "hvterm1")) {
432		hvterm_priv0.proto = HV_PROTOCOL_RAW;
433		ops = &hvterm_raw_ops;
434	}
435	else if (of_device_is_compatible(of_stdout, "hvterm-protocol")) {
436		hvterm_priv0.proto = HV_PROTOCOL_HVSI;
437		ops = &hvterm_hvsi_ops;
438		hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
439			     hvterm_priv0.termno, 1);
440		/* HVSI, perform the handshake now */
441		hvsilib_establish(&hvterm_priv0.hvsi);
442	} else
443		return;
444	udbg_putc = udbg_hvc_putc;
445	udbg_getc = udbg_hvc_getc;
446	udbg_getc_poll = udbg_hvc_getc_poll;
447#ifdef HVC_OLD_HVSI
448	/* When using the old HVSI driver don't register the HVC
449	 * backend for HVSI, only do udbg
450	 */
451	if (hvterm_priv0.proto == HV_PROTOCOL_HVSI)
452		return;
453#endif
454	/* Check whether the user has requested a different console. */
455	if (!strstr(boot_command_line, "console="))
456		add_preferred_console("hvc", 0, NULL);
457	hvc_instantiate(0, 0, ops);
458}
459
460/* call this from early_init() for a working debug console on
461 * vterm capable LPAR machines
462 */
463#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR
464void __init udbg_init_debug_lpar(void)
465{
466	hvterm_privs[0] = &hvterm_priv0;
467	hvterm_priv0.termno = 0;
468	hvterm_priv0.proto = HV_PROTOCOL_RAW;
469	spin_lock_init(&hvterm_priv0.buf_lock);
470	udbg_putc = udbg_hvc_putc;
471	udbg_getc = udbg_hvc_getc;
472	udbg_getc_poll = udbg_hvc_getc_poll;
473}
474#endif /* CONFIG_PPC_EARLY_DEBUG_LPAR */
475
476#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI
477void __init udbg_init_debug_lpar_hvsi(void)
478{
479	hvterm_privs[0] = &hvterm_priv0;
480	hvterm_priv0.termno = CONFIG_PPC_EARLY_DEBUG_HVSI_VTERMNO;
481	hvterm_priv0.proto = HV_PROTOCOL_HVSI;
482	spin_lock_init(&hvterm_priv0.buf_lock);
483	udbg_putc = udbg_hvc_putc;
484	udbg_getc = udbg_hvc_getc;
485	udbg_getc_poll = udbg_hvc_getc_poll;
486	hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
487		     hvterm_priv0.termno, 1);
488	hvsilib_establish(&hvterm_priv0.hvsi);
489}
490#endif /* CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI */
491