1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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
52#include "hvc_console.h"
53
54static const char hvc_driver_name[] = "hvc_console";
55
56static struct vio_device_id hvc_driver_table[] = {
57 {"serial", "hvterm1"},
58#ifndef HVC_OLD_HVSI
59 {"serial", "hvterm-protocol"},
60#endif
61 { "", "" }
62};
63MODULE_DEVICE_TABLE(vio, hvc_driver_table);
64
65typedef enum hv_protocol {
66 HV_PROTOCOL_RAW,
67 HV_PROTOCOL_HVSI
68} hv_protocol_t;
69
70struct hvterm_priv {
71 u32 termno;
72 hv_protocol_t proto;
73 struct hvsi_priv hvsi;
74 spinlock_t buf_lock;
75 char buf[SIZE_VIO_GET_CHARS];
76 int left;
77 int offset;
78};
79static struct hvterm_priv *hvterm_privs[MAX_NR_HVC_CONSOLES];
80
81static struct hvterm_priv hvterm_priv0;
82
83static int hvterm_raw_get_chars(uint32_t vtermno, char *buf, int count)
84{
85 struct hvterm_priv *pv = hvterm_privs[vtermno];
86 unsigned long i;
87 unsigned long flags;
88 int got;
89
90 if (WARN_ON(!pv))
91 return 0;
92
93 spin_lock_irqsave(&pv->buf_lock, flags);
94
95 if (pv->left == 0) {
96 pv->offset = 0;
97 pv->left = hvc_get_chars(pv->termno, pv->buf, count);
98
99
100
101
102
103 for (i = 1; i < pv->left; ++i) {
104 if (pv->buf[i] == 0 && pv->buf[i-1] == '\r') {
105 --pv->left;
106 if (i < pv->left) {
107 memmove(&pv->buf[i], &pv->buf[i+1],
108 pv->left - i);
109 }
110 }
111 }
112 }
113
114 got = min(count, pv->left);
115 memcpy(buf, &pv->buf[pv->offset], got);
116 pv->offset += got;
117 pv->left -= got;
118
119 spin_unlock_irqrestore(&pv->buf_lock, flags);
120
121 return got;
122}
123
124static int hvterm_raw_put_chars(uint32_t vtermno, const char *buf, int count)
125{
126 struct hvterm_priv *pv = hvterm_privs[vtermno];
127
128 if (WARN_ON(!pv))
129 return 0;
130
131 return hvc_put_chars(pv->termno, buf, count);
132}
133
134static const struct hv_ops hvterm_raw_ops = {
135 .get_chars = hvterm_raw_get_chars,
136 .put_chars = hvterm_raw_put_chars,
137 .notifier_add = notifier_add_irq,
138 .notifier_del = notifier_del_irq,
139 .notifier_hangup = notifier_hangup_irq,
140};
141
142static int hvterm_hvsi_get_chars(uint32_t vtermno, char *buf, int count)
143{
144 struct hvterm_priv *pv = hvterm_privs[vtermno];
145
146 if (WARN_ON(!pv))
147 return 0;
148
149 return hvsilib_get_chars(&pv->hvsi, buf, count);
150}
151
152static int hvterm_hvsi_put_chars(uint32_t vtermno, const char *buf, int count)
153{
154 struct hvterm_priv *pv = hvterm_privs[vtermno];
155
156 if (WARN_ON(!pv))
157 return 0;
158
159 return hvsilib_put_chars(&pv->hvsi, buf, count);
160}
161
162static int hvterm_hvsi_open(struct hvc_struct *hp, int data)
163{
164 struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
165 int rc;
166
167 pr_devel("HVSI@%x: open !\n", pv->termno);
168
169 rc = notifier_add_irq(hp, data);
170 if (rc)
171 return rc;
172
173 return hvsilib_open(&pv->hvsi, hp);
174}
175
176static void hvterm_hvsi_close(struct hvc_struct *hp, int data)
177{
178 struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
179
180 pr_devel("HVSI@%x: do close !\n", pv->termno);
181
182 hvsilib_close(&pv->hvsi, hp);
183
184 notifier_del_irq(hp, data);
185}
186
187void hvterm_hvsi_hangup(struct hvc_struct *hp, int data)
188{
189 struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
190
191 pr_devel("HVSI@%x: do hangup !\n", pv->termno);
192
193 hvsilib_close(&pv->hvsi, hp);
194
195 notifier_hangup_irq(hp, data);
196}
197
198static int hvterm_hvsi_tiocmget(struct hvc_struct *hp)
199{
200 struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
201
202 if (!pv)
203 return -EINVAL;
204 return pv->hvsi.mctrl;
205}
206
207static int hvterm_hvsi_tiocmset(struct hvc_struct *hp, unsigned int set,
208 unsigned int clear)
209{
210 struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
211
212 pr_devel("HVSI@%x: Set modem control, set=%x,clr=%x\n",
213 pv->termno, set, clear);
214
215 if (set & TIOCM_DTR)
216 hvsilib_write_mctrl(&pv->hvsi, 1);
217 else if (clear & TIOCM_DTR)
218 hvsilib_write_mctrl(&pv->hvsi, 0);
219
220 return 0;
221}
222
223static const struct hv_ops hvterm_hvsi_ops = {
224 .get_chars = hvterm_hvsi_get_chars,
225 .put_chars = hvterm_hvsi_put_chars,
226 .notifier_add = hvterm_hvsi_open,
227 .notifier_del = hvterm_hvsi_close,
228 .notifier_hangup = hvterm_hvsi_hangup,
229 .tiocmget = hvterm_hvsi_tiocmget,
230 .tiocmset = hvterm_hvsi_tiocmset,
231};
232
233static void udbg_hvc_putc(char c)
234{
235 int count = -1;
236
237 if (!hvterm_privs[0])
238 return;
239
240 if (c == '\n')
241 udbg_hvc_putc('\r');
242
243 do {
244 switch(hvterm_privs[0]->proto) {
245 case HV_PROTOCOL_RAW:
246 count = hvterm_raw_put_chars(0, &c, 1);
247 break;
248 case HV_PROTOCOL_HVSI:
249 count = hvterm_hvsi_put_chars(0, &c, 1);
250 break;
251 }
252 } while(count == 0);
253}
254
255static int udbg_hvc_getc_poll(void)
256{
257 int rc = 0;
258 char c;
259
260 if (!hvterm_privs[0])
261 return -1;
262
263 switch(hvterm_privs[0]->proto) {
264 case HV_PROTOCOL_RAW:
265 rc = hvterm_raw_get_chars(0, &c, 1);
266 break;
267 case HV_PROTOCOL_HVSI:
268 rc = hvterm_hvsi_get_chars(0, &c, 1);
269 break;
270 }
271 if (!rc)
272 return -1;
273 return c;
274}
275
276static int udbg_hvc_getc(void)
277{
278 int ch;
279
280 if (!hvterm_privs[0])
281 return -1;
282
283 for (;;) {
284 ch = udbg_hvc_getc_poll();
285 if (ch == -1) {
286
287 volatile unsigned long delay;
288 for (delay=0; delay < 2000000; delay++)
289 ;
290 } else {
291 return ch;
292 }
293 }
294}
295
296static int hvc_vio_probe(struct vio_dev *vdev,
297 const struct vio_device_id *id)
298{
299 const struct hv_ops *ops;
300 struct hvc_struct *hp;
301 struct hvterm_priv *pv;
302 hv_protocol_t proto;
303 int i, termno = -1;
304
305
306 if (!vdev || !id)
307 return -EPERM;
308
309 if (of_device_is_compatible(vdev->dev.of_node, "hvterm1")) {
310 proto = HV_PROTOCOL_RAW;
311 ops = &hvterm_raw_ops;
312 } else if (of_device_is_compatible(vdev->dev.of_node, "hvterm-protocol")) {
313 proto = HV_PROTOCOL_HVSI;
314 ops = &hvterm_hvsi_ops;
315 } else {
316 pr_err("hvc_vio: Unknown protocol for %s\n", vdev->dev.of_node->full_name);
317 return -ENXIO;
318 }
319
320 pr_devel("hvc_vio_probe() device %s, using %s protocol\n",
321 vdev->dev.of_node->full_name,
322 proto == HV_PROTOCOL_RAW ? "raw" : "hvsi");
323
324
325 if (hvterm_privs[0] == &hvterm_priv0 &&
326 vdev->unit_address == hvterm_priv0.termno) {
327 pv = hvterm_privs[0];
328 termno = 0;
329 pr_devel("->boot console, using termno 0\n");
330 }
331
332 else {
333 for (i = 0; i < MAX_NR_HVC_CONSOLES && termno < 0; i++)
334 if (!hvterm_privs[i])
335 termno = i;
336 pr_devel("->non-boot console, using termno %d\n", termno);
337 if (termno < 0)
338 return -ENODEV;
339 pv = kzalloc(sizeof(struct hvterm_priv), GFP_KERNEL);
340 if (!pv)
341 return -ENOMEM;
342 pv->termno = vdev->unit_address;
343 pv->proto = proto;
344 spin_lock_init(&pv->buf_lock);
345 hvterm_privs[termno] = pv;
346 hvsilib_init(&pv->hvsi, hvc_get_chars, hvc_put_chars,
347 pv->termno, 0);
348 }
349
350 hp = hvc_alloc(termno, vdev->irq, ops, MAX_VIO_PUT_CHARS);
351 if (IS_ERR(hp))
352 return PTR_ERR(hp);
353 dev_set_drvdata(&vdev->dev, hp);
354
355
356 if (hp->index == 0 && !udbg_putc) {
357 udbg_putc = udbg_hvc_putc;
358 udbg_getc = udbg_hvc_getc;
359 udbg_getc_poll = udbg_hvc_getc_poll;
360 }
361
362 return 0;
363}
364
365static int hvc_vio_remove(struct vio_dev *vdev)
366{
367 struct hvc_struct *hp = dev_get_drvdata(&vdev->dev);
368 int rc, termno;
369
370 termno = hp->vtermno;
371 rc = hvc_remove(hp);
372 if (rc == 0) {
373 if (hvterm_privs[termno] != &hvterm_priv0)
374 kfree(hvterm_privs[termno]);
375 hvterm_privs[termno] = NULL;
376 }
377 return rc;
378}
379
380static struct vio_driver hvc_vio_driver = {
381 .id_table = hvc_driver_table,
382 .probe = hvc_vio_probe,
383 .remove = hvc_vio_remove,
384 .name = hvc_driver_name,
385};
386
387static int __init hvc_vio_init(void)
388{
389 int rc;
390
391
392 rc = vio_register_driver(&hvc_vio_driver);
393
394 return rc;
395}
396module_init(hvc_vio_init);
397
398static void __exit hvc_vio_exit(void)
399{
400 vio_unregister_driver(&hvc_vio_driver);
401}
402module_exit(hvc_vio_exit);
403
404void __init hvc_vio_init_early(void)
405{
406 struct device_node *stdout_node;
407 const u32 *termno;
408 const char *name;
409 const struct hv_ops *ops;
410
411
412 if (!of_chosen)
413 return;
414 name = of_get_property(of_chosen, "linux,stdout-path", NULL);
415 if (name == NULL)
416 return;
417 stdout_node = of_find_node_by_path(name);
418 if (!stdout_node)
419 return;
420 name = of_get_property(stdout_node, "name", NULL);
421 if (!name) {
422 printk(KERN_WARNING "stdout node missing 'name' property!\n");
423 goto out;
424 }
425
426
427 if (strncmp(name, "vty", 3) != 0)
428 goto out;
429 termno = of_get_property(stdout_node, "reg", NULL);
430 if (termno == NULL)
431 goto out;
432 hvterm_priv0.termno = *termno;
433 spin_lock_init(&hvterm_priv0.buf_lock);
434 hvterm_privs[0] = &hvterm_priv0;
435
436
437 if (of_device_is_compatible(stdout_node, "hvterm1")) {
438 hvterm_priv0.proto = HV_PROTOCOL_RAW;
439 ops = &hvterm_raw_ops;
440 }
441 else if (of_device_is_compatible(stdout_node, "hvterm-protocol")) {
442 hvterm_priv0.proto = HV_PROTOCOL_HVSI;
443 ops = &hvterm_hvsi_ops;
444 hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
445 hvterm_priv0.termno, 1);
446
447 hvsilib_establish(&hvterm_priv0.hvsi);
448 } else
449 goto out;
450 udbg_putc = udbg_hvc_putc;
451 udbg_getc = udbg_hvc_getc;
452 udbg_getc_poll = udbg_hvc_getc_poll;
453#ifdef HVC_OLD_HVSI
454
455
456
457 if (hvterm_priv0.proto == HV_PROTOCOL_HVSI)
458 goto out;
459#endif
460 add_preferred_console("hvc", 0, NULL);
461 hvc_instantiate(0, 0, ops);
462out:
463 of_node_put(stdout_node);
464}
465
466
467
468
469#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR
470void __init udbg_init_debug_lpar(void)
471{
472 hvterm_privs[0] = &hvterm_priv0;
473 hvterm_priv0.termno = 0;
474 hvterm_priv0.proto = HV_PROTOCOL_RAW;
475 spin_lock_init(&hvterm_priv0.buf_lock);
476 udbg_putc = udbg_hvc_putc;
477 udbg_getc = udbg_hvc_getc;
478 udbg_getc_poll = udbg_hvc_getc_poll;
479}
480#endif
481
482#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI
483void __init udbg_init_debug_lpar_hvsi(void)
484{
485 hvterm_privs[0] = &hvterm_priv0;
486 hvterm_priv0.termno = CONFIG_PPC_EARLY_DEBUG_HVSI_VTERMNO;
487 hvterm_priv0.proto = HV_PROTOCOL_HVSI;
488 spin_lock_init(&hvterm_priv0.buf_lock);
489 udbg_putc = udbg_hvc_putc;
490 udbg_getc = udbg_hvc_getc;
491 udbg_getc_poll = udbg_hvc_getc_poll;
492 hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
493 hvterm_priv0.termno, 1);
494 hvsilib_establish(&hvterm_priv0.hvsi);
495}
496#endif
497