blob: 4e5360388748e7facd991ceefe64a06439f3b35c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* -*- linux-c -*-
2 *
3 * drivers/char/viocons.c
4 *
5 * iSeries Virtual Terminal
6 *
7 * Authors: Dave Boutcher <boutcher@us.ibm.com>
8 * Ryan Arnold <ryanarn@us.ibm.com>
9 * Colin Devilbiss <devilbis@us.ibm.com>
10 * Stephen Rothwell <sfr@au1.ibm.com>
11 *
12 * (C) Copyright 2000, 2001, 2002, 2003, 2004 IBM Corporation
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License as
16 * published by the Free Software Foundation; either version 2 of the
17 * License, or (at your option) anyu later version.
18 *
19 * This program is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software Foundation,
26 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 */
28#include <linux/config.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/kernel.h>
30#include <linux/proc_fs.h>
31#include <linux/errno.h>
32#include <linux/vmalloc.h>
33#include <linux/mm.h>
34#include <linux/console.h>
35#include <linux/module.h>
36#include <asm/uaccess.h>
37#include <linux/init.h>
38#include <linux/wait.h>
39#include <linux/spinlock.h>
40#include <asm/ioctls.h>
41#include <linux/kd.h>
42#include <linux/tty.h>
43#include <linux/tty_flip.h>
44#include <linux/sysrq.h>
45
Kelly Dalyb4206772005-11-02 15:13:57 +110046#include <asm/iseries/vio.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Kelly Dalye45423e2005-11-02 12:08:31 +110048#include <asm/iseries/hv_lp_event.h>
Kelly Dalyc0a8d052005-11-02 11:11:11 +110049#include <asm/iseries/hv_call_event.h>
Kelly Daly15b17182005-11-02 11:55:28 +110050#include <asm/iseries/hv_lp_config.h>
Kelly Daly1da44032005-11-01 16:59:20 +110051#include <asm/iseries/hv_call.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
53#ifdef CONFIG_VT
54#error You must turn off CONFIG_VT to use CONFIG_VIOCONS
55#endif
56
57#define VIOTTY_MAGIC (0x0DCB)
58#define VTTY_PORTS 10
59
60#define VIOCONS_KERN_WARN KERN_WARNING "viocons: "
61#define VIOCONS_KERN_INFO KERN_INFO "viocons: "
62
63static DEFINE_SPINLOCK(consolelock);
64static DEFINE_SPINLOCK(consoleloglock);
65
66#ifdef CONFIG_MAGIC_SYSRQ
67static int vio_sysrq_pressed;
68extern int sysrq_enabled;
69#endif
70
71/*
72 * The structure of the events that flow between us and OS/400. You can't
73 * mess with this unless the OS/400 side changes too
74 */
75struct viocharlpevent {
76 struct HvLpEvent event;
77 u32 reserved;
78 u16 version;
79 u16 subtype_result_code;
80 u8 virtual_device;
81 u8 len;
82 u8 data[VIOCHAR_MAX_DATA];
83};
84
85#define VIOCHAR_WINDOW 10
86#define VIOCHAR_HIGHWATERMARK 3
87
88enum viocharsubtype {
89 viocharopen = 0x0001,
90 viocharclose = 0x0002,
91 viochardata = 0x0003,
92 viocharack = 0x0004,
93 viocharconfig = 0x0005
94};
95
96enum viochar_rc {
97 viochar_rc_ebusy = 1
98};
99
100#define VIOCHAR_NUM_BUF 16
101
102/*
103 * Our port information. We store a pointer to one entry in the
104 * tty_driver_data
105 */
106static struct port_info {
107 int magic;
108 struct tty_struct *tty;
109 HvLpIndex lp;
110 u8 vcons;
111 u64 seq; /* sequence number of last HV send */
112 u64 ack; /* last ack from HV */
113/*
114 * When we get writes faster than we can send it to the partition,
115 * buffer the data here. Note that used is a bit map of used buffers.
116 * It had better have enough bits to hold VIOCHAR_NUM_BUF the bitops assume
117 * it is a multiple of unsigned long
118 */
119 unsigned long used;
120 u8 *buffer[VIOCHAR_NUM_BUF];
121 int bufferBytes[VIOCHAR_NUM_BUF];
122 int curbuf;
123 int bufferOverflow;
124 int overflowMessage;
125} port_info[VTTY_PORTS];
126
127#define viochar_is_console(pi) ((pi) == &port_info[0])
128#define viochar_port(pi) ((pi) - &port_info[0])
129
130static void initDataEvent(struct viocharlpevent *viochar, HvLpIndex lp);
131
132static struct tty_driver *viotty_driver;
133
Michael Ellermanbf6a7112006-01-11 11:54:08 +1100134static void hvlog(char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135{
136 int i;
137 unsigned long flags;
138 va_list args;
139 static char buf[256];
140
141 spin_lock_irqsave(&consoleloglock, flags);
142 va_start(args, fmt);
143 i = vscnprintf(buf, sizeof(buf) - 1, fmt, args);
144 va_end(args);
145 buf[i++] = '\r';
146 HvCall_writeLogBuffer(buf, i);
147 spin_unlock_irqrestore(&consoleloglock, flags);
148}
149
Michael Ellermanbf6a7112006-01-11 11:54:08 +1100150static void hvlogOutput(const char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
152 unsigned long flags;
153 int begin;
154 int index;
155 static const char cr = '\r';
156
157 begin = 0;
158 spin_lock_irqsave(&consoleloglock, flags);
159 for (index = 0; index < count; index++) {
160 if (buf[index] == '\n') {
161 /*
162 * Start right after the last '\n' or at the zeroth
163 * array position and output the number of characters
164 * including the newline.
165 */
166 HvCall_writeLogBuffer(&buf[begin], index - begin + 1);
167 begin = index + 1;
168 HvCall_writeLogBuffer(&cr, 1);
169 }
170 }
171 if ((index - begin) > 0)
172 HvCall_writeLogBuffer(&buf[begin], index - begin);
173 spin_unlock_irqrestore(&consoleloglock, flags);
174}
175
176/*
177 * Make sure we're pointing to a valid port_info structure. Shamelessly
178 * plagerized from serial.c
179 */
180static inline int viotty_paranoia_check(struct port_info *pi,
181 char *name, const char *routine)
182{
183 static const char *bad_pi_addr = VIOCONS_KERN_WARN
184 "warning: bad address for port_info struct (%s) in %s\n";
185 static const char *badmagic = VIOCONS_KERN_WARN
186 "warning: bad magic number for port_info struct (%s) in %s\n";
187
188 if ((pi < &port_info[0]) || (viochar_port(pi) > VTTY_PORTS)) {
189 printk(bad_pi_addr, name, routine);
190 return 1;
191 }
192 if (pi->magic != VIOTTY_MAGIC) {
193 printk(badmagic, name, routine);
194 return 1;
195 }
196 return 0;
197}
198
199/*
200 * Add data to our pending-send buffers.
201 *
202 * NOTE: Don't use printk in here because it gets nastily recursive.
203 * hvlog can be used to log to the hypervisor buffer
204 */
205static int buffer_add(struct port_info *pi, const char *buf, size_t len)
206{
207 size_t bleft;
208 size_t curlen;
209 const char *curbuf;
210 int nextbuf;
211
212 curbuf = buf;
213 bleft = len;
214 while (bleft > 0) {
215 /*
216 * If there is no space left in the current buffer, we have
217 * filled everything up, so return. If we filled the previous
218 * buffer we would already have moved to the next one.
219 */
220 if (pi->bufferBytes[pi->curbuf] == VIOCHAR_MAX_DATA) {
221 hvlog ("\n\rviocons: No overflow buffer available for memcpy().\n");
222 pi->bufferOverflow++;
223 pi->overflowMessage = 1;
224 break;
225 }
226
227 /*
228 * Turn on the "used" bit for this buffer. If it's already on,
229 * that's fine.
230 */
231 set_bit(pi->curbuf, &pi->used);
232
233 /*
234 * See if this buffer has been allocated. If not, allocate it.
235 */
236 if (pi->buffer[pi->curbuf] == NULL) {
237 pi->buffer[pi->curbuf] =
238 kmalloc(VIOCHAR_MAX_DATA, GFP_ATOMIC);
239 if (pi->buffer[pi->curbuf] == NULL) {
240 hvlog("\n\rviocons: kmalloc failed allocating spaces for buffer %d.",
241 pi->curbuf);
242 break;
243 }
244 }
245
246 /* Figure out how much we can copy into this buffer. */
247 if (bleft < (VIOCHAR_MAX_DATA - pi->bufferBytes[pi->curbuf]))
248 curlen = bleft;
249 else
250 curlen = VIOCHAR_MAX_DATA - pi->bufferBytes[pi->curbuf];
251
252 /* Copy the data into the buffer. */
253 memcpy(pi->buffer[pi->curbuf] + pi->bufferBytes[pi->curbuf],
254 curbuf, curlen);
255
256 pi->bufferBytes[pi->curbuf] += curlen;
257 curbuf += curlen;
258 bleft -= curlen;
259
260 /*
261 * Now see if we've filled this buffer. If not then
262 * we'll try to use it again later. If we've filled it
263 * up then we'll advance the curbuf to the next in the
264 * circular queue.
265 */
266 if (pi->bufferBytes[pi->curbuf] == VIOCHAR_MAX_DATA) {
267 nextbuf = (pi->curbuf + 1) % VIOCHAR_NUM_BUF;
268 /*
269 * Move to the next buffer if it hasn't been used yet
270 */
271 if (test_bit(nextbuf, &pi->used) == 0)
272 pi->curbuf = nextbuf;
273 }
274 }
275 return len - bleft;
276}
277
278/*
279 * Send pending data
280 *
281 * NOTE: Don't use printk in here because it gets nastily recursive.
282 * hvlog can be used to log to the hypervisor buffer
283 */
284static void send_buffers(struct port_info *pi)
285{
286 HvLpEvent_Rc hvrc;
287 int nextbuf;
288 struct viocharlpevent *viochar;
289 unsigned long flags;
290
291 spin_lock_irqsave(&consolelock, flags);
292
293 viochar = (struct viocharlpevent *)
294 vio_get_event_buffer(viomajorsubtype_chario);
295
296 /* Make sure we got a buffer */
297 if (viochar == NULL) {
298 hvlog("\n\rviocons: Can't get viochar buffer in sendBuffers().");
299 spin_unlock_irqrestore(&consolelock, flags);
300 return;
301 }
302
303 if (pi->used == 0) {
304 hvlog("\n\rviocons: in sendbuffers(), but no buffers used.\n");
305 vio_free_event_buffer(viomajorsubtype_chario, viochar);
306 spin_unlock_irqrestore(&consolelock, flags);
307 return;
308 }
309
310 /*
311 * curbuf points to the buffer we're filling. We want to
312 * start sending AFTER this one.
313 */
314 nextbuf = (pi->curbuf + 1) % VIOCHAR_NUM_BUF;
315
316 /*
317 * Loop until we find a buffer with the used bit on
318 */
319 while (test_bit(nextbuf, &pi->used) == 0)
320 nextbuf = (nextbuf + 1) % VIOCHAR_NUM_BUF;
321
322 initDataEvent(viochar, pi->lp);
323
324 /*
325 * While we have buffers with data, and our send window
326 * is open, send them
327 */
328 while ((test_bit(nextbuf, &pi->used)) &&
329 ((pi->seq - pi->ack) < VIOCHAR_WINDOW)) {
330 viochar->len = pi->bufferBytes[nextbuf];
331 viochar->event.xCorrelationToken = pi->seq++;
332 viochar->event.xSizeMinus1 =
333 offsetof(struct viocharlpevent, data) + viochar->len;
334
335 memcpy(viochar->data, pi->buffer[nextbuf], viochar->len);
336
337 hvrc = HvCallEvent_signalLpEvent(&viochar->event);
338 if (hvrc) {
339 /*
340 * MUST unlock the spinlock before doing a printk
341 */
342 vio_free_event_buffer(viomajorsubtype_chario, viochar);
343 spin_unlock_irqrestore(&consolelock, flags);
344
345 printk(VIOCONS_KERN_WARN
346 "error sending event! return code %d\n",
347 (int)hvrc);
348 return;
349 }
350
351 /*
352 * clear the used bit, zero the number of bytes in
353 * this buffer, and move to the next buffer
354 */
355 clear_bit(nextbuf, &pi->used);
356 pi->bufferBytes[nextbuf] = 0;
357 nextbuf = (nextbuf + 1) % VIOCHAR_NUM_BUF;
358 }
359
360 /*
361 * If we have emptied all the buffers, start at 0 again.
362 * this will re-use any allocated buffers
363 */
364 if (pi->used == 0) {
365 pi->curbuf = 0;
366
367 if (pi->overflowMessage)
368 pi->overflowMessage = 0;
369
370 if (pi->tty) {
371 tty_wakeup(pi->tty);
372 }
373 }
374
375 vio_free_event_buffer(viomajorsubtype_chario, viochar);
376 spin_unlock_irqrestore(&consolelock, flags);
377}
378
379/*
380 * Our internal writer. Gets called both from the console device and
381 * the tty device. the tty pointer will be NULL if called from the console.
382 * Return total number of bytes "written".
383 *
384 * NOTE: Don't use printk in here because it gets nastily recursive. hvlog
385 * can be used to log to the hypervisor buffer
386 */
387static int internal_write(struct port_info *pi, const char *buf, size_t len)
388{
389 HvLpEvent_Rc hvrc;
390 size_t bleft;
391 size_t curlen;
392 const char *curbuf;
393 unsigned long flags;
394 struct viocharlpevent *viochar;
395
396 /*
397 * Write to the hvlog of inbound data are now done prior to
398 * calling internal_write() since internal_write() is only called in
399 * the event that an lp event path is active, which isn't the case for
400 * logging attempts prior to console initialization.
401 *
402 * If there is already data queued for this port, send it prior to
403 * attempting to send any new data.
404 */
405 if (pi->used)
406 send_buffers(pi);
407
408 spin_lock_irqsave(&consolelock, flags);
409
410 viochar = vio_get_event_buffer(viomajorsubtype_chario);
411 if (viochar == NULL) {
412 spin_unlock_irqrestore(&consolelock, flags);
413 hvlog("\n\rviocons: Can't get vio buffer in internal_write().");
414 return -EAGAIN;
415 }
416 initDataEvent(viochar, pi->lp);
417
418 curbuf = buf;
419 bleft = len;
420
421 while ((bleft > 0) && (pi->used == 0) &&
422 ((pi->seq - pi->ack) < VIOCHAR_WINDOW)) {
423 if (bleft > VIOCHAR_MAX_DATA)
424 curlen = VIOCHAR_MAX_DATA;
425 else
426 curlen = bleft;
427
428 viochar->event.xCorrelationToken = pi->seq++;
429 memcpy(viochar->data, curbuf, curlen);
430 viochar->len = curlen;
431 viochar->event.xSizeMinus1 =
432 offsetof(struct viocharlpevent, data) + curlen;
433
434 hvrc = HvCallEvent_signalLpEvent(&viochar->event);
435 if (hvrc) {
436 hvlog("viocons: error sending event! %d\n", (int)hvrc);
437 goto out;
438 }
439 curbuf += curlen;
440 bleft -= curlen;
441 }
442
443 /* If we didn't send it all, buffer as much of it as we can. */
444 if (bleft > 0)
445 bleft -= buffer_add(pi, curbuf, bleft);
446out:
447 vio_free_event_buffer(viomajorsubtype_chario, viochar);
448 spin_unlock_irqrestore(&consolelock, flags);
449 return len - bleft;
450}
451
452static struct port_info *get_port_data(struct tty_struct *tty)
453{
454 unsigned long flags;
455 struct port_info *pi;
456
457 spin_lock_irqsave(&consolelock, flags);
458 if (tty) {
459 pi = (struct port_info *)tty->driver_data;
460 if (!pi || viotty_paranoia_check(pi, tty->name,
461 "get_port_data")) {
462 pi = NULL;
463 }
464 } else
465 /*
466 * If this is the console device, use the lp from
467 * the first port entry
468 */
469 pi = &port_info[0];
470 spin_unlock_irqrestore(&consolelock, flags);
471 return pi;
472}
473
474/*
475 * Initialize the common fields in a charLpEvent
476 */
477static void initDataEvent(struct viocharlpevent *viochar, HvLpIndex lp)
478{
Stephen Rothwell677f8c02006-01-12 13:47:43 +1100479 struct HvLpEvent *hev = &viochar->event;
480
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 memset(viochar, 0, sizeof(struct viocharlpevent));
482
Stephen Rothwell677f8c02006-01-12 13:47:43 +1100483 hev->flags = HV_LP_EVENT_VALID | HV_LP_EVENT_DEFERRED_ACK |
484 HV_LP_EVENT_INT;
485 hev->xType = HvLpEvent_Type_VirtualIo;
486 hev->xSubtype = viomajorsubtype_chario | viochardata;
487 hev->xSourceLp = HvLpConfig_getLpIndex();
488 hev->xTargetLp = lp;
489 hev->xSizeMinus1 = sizeof(struct viocharlpevent);
490 hev->xSourceInstanceId = viopath_sourceinst(lp);
491 hev->xTargetInstanceId = viopath_targetinst(lp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492}
493
494/*
495 * early console device write
496 */
497static void viocons_write_early(struct console *co, const char *s, unsigned count)
498{
499 hvlogOutput(s, count);
500}
501
502/*
503 * console device write
504 */
505static void viocons_write(struct console *co, const char *s, unsigned count)
506{
507 int index;
508 int begin;
509 struct port_info *pi;
510
511 static const char cr = '\r';
512
513 /*
514 * Check port data first because the target LP might be valid but
515 * simply not active, in which case we want to hvlog the output.
516 */
517 pi = get_port_data(NULL);
518 if (pi == NULL) {
519 hvlog("\n\rviocons_write: unable to get port data.");
520 return;
521 }
522
523 hvlogOutput(s, count);
524
525 if (!viopath_isactive(pi->lp))
526 return;
527
528 /*
529 * Any newline character found will cause a
530 * carriage return character to be emitted as well.
531 */
532 begin = 0;
533 for (index = 0; index < count; index++) {
534 if (s[index] == '\n') {
535 /*
536 * Newline found. Print everything up to and
537 * including the newline
538 */
539 internal_write(pi, &s[begin], index - begin + 1);
540 begin = index + 1;
541 /* Emit a carriage return as well */
542 internal_write(pi, &cr, 1);
543 }
544 }
545
546 /* If any characters left to write, write them now */
547 if ((index - begin) > 0)
548 internal_write(pi, &s[begin], index - begin);
549}
550
551/*
552 * Work out the device associate with this console
553 */
554static struct tty_driver *viocons_device(struct console *c, int *index)
555{
556 *index = c->index;
557 return viotty_driver;
558}
559
560/*
561 * console device I/O methods
562 */
563static struct console viocons_early = {
564 .name = "viocons",
565 .write = viocons_write_early,
566 .flags = CON_PRINTBUFFER,
567 .index = -1,
568};
569
570static struct console viocons = {
571 .name = "viocons",
572 .write = viocons_write,
573 .device = viocons_device,
574 .flags = CON_PRINTBUFFER,
575 .index = -1,
576};
577
578/*
579 * TTY Open method
580 */
581static int viotty_open(struct tty_struct *tty, struct file *filp)
582{
583 int port;
584 unsigned long flags;
585 struct port_info *pi;
586
587 port = tty->index;
588
589 if ((port < 0) || (port >= VTTY_PORTS))
590 return -ENODEV;
591
592 spin_lock_irqsave(&consolelock, flags);
593
594 pi = &port_info[port];
595 /* If some other TTY is already connected here, reject the open */
596 if ((pi->tty) && (pi->tty != tty)) {
597 spin_unlock_irqrestore(&consolelock, flags);
598 printk(VIOCONS_KERN_WARN
599 "attempt to open device twice from different ttys\n");
600 return -EBUSY;
601 }
602 tty->driver_data = pi;
603 pi->tty = tty;
604 spin_unlock_irqrestore(&consolelock, flags);
605
606 return 0;
607}
608
609/*
610 * TTY Close method
611 */
612static void viotty_close(struct tty_struct *tty, struct file *filp)
613{
614 unsigned long flags;
615 struct port_info *pi;
616
617 spin_lock_irqsave(&consolelock, flags);
618 pi = (struct port_info *)tty->driver_data;
619
620 if (!pi || viotty_paranoia_check(pi, tty->name, "viotty_close")) {
621 spin_unlock_irqrestore(&consolelock, flags);
622 return;
623 }
624 if (tty->count == 1)
625 pi->tty = NULL;
626 spin_unlock_irqrestore(&consolelock, flags);
627}
628
629/*
630 * TTY Write method
631 */
632static int viotty_write(struct tty_struct *tty, const unsigned char *buf,
633 int count)
634{
635 struct port_info *pi;
636
637 pi = get_port_data(tty);
638 if (pi == NULL) {
639 hvlog("\n\rviotty_write: no port data.");
640 return -ENODEV;
641 }
642
643 if (viochar_is_console(pi))
644 hvlogOutput(buf, count);
645
646 /*
647 * If the path to this LP is closed, don't bother doing anything more.
648 * just dump the data on the floor and return count. For some reason
649 * some user level programs will attempt to probe available tty's and
650 * they'll attempt a viotty_write on an invalid port which maps to an
651 * invalid target lp. If this is the case then ignore the
652 * viotty_write call and, since the viopath isn't active to this
653 * partition, return count.
654 */
655 if (!viopath_isactive(pi->lp))
656 return count;
657
658 return internal_write(pi, buf, count);
659}
660
661/*
662 * TTY put_char method
663 */
664static void viotty_put_char(struct tty_struct *tty, unsigned char ch)
665{
666 struct port_info *pi;
667
668 pi = get_port_data(tty);
669 if (pi == NULL)
670 return;
671
672 /* This will append '\r' as well if the char is '\n' */
673 if (viochar_is_console(pi))
674 hvlogOutput(&ch, 1);
675
676 if (viopath_isactive(pi->lp))
677 internal_write(pi, &ch, 1);
678}
679
680/*
681 * TTY write_room method
682 */
683static int viotty_write_room(struct tty_struct *tty)
684{
685 int i;
686 int room = 0;
687 struct port_info *pi;
688 unsigned long flags;
689
690 spin_lock_irqsave(&consolelock, flags);
691 pi = (struct port_info *)tty->driver_data;
692 if (!pi || viotty_paranoia_check(pi, tty->name, "viotty_write_room")) {
693 spin_unlock_irqrestore(&consolelock, flags);
694 return 0;
695 }
696
697 /* If no buffers are used, return the max size. */
698 if (pi->used == 0) {
699 spin_unlock_irqrestore(&consolelock, flags);
700 return VIOCHAR_MAX_DATA * VIOCHAR_NUM_BUF;
701 }
702
703 /*
704 * We retain the spinlock because we want to get an accurate
705 * count and it can change on us between each operation if we
706 * don't hold the spinlock.
707 */
708 for (i = 0; ((i < VIOCHAR_NUM_BUF) && (room < VIOCHAR_MAX_DATA)); i++)
709 room += (VIOCHAR_MAX_DATA - pi->bufferBytes[i]);
710 spin_unlock_irqrestore(&consolelock, flags);
711
712 if (room > VIOCHAR_MAX_DATA)
713 room = VIOCHAR_MAX_DATA;
714 return room;
715}
716
717/*
718 * TTY chars_in_buffer method
719 */
720static int viotty_chars_in_buffer(struct tty_struct *tty)
721{
722 return 0;
723}
724
725static int viotty_ioctl(struct tty_struct *tty, struct file *file,
726 unsigned int cmd, unsigned long arg)
727{
728 switch (cmd) {
729 /*
730 * the ioctls below read/set the flags usually shown in the leds
731 * don't use them - they will go away without warning
732 */
733 case KDGETLED:
734 case KDGKBLED:
735 return put_user(0, (char *)arg);
736
737 case KDSKBLED:
738 return 0;
739 }
740
741 return n_tty_ioctl(tty, file, cmd, arg);
742}
743
744/*
745 * Handle an open charLpEvent. Could be either interrupt or ack
746 */
747static void vioHandleOpenEvent(struct HvLpEvent *event)
748{
749 unsigned long flags;
750 struct viocharlpevent *cevent = (struct viocharlpevent *)event;
751 u8 port = cevent->virtual_device;
752 struct port_info *pi;
753 int reject = 0;
754
Stephen Rothwell677f8c02006-01-12 13:47:43 +1100755 if (hvlpevent_is_ack(event)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 if (port >= VTTY_PORTS)
757 return;
758
759 spin_lock_irqsave(&consolelock, flags);
760 /* Got the lock, don't cause console output */
761
762 pi = &port_info[port];
763 if (event->xRc == HvLpEvent_Rc_Good) {
764 pi->seq = pi->ack = 0;
765 /*
766 * This line allows connections from the primary
767 * partition but once one is connected from the
768 * primary partition nothing short of a reboot
769 * of linux will allow access from the hosting
770 * partition again without a required iSeries fix.
771 */
772 pi->lp = event->xTargetLp;
773 }
774
775 spin_unlock_irqrestore(&consolelock, flags);
776 if (event->xRc != HvLpEvent_Rc_Good)
777 printk(VIOCONS_KERN_WARN
778 "handle_open_event: event->xRc == (%d).\n",
779 event->xRc);
780
781 if (event->xCorrelationToken != 0) {
782 atomic_t *aptr= (atomic_t *)event->xCorrelationToken;
783 atomic_set(aptr, 1);
784 } else
785 printk(VIOCONS_KERN_WARN
786 "weird...got open ack without atomic\n");
787 return;
788 }
789
790 /* This had better require an ack, otherwise complain */
Stephen Rothwell677f8c02006-01-12 13:47:43 +1100791 if (!hvlpevent_need_ack(event)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 printk(VIOCONS_KERN_WARN "viocharopen without ack bit!\n");
793 return;
794 }
795
796 spin_lock_irqsave(&consolelock, flags);
797 /* Got the lock, don't cause console output */
798
799 /* Make sure this is a good virtual tty */
800 if (port >= VTTY_PORTS) {
801 event->xRc = HvLpEvent_Rc_SubtypeError;
802 cevent->subtype_result_code = viorc_openRejected;
803 /*
804 * Flag state here since we can't printk while holding
805 * a spinlock.
806 */
807 reject = 1;
808 } else {
809 pi = &port_info[port];
810 if ((pi->lp != HvLpIndexInvalid) &&
811 (pi->lp != event->xSourceLp)) {
812 /*
813 * If this is tty is already connected to a different
814 * partition, fail.
815 */
816 event->xRc = HvLpEvent_Rc_SubtypeError;
817 cevent->subtype_result_code = viorc_openRejected;
818 reject = 2;
819 } else {
820 pi->lp = event->xSourceLp;
821 event->xRc = HvLpEvent_Rc_Good;
822 cevent->subtype_result_code = viorc_good;
823 pi->seq = pi->ack = 0;
824 reject = 0;
825 }
826 }
827
828 spin_unlock_irqrestore(&consolelock, flags);
829
830 if (reject == 1)
831 printk(VIOCONS_KERN_WARN "open rejected: bad virtual tty.\n");
832 else if (reject == 2)
833 printk(VIOCONS_KERN_WARN
834 "open rejected: console in exclusive use by another partition.\n");
835
836 /* Return the acknowledgement */
837 HvCallEvent_ackLpEvent(event);
838}
839
840/*
841 * Handle a close charLpEvent. This should ONLY be an Interrupt because the
842 * virtual console should never actually issue a close event to the hypervisor
843 * because the virtual console never goes away. A close event coming from the
844 * hypervisor simply means that there are no client consoles connected to the
845 * virtual console.
846 *
847 * Regardless of the number of connections masqueraded on the other side of
848 * the hypervisor ONLY ONE close event should be called to accompany the ONE
849 * open event that is called. The close event should ONLY be called when NO
850 * MORE connections (masqueraded or not) exist on the other side of the
851 * hypervisor.
852 */
853static void vioHandleCloseEvent(struct HvLpEvent *event)
854{
855 unsigned long flags;
856 struct viocharlpevent *cevent = (struct viocharlpevent *)event;
857 u8 port = cevent->virtual_device;
858
Stephen Rothwell677f8c02006-01-12 13:47:43 +1100859 if (hvlpevent_is_int(event)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 if (port >= VTTY_PORTS) {
861 printk(VIOCONS_KERN_WARN
862 "close message from invalid virtual device.\n");
863 return;
864 }
865
866 /* For closes, just mark the console partition invalid */
867 spin_lock_irqsave(&consolelock, flags);
868 /* Got the lock, don't cause console output */
869
870 if (port_info[port].lp == event->xSourceLp)
871 port_info[port].lp = HvLpIndexInvalid;
872
873 spin_unlock_irqrestore(&consolelock, flags);
874 printk(VIOCONS_KERN_INFO "close from %d\n", event->xSourceLp);
875 } else
876 printk(VIOCONS_KERN_WARN
877 "got unexpected close acknowlegement\n");
878}
879
880/*
881 * Handle a config charLpEvent. Could be either interrupt or ack
882 */
883static void vioHandleConfig(struct HvLpEvent *event)
884{
885 struct viocharlpevent *cevent = (struct viocharlpevent *)event;
886
887 HvCall_writeLogBuffer(cevent->data, cevent->len);
888
889 if (cevent->data[0] == 0x01)
890 printk(VIOCONS_KERN_INFO "window resized to %d: %d: %d: %d\n",
891 cevent->data[1], cevent->data[2],
892 cevent->data[3], cevent->data[4]);
893 else
894 printk(VIOCONS_KERN_WARN "unknown config event\n");
895}
896
897/*
898 * Handle a data charLpEvent.
899 */
900static void vioHandleData(struct HvLpEvent *event)
901{
902 struct tty_struct *tty;
903 unsigned long flags;
904 struct viocharlpevent *cevent = (struct viocharlpevent *)event;
905 struct port_info *pi;
906 int index;
Stephen Rothwell415c2e02006-01-11 13:51:22 +1100907 int num_pushed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 u8 port = cevent->virtual_device;
909
910 if (port >= VTTY_PORTS) {
911 printk(VIOCONS_KERN_WARN "data on invalid virtual device %d\n",
912 port);
913 return;
914 }
915
916 /*
917 * Hold the spinlock so that we don't take an interrupt that
918 * changes tty between the time we fetch the port_info
919 * pointer and the time we paranoia check.
920 */
921 spin_lock_irqsave(&consolelock, flags);
922 pi = &port_info[port];
923
924 /*
925 * Change 05/01/2003 - Ryan Arnold: If a partition other than
926 * the current exclusive partition tries to send us data
927 * events then just drop them on the floor because we don't
928 * want his stinking data. He isn't authorized to receive
929 * data because he wasn't the first one to get the console,
930 * therefore he shouldn't be allowed to send data either.
931 * This will work without an iSeries fix.
932 */
933 if (pi->lp != event->xSourceLp) {
934 spin_unlock_irqrestore(&consolelock, flags);
935 return;
936 }
937
938 tty = pi->tty;
939 if (tty == NULL) {
940 spin_unlock_irqrestore(&consolelock, flags);
941 printk(VIOCONS_KERN_WARN "no tty for virtual device %d\n",
942 port);
943 return;
944 }
945
946 if (tty->magic != TTY_MAGIC) {
947 spin_unlock_irqrestore(&consolelock, flags);
948 printk(VIOCONS_KERN_WARN "tty bad magic\n");
949 return;
950 }
951
952 /*
953 * Just to be paranoid, make sure the tty points back to this port
954 */
955 pi = (struct port_info *)tty->driver_data;
956 if (!pi || viotty_paranoia_check(pi, tty->name, "vioHandleData")) {
957 spin_unlock_irqrestore(&consolelock, flags);
958 return;
959 }
960 spin_unlock_irqrestore(&consolelock, flags);
961
962 /*
963 * Change 07/21/2003 - Ryan Arnold: functionality added to
964 * support sysrq utilizing ^O as the sysrq key. The sysrq
965 * functionality will only work if built into the kernel and
966 * then only if sysrq is enabled through the proc filesystem.
967 */
Stephen Rothwell415c2e02006-01-11 13:51:22 +1100968 num_pushed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 for (index = 0; index < cevent->len; index++) {
970#ifdef CONFIG_MAGIC_SYSRQ
971 if (sysrq_enabled) {
972 /* 0x0f is the ascii character for ^O */
973 if (cevent->data[index] == '\x0f') {
974 vio_sysrq_pressed = 1;
975 /*
976 * continue because we don't want to add
977 * the sysrq key into the data string.
978 */
979 continue;
980 } else if (vio_sysrq_pressed) {
981 handle_sysrq(cevent->data[index], NULL, tty);
982 vio_sysrq_pressed = 0;
983 /*
984 * continue because we don't want to add
985 * the sysrq sequence into the data string.
986 */
987 continue;
988 }
989 }
990#endif
991 /*
992 * The sysrq sequence isn't included in this check if
993 * sysrq is enabled and compiled into the kernel because
994 * the sequence will never get inserted into the buffer.
995 * Don't attempt to copy more data into the buffer than we
996 * have room for because it would fail without indication.
997 */
Alan Cox33f0f882006-01-09 20:54:13 -0800998 if(tty_insert_flip_char(tty, cevent->data[index], TTY_NORMAL) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 printk(VIOCONS_KERN_WARN "input buffer overflow!\n");
1000 break;
1001 }
Stephen Rothwell415c2e02006-01-11 13:51:22 +11001002 num_pushed++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 }
1004
Stephen Rothwell415c2e02006-01-11 13:51:22 +11001005 if (num_pushed)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 tty_flip_buffer_push(tty);
1007}
1008
1009/*
1010 * Handle an ack charLpEvent.
1011 */
1012static void vioHandleAck(struct HvLpEvent *event)
1013{
1014 struct viocharlpevent *cevent = (struct viocharlpevent *)event;
1015 unsigned long flags;
1016 u8 port = cevent->virtual_device;
1017
1018 if (port >= VTTY_PORTS) {
1019 printk(VIOCONS_KERN_WARN "data on invalid virtual device\n");
1020 return;
1021 }
1022
1023 spin_lock_irqsave(&consolelock, flags);
1024 port_info[port].ack = event->xCorrelationToken;
1025 spin_unlock_irqrestore(&consolelock, flags);
1026
1027 if (port_info[port].used)
1028 send_buffers(&port_info[port]);
1029}
1030
1031/*
1032 * Handle charLpEvents and route to the appropriate routine
1033 */
1034static void vioHandleCharEvent(struct HvLpEvent *event)
1035{
1036 int charminor;
1037
1038 if (event == NULL)
1039 return;
1040
1041 charminor = event->xSubtype & VIOMINOR_SUBTYPE_MASK;
1042 switch (charminor) {
1043 case viocharopen:
1044 vioHandleOpenEvent(event);
1045 break;
1046 case viocharclose:
1047 vioHandleCloseEvent(event);
1048 break;
1049 case viochardata:
1050 vioHandleData(event);
1051 break;
1052 case viocharack:
1053 vioHandleAck(event);
1054 break;
1055 case viocharconfig:
1056 vioHandleConfig(event);
1057 break;
1058 default:
Stephen Rothwell677f8c02006-01-12 13:47:43 +11001059 if (hvlpevent_is_int(event) && hvlpevent_need_ack(event)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 event->xRc = HvLpEvent_Rc_InvalidSubtype;
1061 HvCallEvent_ackLpEvent(event);
1062 }
1063 }
1064}
1065
1066/*
1067 * Send an open event
1068 */
1069static int send_open(HvLpIndex remoteLp, void *sem)
1070{
1071 return HvCallEvent_signalLpEventFast(remoteLp,
1072 HvLpEvent_Type_VirtualIo,
1073 viomajorsubtype_chario | viocharopen,
1074 HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
1075 viopath_sourceinst(remoteLp),
1076 viopath_targetinst(remoteLp),
1077 (u64)(unsigned long)sem, VIOVERSION << 16,
1078 0, 0, 0, 0);
1079}
1080
1081static struct tty_operations serial_ops = {
1082 .open = viotty_open,
1083 .close = viotty_close,
1084 .write = viotty_write,
1085 .put_char = viotty_put_char,
1086 .write_room = viotty_write_room,
1087 .chars_in_buffer = viotty_chars_in_buffer,
1088 .ioctl = viotty_ioctl,
1089};
1090
1091static int __init viocons_init2(void)
1092{
1093 atomic_t wait_flag;
1094 int rc;
1095
1096 /* +2 for fudge */
1097 rc = viopath_open(HvLpConfig_getPrimaryLpIndex(),
1098 viomajorsubtype_chario, VIOCHAR_WINDOW + 2);
1099 if (rc)
1100 printk(VIOCONS_KERN_WARN "error opening to primary %d\n", rc);
1101
1102 if (viopath_hostLp == HvLpIndexInvalid)
1103 vio_set_hostlp();
1104
1105 /*
1106 * And if the primary is not the same as the hosting LP, open to the
1107 * hosting lp
1108 */
1109 if ((viopath_hostLp != HvLpIndexInvalid) &&
1110 (viopath_hostLp != HvLpConfig_getPrimaryLpIndex())) {
1111 printk(VIOCONS_KERN_INFO "open path to hosting (%d)\n",
1112 viopath_hostLp);
1113 rc = viopath_open(viopath_hostLp, viomajorsubtype_chario,
1114 VIOCHAR_WINDOW + 2); /* +2 for fudge */
1115 if (rc)
1116 printk(VIOCONS_KERN_WARN
1117 "error opening to partition %d: %d\n",
1118 viopath_hostLp, rc);
1119 }
1120
1121 if (vio_setHandler(viomajorsubtype_chario, vioHandleCharEvent) < 0)
1122 printk(VIOCONS_KERN_WARN
1123 "error seting handler for console events!\n");
1124
1125 /*
1126 * First, try to open the console to the hosting lp.
1127 * Wait on a semaphore for the response.
1128 */
1129 atomic_set(&wait_flag, 0);
1130 if ((viopath_isactive(viopath_hostLp)) &&
1131 (send_open(viopath_hostLp, (void *)&wait_flag) == 0)) {
1132 printk(VIOCONS_KERN_INFO "hosting partition %d\n",
1133 viopath_hostLp);
1134 while (atomic_read(&wait_flag) == 0)
1135 mb();
1136 atomic_set(&wait_flag, 0);
1137 }
1138
1139 /*
1140 * If we don't have an active console, try the primary
1141 */
1142 if ((!viopath_isactive(port_info[0].lp)) &&
1143 (viopath_isactive(HvLpConfig_getPrimaryLpIndex())) &&
1144 (send_open(HvLpConfig_getPrimaryLpIndex(), (void *)&wait_flag)
1145 == 0)) {
1146 printk(VIOCONS_KERN_INFO "opening console to primary partition\n");
1147 while (atomic_read(&wait_flag) == 0)
1148 mb();
1149 }
1150
1151 /* Initialize the tty_driver structure */
1152 viotty_driver = alloc_tty_driver(VTTY_PORTS);
1153 viotty_driver->owner = THIS_MODULE;
1154 viotty_driver->driver_name = "vioconsole";
1155 viotty_driver->devfs_name = "vcs/";
1156 viotty_driver->name = "tty";
1157 viotty_driver->name_base = 1;
1158 viotty_driver->major = TTY_MAJOR;
1159 viotty_driver->minor_start = 1;
1160 viotty_driver->type = TTY_DRIVER_TYPE_CONSOLE;
1161 viotty_driver->subtype = 1;
1162 viotty_driver->init_termios = tty_std_termios;
1163 viotty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
1164 tty_set_operations(viotty_driver, &serial_ops);
1165
1166 if (tty_register_driver(viotty_driver)) {
1167 printk(VIOCONS_KERN_WARN "couldn't register console driver\n");
1168 put_tty_driver(viotty_driver);
1169 viotty_driver = NULL;
1170 }
1171
1172 unregister_console(&viocons_early);
1173 register_console(&viocons);
1174
1175 return 0;
1176}
1177
1178static int __init viocons_init(void)
1179{
1180 int i;
1181
1182 printk(VIOCONS_KERN_INFO "registering console\n");
1183 for (i = 0; i < VTTY_PORTS; i++) {
1184 port_info[i].lp = HvLpIndexInvalid;
1185 port_info[i].magic = VIOTTY_MAGIC;
1186 }
1187 HvCall_setLogBufferFormatAndCodepage(HvCall_LogBuffer_ASCII, 437);
1188 register_console(&viocons_early);
1189 return 0;
1190}
1191
1192console_initcall(viocons_init);
1193module_init(viocons_init2);