ia64/linux-2.6.18-xen.hg

view drivers/char/viocons.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

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