2 * vio driver interface to hvc_console.c
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.
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
14 * Additional Author(s):
15 * Ryan S. Arnold <rsa@us.ibm.com>
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.
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.
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
33 * - handle error in sending hvsi protocol packets
34 * - retry nego on subsequent sends ?
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>
46 #include <asm/hvconsole.h>
49 #include <asm/firmware.h>
53 #include "hvc_console.h"
55 static const char hvc_driver_name[] = "hvc_console";
57 static struct vio_device_id hvc_driver_table[] __devinitdata = {
58 {"serial", "hvterm1"},
60 {"serial", "hvterm-protocol"},
64 MODULE_DEVICE_TABLE(vio, hvc_driver_table);
66 typedef enum hv_protocol {
72 u32 termno; /* HV term number */
73 hv_protocol_t proto; /* Raw data or HVSI packets */
74 struct hvsi_priv hvsi; /* HVSI specific data */
76 char buf[SIZE_VIO_GET_CHARS];
80 static struct hvterm_priv *hvterm_privs[MAX_NR_HVC_CONSOLES];
81 /* For early boot console */
82 static struct hvterm_priv hvterm_priv0;
84 static int hvterm_raw_get_chars(uint32_t vtermno, char *buf, int count)
86 struct hvterm_priv *pv = hvterm_privs[vtermno];
94 spin_lock_irqsave(&pv->buf_lock, flags);
98 pv->left = hvc_get_chars(pv->termno, pv->buf, count);
101 * Work around a HV bug where it gives us a null
102 * after every \r. -- paulus
104 for (i = 1; i < pv->left; ++i) {
105 if (pv->buf[i] == 0 && pv->buf[i-1] == '\r') {
108 memmove(&pv->buf[i], &pv->buf[i+1],
115 got = min(count, pv->left);
116 memcpy(buf, &pv->buf[pv->offset], got);
120 spin_unlock_irqrestore(&pv->buf_lock, flags);
125 static int hvterm_raw_put_chars(uint32_t vtermno, const char *buf, int count)
127 struct hvterm_priv *pv = hvterm_privs[vtermno];
132 return hvc_put_chars(pv->termno, buf, count);
135 static 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,
143 static int hvterm_hvsi_get_chars(uint32_t vtermno, char *buf, int count)
145 struct hvterm_priv *pv = hvterm_privs[vtermno];
150 return hvsilib_get_chars(&pv->hvsi, buf, count);
153 static int hvterm_hvsi_put_chars(uint32_t vtermno, const char *buf, int count)
155 struct hvterm_priv *pv = hvterm_privs[vtermno];
160 return hvsilib_put_chars(&pv->hvsi, buf, count);
163 static int hvterm_hvsi_open(struct hvc_struct *hp, int data)
165 struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
168 pr_devel("HVSI@%x: open !\n", pv->termno);
170 rc = notifier_add_irq(hp, data);
174 return hvsilib_open(&pv->hvsi, hp);
177 static void hvterm_hvsi_close(struct hvc_struct *hp, int data)
179 struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
181 pr_devel("HVSI@%x: do close !\n", pv->termno);
183 hvsilib_close(&pv->hvsi, hp);
185 notifier_del_irq(hp, data);
188 void hvterm_hvsi_hangup(struct hvc_struct *hp, int data)
190 struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
192 pr_devel("HVSI@%x: do hangup !\n", pv->termno);
194 hvsilib_close(&pv->hvsi, hp);
196 notifier_hangup_irq(hp, data);
199 static int hvterm_hvsi_tiocmget(struct hvc_struct *hp)
201 struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
205 return pv->hvsi.mctrl;
208 static int hvterm_hvsi_tiocmset(struct hvc_struct *hp, unsigned int set,
211 struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
213 pr_devel("HVSI@%x: Set modem control, set=%x,clr=%x\n",
214 pv->termno, set, clear);
217 hvsilib_write_mctrl(&pv->hvsi, 1);
218 else if (clear & TIOCM_DTR)
219 hvsilib_write_mctrl(&pv->hvsi, 0);
224 static 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,
234 static int __devinit hvc_vio_probe(struct vio_dev *vdev,
235 const struct vio_device_id *id)
237 const struct hv_ops *ops;
238 struct hvc_struct *hp;
239 struct hvterm_priv *pv;
243 /* probed with invalid parameters. */
247 if (of_device_is_compatible(vdev->dev.of_node, "hvterm1")) {
248 proto = HV_PROTOCOL_RAW;
249 ops = &hvterm_raw_ops;
250 } else if (of_device_is_compatible(vdev->dev.of_node, "hvterm-protocol")) {
251 proto = HV_PROTOCOL_HVSI;
252 ops = &hvterm_hvsi_ops;
254 pr_err("hvc_vio: Unkown protocol for %s\n", vdev->dev.of_node->full_name);
258 pr_devel("hvc_vio_probe() device %s, using %s protocol\n",
259 vdev->dev.of_node->full_name,
260 proto == HV_PROTOCOL_RAW ? "raw" : "hvsi");
262 /* Is it our boot one ? */
263 if (hvterm_privs[0] == &hvterm_priv0 &&
264 vdev->unit_address == hvterm_priv0.termno) {
265 pv = hvterm_privs[0];
267 pr_devel("->boot console, using termno 0\n");
269 /* nope, allocate a new one */
271 for (i = 0; i < MAX_NR_HVC_CONSOLES && termno < 0; i++)
272 if (!hvterm_privs[i])
274 pr_devel("->non-boot console, using termno %d\n", termno);
277 pv = kzalloc(sizeof(struct hvterm_priv), GFP_KERNEL);
280 pv->termno = vdev->unit_address;
282 spin_lock_init(&pv->buf_lock);
283 hvterm_privs[termno] = pv;
284 hvsilib_init(&pv->hvsi, hvc_get_chars, hvc_put_chars,
288 hp = hvc_alloc(termno, vdev->irq, ops, MAX_VIO_PUT_CHARS);
291 dev_set_drvdata(&vdev->dev, hp);
296 static int __devexit hvc_vio_remove(struct vio_dev *vdev)
298 struct hvc_struct *hp = dev_get_drvdata(&vdev->dev);
301 termno = hp->vtermno;
304 if (hvterm_privs[termno] != &hvterm_priv0)
305 kfree(hvterm_privs[termno]);
306 hvterm_privs[termno] = NULL;
311 static struct vio_driver hvc_vio_driver = {
312 .id_table = hvc_driver_table,
313 .probe = hvc_vio_probe,
314 .remove = __devexit_p(hvc_vio_remove),
316 .name = hvc_driver_name,
317 .owner = THIS_MODULE,
321 static int __init hvc_vio_init(void)
325 if (firmware_has_feature(FW_FEATURE_ISERIES))
328 /* Register as a vio device to receive callbacks */
329 rc = vio_register_driver(&hvc_vio_driver);
333 module_init(hvc_vio_init); /* after drivers/char/hvc_console.c */
335 static void __exit hvc_vio_exit(void)
337 vio_unregister_driver(&hvc_vio_driver);
339 module_exit(hvc_vio_exit);
341 static void udbg_hvc_putc(char c)
349 switch(hvterm_priv0.proto) {
350 case HV_PROTOCOL_RAW:
351 count = hvterm_raw_put_chars(0, &c, 1);
353 case HV_PROTOCOL_HVSI:
354 count = hvterm_hvsi_put_chars(0, &c, 1);
360 static int udbg_hvc_getc_poll(void)
365 switch(hvterm_priv0.proto) {
366 case HV_PROTOCOL_RAW:
367 rc = hvterm_raw_get_chars(0, &c, 1);
369 case HV_PROTOCOL_HVSI:
370 rc = hvterm_hvsi_get_chars(0, &c, 1);
378 static int udbg_hvc_getc(void)
382 ch = udbg_hvc_getc_poll();
384 /* This shouldn't be needed...but... */
385 volatile unsigned long delay;
386 for (delay=0; delay < 2000000; delay++)
394 void __init hvc_vio_init_early(void)
396 struct device_node *stdout_node;
399 const struct hv_ops *ops;
401 /* find the boot console from /chosen/stdout */
404 name = of_get_property(of_chosen, "linux,stdout-path", NULL);
407 stdout_node = of_find_node_by_path(name);
410 name = of_get_property(stdout_node, "name", NULL);
412 printk(KERN_WARNING "stdout node missing 'name' property!\n");
416 /* Check if it's a virtual terminal */
417 if (strncmp(name, "vty", 3) != 0)
419 termno = of_get_property(stdout_node, "reg", NULL);
422 hvterm_priv0.termno = *termno;
423 spin_lock_init(&hvterm_priv0.buf_lock);
424 hvterm_privs[0] = &hvterm_priv0;
426 /* Check the protocol */
427 if (of_device_is_compatible(stdout_node, "hvterm1")) {
428 hvterm_priv0.proto = HV_PROTOCOL_RAW;
429 ops = &hvterm_raw_ops;
431 else if (of_device_is_compatible(stdout_node, "hvterm-protocol")) {
432 hvterm_priv0.proto = HV_PROTOCOL_HVSI;
433 ops = &hvterm_hvsi_ops;
434 hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
435 hvterm_priv0.termno, 1);
436 /* HVSI, perform the handshake now */
437 hvsilib_establish(&hvterm_priv0.hvsi);
440 udbg_putc = udbg_hvc_putc;
441 udbg_getc = udbg_hvc_getc;
442 udbg_getc_poll = udbg_hvc_getc_poll;
444 /* When using the old HVSI driver don't register the HVC
445 * backend for HVSI, only do udbg
447 if (hvterm_priv0.proto == HV_PROTOCOL_HVSI)
450 add_preferred_console("hvc", 0, NULL);
451 hvc_instantiate(0, 0, ops);
453 of_node_put(stdout_node);
456 /* call this from early_init() for a working debug console on
457 * vterm capable LPAR machines
459 #ifdef CONFIG_PPC_EARLY_DEBUG_LPAR
460 void __init udbg_init_debug_lpar(void)
462 hvterm_privs[0] = &hvterm_priv0;
463 hvterm_priv0.termno = 0;
464 hvterm_priv0.proto = HV_PROTOCOL_RAW;
465 spin_lock_init(&hvterm_priv0.buf_lock);
466 udbg_putc = udbg_hvc_putc;
467 udbg_getc = udbg_hvc_getc;
468 udbg_getc_poll = udbg_hvc_getc_poll;
470 #endif /* CONFIG_PPC_EARLY_DEBUG_LPAR */
472 #ifdef CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI
473 void __init udbg_init_debug_lpar_hvsi(void)
475 hvterm_privs[0] = &hvterm_priv0;
476 hvterm_priv0.termno = CONFIG_PPC_EARLY_DEBUG_HVSI_VTERMNO;
477 hvterm_priv0.proto = HV_PROTOCOL_HVSI;
478 spin_lock_init(&hvterm_priv0.buf_lock);
479 udbg_putc = udbg_hvc_putc;
480 udbg_getc = udbg_hvc_getc;
481 udbg_getc_poll = udbg_hvc_getc_poll;
482 hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
483 hvterm_priv0.termno, 1);
484 hvsilib_establish(&hvterm_priv0.hvsi);
486 #endif /* CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI */