3 * drivers/char/viocons.c
5 * iSeries Virtual Terminal
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>
12 * (C) Copyright 2000, 2001, 2002, 2003, 2004 IBM Corporation
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.
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.
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
28 #include <linux/kernel.h>
29 #include <linux/proc_fs.h>
30 #include <linux/errno.h>
31 #include <linux/vmalloc.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>
41 #include <linux/tty.h>
42 #include <linux/tty_flip.h>
43 #include <linux/sysrq.h>
45 #include <asm/iseries/vio.h>
46 #include <asm/iseries/hv_lp_event.h>
47 #include <asm/iseries/hv_call_event.h>
48 #include <asm/iseries/hv_lp_config.h>
49 #include <asm/iseries/hv_call.h>
52 #error You must turn off CONFIG_VT to use CONFIG_VIOCONS
55 #define VIOTTY_MAGIC (0x0DCB)
58 #define VIOCONS_KERN_WARN KERN_WARNING "viocons: "
59 #define VIOCONS_KERN_INFO KERN_INFO "viocons: "
61 static DEFINE_SPINLOCK(consolelock
);
62 static DEFINE_SPINLOCK(consoleloglock
);
64 static int vio_sysrq_pressed
;
66 #define VIOCHAR_NUM_BUF 16
69 * Our port information. We store a pointer to one entry in the
72 static struct port_info
{
74 struct tty_struct
*tty
;
77 u64 seq
; /* sequence number of last HV send */
78 u64 ack
; /* last ack from HV */
80 * When we get writes faster than we can send it to the partition,
81 * buffer the data here. Note that used is a bit map of used buffers.
82 * It had better have enough bits to hold VIOCHAR_NUM_BUF the bitops assume
83 * it is a multiple of unsigned long
86 u8
*buffer
[VIOCHAR_NUM_BUF
];
87 int bufferBytes
[VIOCHAR_NUM_BUF
];
91 } port_info
[VTTY_PORTS
];
93 #define viochar_is_console(pi) ((pi) == &port_info[0])
94 #define viochar_port(pi) ((pi) - &port_info[0])
96 static void initDataEvent(struct viocharlpevent
*viochar
, HvLpIndex lp
);
98 static struct tty_driver
*viotty_driver
;
100 static void hvlog(char *fmt
, ...)
105 static char buf
[256];
107 spin_lock_irqsave(&consoleloglock
, flags
);
109 i
= vscnprintf(buf
, sizeof(buf
) - 1, fmt
, args
);
112 HvCall_writeLogBuffer(buf
, i
);
113 spin_unlock_irqrestore(&consoleloglock
, flags
);
116 static void hvlogOutput(const char *buf
, int count
)
121 static const char cr
= '\r';
124 spin_lock_irqsave(&consoleloglock
, flags
);
125 for (index
= 0; index
< count
; index
++) {
126 if (buf
[index
] == '\n') {
128 * Start right after the last '\n' or at the zeroth
129 * array position and output the number of characters
130 * including the newline.
132 HvCall_writeLogBuffer(&buf
[begin
], index
- begin
+ 1);
134 HvCall_writeLogBuffer(&cr
, 1);
137 if ((index
- begin
) > 0)
138 HvCall_writeLogBuffer(&buf
[begin
], index
- begin
);
139 spin_unlock_irqrestore(&consoleloglock
, flags
);
143 * Make sure we're pointing to a valid port_info structure. Shamelessly
144 * plagerized from serial.c
146 static inline int viotty_paranoia_check(struct port_info
*pi
,
147 char *name
, const char *routine
)
149 static const char *bad_pi_addr
= VIOCONS_KERN_WARN
150 "warning: bad address for port_info struct (%s) in %s\n";
151 static const char *badmagic
= VIOCONS_KERN_WARN
152 "warning: bad magic number for port_info struct (%s) in %s\n";
154 if ((pi
< &port_info
[0]) || (viochar_port(pi
) > VTTY_PORTS
)) {
155 printk(bad_pi_addr
, name
, routine
);
158 if (pi
->magic
!= VIOTTY_MAGIC
) {
159 printk(badmagic
, name
, routine
);
166 * Add data to our pending-send buffers.
168 * NOTE: Don't use printk in here because it gets nastily recursive.
169 * hvlog can be used to log to the hypervisor buffer
171 static int buffer_add(struct port_info
*pi
, const char *buf
, size_t len
)
182 * If there is no space left in the current buffer, we have
183 * filled everything up, so return. If we filled the previous
184 * buffer we would already have moved to the next one.
186 if (pi
->bufferBytes
[pi
->curbuf
] == VIOCHAR_MAX_DATA
) {
187 hvlog ("\n\rviocons: No overflow buffer available for memcpy().\n");
188 pi
->bufferOverflow
++;
189 pi
->overflowMessage
= 1;
194 * Turn on the "used" bit for this buffer. If it's already on,
197 set_bit(pi
->curbuf
, &pi
->used
);
200 * See if this buffer has been allocated. If not, allocate it.
202 if (pi
->buffer
[pi
->curbuf
] == NULL
) {
203 pi
->buffer
[pi
->curbuf
] =
204 kmalloc(VIOCHAR_MAX_DATA
, GFP_ATOMIC
);
205 if (pi
->buffer
[pi
->curbuf
] == NULL
) {
206 hvlog("\n\rviocons: kmalloc failed allocating spaces for buffer %d.",
212 /* Figure out how much we can copy into this buffer. */
213 if (bleft
< (VIOCHAR_MAX_DATA
- pi
->bufferBytes
[pi
->curbuf
]))
216 curlen
= VIOCHAR_MAX_DATA
- pi
->bufferBytes
[pi
->curbuf
];
218 /* Copy the data into the buffer. */
219 memcpy(pi
->buffer
[pi
->curbuf
] + pi
->bufferBytes
[pi
->curbuf
],
222 pi
->bufferBytes
[pi
->curbuf
] += curlen
;
227 * Now see if we've filled this buffer. If not then
228 * we'll try to use it again later. If we've filled it
229 * up then we'll advance the curbuf to the next in the
232 if (pi
->bufferBytes
[pi
->curbuf
] == VIOCHAR_MAX_DATA
) {
233 nextbuf
= (pi
->curbuf
+ 1) % VIOCHAR_NUM_BUF
;
235 * Move to the next buffer if it hasn't been used yet
237 if (test_bit(nextbuf
, &pi
->used
) == 0)
238 pi
->curbuf
= nextbuf
;
247 * NOTE: Don't use printk in here because it gets nastily recursive.
248 * hvlog can be used to log to the hypervisor buffer
250 static void send_buffers(struct port_info
*pi
)
254 struct viocharlpevent
*viochar
;
257 spin_lock_irqsave(&consolelock
, flags
);
259 viochar
= (struct viocharlpevent
*)
260 vio_get_event_buffer(viomajorsubtype_chario
);
262 /* Make sure we got a buffer */
263 if (viochar
== NULL
) {
264 hvlog("\n\rviocons: Can't get viochar buffer in sendBuffers().");
265 spin_unlock_irqrestore(&consolelock
, flags
);
270 hvlog("\n\rviocons: in sendbuffers(), but no buffers used.\n");
271 vio_free_event_buffer(viomajorsubtype_chario
, viochar
);
272 spin_unlock_irqrestore(&consolelock
, flags
);
277 * curbuf points to the buffer we're filling. We want to
278 * start sending AFTER this one.
280 nextbuf
= (pi
->curbuf
+ 1) % VIOCHAR_NUM_BUF
;
283 * Loop until we find a buffer with the used bit on
285 while (test_bit(nextbuf
, &pi
->used
) == 0)
286 nextbuf
= (nextbuf
+ 1) % VIOCHAR_NUM_BUF
;
288 initDataEvent(viochar
, pi
->lp
);
291 * While we have buffers with data, and our send window
294 while ((test_bit(nextbuf
, &pi
->used
)) &&
295 ((pi
->seq
- pi
->ack
) < VIOCHAR_WINDOW
)) {
296 viochar
->len
= pi
->bufferBytes
[nextbuf
];
297 viochar
->event
.xCorrelationToken
= pi
->seq
++;
298 viochar
->event
.xSizeMinus1
=
299 offsetof(struct viocharlpevent
, data
) + viochar
->len
;
301 memcpy(viochar
->data
, pi
->buffer
[nextbuf
], viochar
->len
);
303 hvrc
= HvCallEvent_signalLpEvent(&viochar
->event
);
306 * MUST unlock the spinlock before doing a printk
308 vio_free_event_buffer(viomajorsubtype_chario
, viochar
);
309 spin_unlock_irqrestore(&consolelock
, flags
);
311 printk(VIOCONS_KERN_WARN
312 "error sending event! return code %d\n",
318 * clear the used bit, zero the number of bytes in
319 * this buffer, and move to the next buffer
321 clear_bit(nextbuf
, &pi
->used
);
322 pi
->bufferBytes
[nextbuf
] = 0;
323 nextbuf
= (nextbuf
+ 1) % VIOCHAR_NUM_BUF
;
327 * If we have emptied all the buffers, start at 0 again.
328 * this will re-use any allocated buffers
333 if (pi
->overflowMessage
)
334 pi
->overflowMessage
= 0;
341 vio_free_event_buffer(viomajorsubtype_chario
, viochar
);
342 spin_unlock_irqrestore(&consolelock
, flags
);
346 * Our internal writer. Gets called both from the console device and
347 * the tty device. the tty pointer will be NULL if called from the console.
348 * Return total number of bytes "written".
350 * NOTE: Don't use printk in here because it gets nastily recursive. hvlog
351 * can be used to log to the hypervisor buffer
353 static int internal_write(struct port_info
*pi
, const char *buf
, size_t len
)
360 struct viocharlpevent
*viochar
;
363 * Write to the hvlog of inbound data are now done prior to
364 * calling internal_write() since internal_write() is only called in
365 * the event that an lp event path is active, which isn't the case for
366 * logging attempts prior to console initialization.
368 * If there is already data queued for this port, send it prior to
369 * attempting to send any new data.
374 spin_lock_irqsave(&consolelock
, flags
);
376 viochar
= vio_get_event_buffer(viomajorsubtype_chario
);
377 if (viochar
== NULL
) {
378 spin_unlock_irqrestore(&consolelock
, flags
);
379 hvlog("\n\rviocons: Can't get vio buffer in internal_write().");
382 initDataEvent(viochar
, pi
->lp
);
387 while ((bleft
> 0) && (pi
->used
== 0) &&
388 ((pi
->seq
- pi
->ack
) < VIOCHAR_WINDOW
)) {
389 if (bleft
> VIOCHAR_MAX_DATA
)
390 curlen
= VIOCHAR_MAX_DATA
;
394 viochar
->event
.xCorrelationToken
= pi
->seq
++;
395 memcpy(viochar
->data
, curbuf
, curlen
);
396 viochar
->len
= curlen
;
397 viochar
->event
.xSizeMinus1
=
398 offsetof(struct viocharlpevent
, data
) + curlen
;
400 hvrc
= HvCallEvent_signalLpEvent(&viochar
->event
);
402 hvlog("viocons: error sending event! %d\n", (int)hvrc
);
409 /* If we didn't send it all, buffer as much of it as we can. */
411 bleft
-= buffer_add(pi
, curbuf
, bleft
);
413 vio_free_event_buffer(viomajorsubtype_chario
, viochar
);
414 spin_unlock_irqrestore(&consolelock
, flags
);
418 static struct port_info
*get_port_data(struct tty_struct
*tty
)
421 struct port_info
*pi
;
423 spin_lock_irqsave(&consolelock
, flags
);
425 pi
= (struct port_info
*)tty
->driver_data
;
426 if (!pi
|| viotty_paranoia_check(pi
, tty
->name
,
432 * If this is the console device, use the lp from
433 * the first port entry
436 spin_unlock_irqrestore(&consolelock
, flags
);
441 * Initialize the common fields in a charLpEvent
443 static void initDataEvent(struct viocharlpevent
*viochar
, HvLpIndex lp
)
445 struct HvLpEvent
*hev
= &viochar
->event
;
447 memset(viochar
, 0, sizeof(struct viocharlpevent
));
449 hev
->flags
= HV_LP_EVENT_VALID
| HV_LP_EVENT_DEFERRED_ACK
|
451 hev
->xType
= HvLpEvent_Type_VirtualIo
;
452 hev
->xSubtype
= viomajorsubtype_chario
| viochardata
;
453 hev
->xSourceLp
= HvLpConfig_getLpIndex();
455 hev
->xSizeMinus1
= sizeof(struct viocharlpevent
);
456 hev
->xSourceInstanceId
= viopath_sourceinst(lp
);
457 hev
->xTargetInstanceId
= viopath_targetinst(lp
);
461 * early console device write
463 static void viocons_write_early(struct console
*co
, const char *s
, unsigned count
)
465 hvlogOutput(s
, count
);
469 * console device write
471 static void viocons_write(struct console
*co
, const char *s
, unsigned count
)
475 struct port_info
*pi
;
477 static const char cr
= '\r';
480 * Check port data first because the target LP might be valid but
481 * simply not active, in which case we want to hvlog the output.
483 pi
= get_port_data(NULL
);
485 hvlog("\n\rviocons_write: unable to get port data.");
489 hvlogOutput(s
, count
);
491 if (!viopath_isactive(pi
->lp
))
495 * Any newline character found will cause a
496 * carriage return character to be emitted as well.
499 for (index
= 0; index
< count
; index
++) {
500 if (s
[index
] == '\n') {
502 * Newline found. Print everything up to and
503 * including the newline
505 internal_write(pi
, &s
[begin
], index
- begin
+ 1);
507 /* Emit a carriage return as well */
508 internal_write(pi
, &cr
, 1);
512 /* If any characters left to write, write them now */
513 if ((index
- begin
) > 0)
514 internal_write(pi
, &s
[begin
], index
- begin
);
518 * Work out the device associate with this console
520 static struct tty_driver
*viocons_device(struct console
*c
, int *index
)
523 return viotty_driver
;
527 * console device I/O methods
529 static struct console viocons_early
= {
531 .write
= viocons_write_early
,
532 .flags
= CON_PRINTBUFFER
,
536 static struct console viocons
= {
538 .write
= viocons_write
,
539 .device
= viocons_device
,
540 .flags
= CON_PRINTBUFFER
,
547 static int viotty_open(struct tty_struct
*tty
, struct file
*filp
)
551 struct port_info
*pi
;
555 if ((port
< 0) || (port
>= VTTY_PORTS
))
558 spin_lock_irqsave(&consolelock
, flags
);
560 pi
= &port_info
[port
];
561 /* If some other TTY is already connected here, reject the open */
562 if ((pi
->tty
) && (pi
->tty
!= tty
)) {
563 spin_unlock_irqrestore(&consolelock
, flags
);
564 printk(VIOCONS_KERN_WARN
565 "attempt to open device twice from different ttys\n");
568 tty
->driver_data
= pi
;
570 spin_unlock_irqrestore(&consolelock
, flags
);
578 static void viotty_close(struct tty_struct
*tty
, struct file
*filp
)
581 struct port_info
*pi
;
583 spin_lock_irqsave(&consolelock
, flags
);
584 pi
= (struct port_info
*)tty
->driver_data
;
586 if (!pi
|| viotty_paranoia_check(pi
, tty
->name
, "viotty_close")) {
587 spin_unlock_irqrestore(&consolelock
, flags
);
592 spin_unlock_irqrestore(&consolelock
, flags
);
598 static int viotty_write(struct tty_struct
*tty
, const unsigned char *buf
,
601 struct port_info
*pi
;
603 pi
= get_port_data(tty
);
605 hvlog("\n\rviotty_write: no port data.");
609 if (viochar_is_console(pi
))
610 hvlogOutput(buf
, count
);
613 * If the path to this LP is closed, don't bother doing anything more.
614 * just dump the data on the floor and return count. For some reason
615 * some user level programs will attempt to probe available tty's and
616 * they'll attempt a viotty_write on an invalid port which maps to an
617 * invalid target lp. If this is the case then ignore the
618 * viotty_write call and, since the viopath isn't active to this
619 * partition, return count.
621 if (!viopath_isactive(pi
->lp
))
624 return internal_write(pi
, buf
, count
);
628 * TTY put_char method
630 static void viotty_put_char(struct tty_struct
*tty
, unsigned char ch
)
632 struct port_info
*pi
;
634 pi
= get_port_data(tty
);
638 /* This will append '\r' as well if the char is '\n' */
639 if (viochar_is_console(pi
))
642 if (viopath_isactive(pi
->lp
))
643 internal_write(pi
, &ch
, 1);
647 * TTY write_room method
649 static int viotty_write_room(struct tty_struct
*tty
)
653 struct port_info
*pi
;
656 spin_lock_irqsave(&consolelock
, flags
);
657 pi
= (struct port_info
*)tty
->driver_data
;
658 if (!pi
|| viotty_paranoia_check(pi
, tty
->name
, "viotty_write_room")) {
659 spin_unlock_irqrestore(&consolelock
, flags
);
663 /* If no buffers are used, return the max size. */
665 spin_unlock_irqrestore(&consolelock
, flags
);
666 return VIOCHAR_MAX_DATA
* VIOCHAR_NUM_BUF
;
670 * We retain the spinlock because we want to get an accurate
671 * count and it can change on us between each operation if we
672 * don't hold the spinlock.
674 for (i
= 0; ((i
< VIOCHAR_NUM_BUF
) && (room
< VIOCHAR_MAX_DATA
)); i
++)
675 room
+= (VIOCHAR_MAX_DATA
- pi
->bufferBytes
[i
]);
676 spin_unlock_irqrestore(&consolelock
, flags
);
678 if (room
> VIOCHAR_MAX_DATA
)
679 room
= VIOCHAR_MAX_DATA
;
684 * TTY chars_in_buffer method
686 static int viotty_chars_in_buffer(struct tty_struct
*tty
)
691 static int viotty_ioctl(struct tty_struct
*tty
, struct file
*file
,
692 unsigned int cmd
, unsigned long arg
)
696 * the ioctls below read/set the flags usually shown in the leds
697 * don't use them - they will go away without warning
701 return put_user(0, (char *)arg
);
707 return n_tty_ioctl(tty
, file
, cmd
, arg
);
711 * Handle an open charLpEvent. Could be either interrupt or ack
713 static void vioHandleOpenEvent(struct HvLpEvent
*event
)
716 struct viocharlpevent
*cevent
= (struct viocharlpevent
*)event
;
717 u8 port
= cevent
->virtual_device
;
718 struct port_info
*pi
;
721 if (hvlpevent_is_ack(event
)) {
722 if (port
>= VTTY_PORTS
)
725 spin_lock_irqsave(&consolelock
, flags
);
726 /* Got the lock, don't cause console output */
728 pi
= &port_info
[port
];
729 if (event
->xRc
== HvLpEvent_Rc_Good
) {
730 pi
->seq
= pi
->ack
= 0;
732 * This line allows connections from the primary
733 * partition but once one is connected from the
734 * primary partition nothing short of a reboot
735 * of linux will allow access from the hosting
736 * partition again without a required iSeries fix.
738 pi
->lp
= event
->xTargetLp
;
741 spin_unlock_irqrestore(&consolelock
, flags
);
742 if (event
->xRc
!= HvLpEvent_Rc_Good
)
743 printk(VIOCONS_KERN_WARN
744 "handle_open_event: event->xRc == (%d).\n",
747 if (event
->xCorrelationToken
!= 0) {
748 atomic_t
*aptr
= (atomic_t
*)event
->xCorrelationToken
;
751 printk(VIOCONS_KERN_WARN
752 "weird...got open ack without atomic\n");
756 /* This had better require an ack, otherwise complain */
757 if (!hvlpevent_need_ack(event
)) {
758 printk(VIOCONS_KERN_WARN
"viocharopen without ack bit!\n");
762 spin_lock_irqsave(&consolelock
, flags
);
763 /* Got the lock, don't cause console output */
765 /* Make sure this is a good virtual tty */
766 if (port
>= VTTY_PORTS
) {
767 event
->xRc
= HvLpEvent_Rc_SubtypeError
;
768 cevent
->subtype_result_code
= viorc_openRejected
;
770 * Flag state here since we can't printk while holding
775 pi
= &port_info
[port
];
776 if ((pi
->lp
!= HvLpIndexInvalid
) &&
777 (pi
->lp
!= event
->xSourceLp
)) {
779 * If this is tty is already connected to a different
782 event
->xRc
= HvLpEvent_Rc_SubtypeError
;
783 cevent
->subtype_result_code
= viorc_openRejected
;
786 pi
->lp
= event
->xSourceLp
;
787 event
->xRc
= HvLpEvent_Rc_Good
;
788 cevent
->subtype_result_code
= viorc_good
;
789 pi
->seq
= pi
->ack
= 0;
794 spin_unlock_irqrestore(&consolelock
, flags
);
797 printk(VIOCONS_KERN_WARN
"open rejected: bad virtual tty.\n");
798 else if (reject
== 2)
799 printk(VIOCONS_KERN_WARN
800 "open rejected: console in exclusive use by another partition.\n");
802 /* Return the acknowledgement */
803 HvCallEvent_ackLpEvent(event
);
807 * Handle a close charLpEvent. This should ONLY be an Interrupt because the
808 * virtual console should never actually issue a close event to the hypervisor
809 * because the virtual console never goes away. A close event coming from the
810 * hypervisor simply means that there are no client consoles connected to the
813 * Regardless of the number of connections masqueraded on the other side of
814 * the hypervisor ONLY ONE close event should be called to accompany the ONE
815 * open event that is called. The close event should ONLY be called when NO
816 * MORE connections (masqueraded or not) exist on the other side of the
819 static void vioHandleCloseEvent(struct HvLpEvent
*event
)
822 struct viocharlpevent
*cevent
= (struct viocharlpevent
*)event
;
823 u8 port
= cevent
->virtual_device
;
825 if (hvlpevent_is_int(event
)) {
826 if (port
>= VTTY_PORTS
) {
827 printk(VIOCONS_KERN_WARN
828 "close message from invalid virtual device.\n");
832 /* For closes, just mark the console partition invalid */
833 spin_lock_irqsave(&consolelock
, flags
);
834 /* Got the lock, don't cause console output */
836 if (port_info
[port
].lp
== event
->xSourceLp
)
837 port_info
[port
].lp
= HvLpIndexInvalid
;
839 spin_unlock_irqrestore(&consolelock
, flags
);
840 printk(VIOCONS_KERN_INFO
"close from %d\n", event
->xSourceLp
);
842 printk(VIOCONS_KERN_WARN
843 "got unexpected close acknowlegement\n");
847 * Handle a config charLpEvent. Could be either interrupt or ack
849 static void vioHandleConfig(struct HvLpEvent
*event
)
851 struct viocharlpevent
*cevent
= (struct viocharlpevent
*)event
;
853 HvCall_writeLogBuffer(cevent
->data
, cevent
->len
);
855 if (cevent
->data
[0] == 0x01)
856 printk(VIOCONS_KERN_INFO
"window resized to %d: %d: %d: %d\n",
857 cevent
->data
[1], cevent
->data
[2],
858 cevent
->data
[3], cevent
->data
[4]);
860 printk(VIOCONS_KERN_WARN
"unknown config event\n");
864 * Handle a data charLpEvent.
866 static void vioHandleData(struct HvLpEvent
*event
)
868 struct tty_struct
*tty
;
870 struct viocharlpevent
*cevent
= (struct viocharlpevent
*)event
;
871 struct port_info
*pi
;
874 u8 port
= cevent
->virtual_device
;
876 if (port
>= VTTY_PORTS
) {
877 printk(VIOCONS_KERN_WARN
"data on invalid virtual device %d\n",
883 * Hold the spinlock so that we don't take an interrupt that
884 * changes tty between the time we fetch the port_info
885 * pointer and the time we paranoia check.
887 spin_lock_irqsave(&consolelock
, flags
);
888 pi
= &port_info
[port
];
891 * Change 05/01/2003 - Ryan Arnold: If a partition other than
892 * the current exclusive partition tries to send us data
893 * events then just drop them on the floor because we don't
894 * want his stinking data. He isn't authorized to receive
895 * data because he wasn't the first one to get the console,
896 * therefore he shouldn't be allowed to send data either.
897 * This will work without an iSeries fix.
899 if (pi
->lp
!= event
->xSourceLp
) {
900 spin_unlock_irqrestore(&consolelock
, flags
);
906 spin_unlock_irqrestore(&consolelock
, flags
);
907 printk(VIOCONS_KERN_WARN
"no tty for virtual device %d\n",
912 if (tty
->magic
!= TTY_MAGIC
) {
913 spin_unlock_irqrestore(&consolelock
, flags
);
914 printk(VIOCONS_KERN_WARN
"tty bad magic\n");
919 * Just to be paranoid, make sure the tty points back to this port
921 pi
= (struct port_info
*)tty
->driver_data
;
922 if (!pi
|| viotty_paranoia_check(pi
, tty
->name
, "vioHandleData")) {
923 spin_unlock_irqrestore(&consolelock
, flags
);
926 spin_unlock_irqrestore(&consolelock
, flags
);
929 * Change 07/21/2003 - Ryan Arnold: functionality added to
930 * support sysrq utilizing ^O as the sysrq key. The sysrq
931 * functionality will only work if built into the kernel and
932 * then only if sysrq is enabled through the proc filesystem.
935 for (index
= 0; index
< cevent
->len
; index
++) {
937 * Will be optimized away if !CONFIG_MAGIC_SYSRQ:
940 /* 0x0f is the ascii character for ^O */
941 if (cevent
->data
[index
] == '\x0f') {
942 vio_sysrq_pressed
= 1;
944 * continue because we don't want to add
945 * the sysrq key into the data string.
948 } else if (vio_sysrq_pressed
) {
949 handle_sysrq(cevent
->data
[index
], tty
);
950 vio_sysrq_pressed
= 0;
952 * continue because we don't want to add
953 * the sysrq sequence into the data string.
959 * The sysrq sequence isn't included in this check if
960 * sysrq is enabled and compiled into the kernel because
961 * the sequence will never get inserted into the buffer.
962 * Don't attempt to copy more data into the buffer than we
963 * have room for because it would fail without indication.
965 if(tty_insert_flip_char(tty
, cevent
->data
[index
], TTY_NORMAL
) == 0) {
966 printk(VIOCONS_KERN_WARN
"input buffer overflow!\n");
973 tty_flip_buffer_push(tty
);
977 * Handle an ack charLpEvent.
979 static void vioHandleAck(struct HvLpEvent
*event
)
981 struct viocharlpevent
*cevent
= (struct viocharlpevent
*)event
;
983 u8 port
= cevent
->virtual_device
;
985 if (port
>= VTTY_PORTS
) {
986 printk(VIOCONS_KERN_WARN
"data on invalid virtual device\n");
990 spin_lock_irqsave(&consolelock
, flags
);
991 port_info
[port
].ack
= event
->xCorrelationToken
;
992 spin_unlock_irqrestore(&consolelock
, flags
);
994 if (port_info
[port
].used
)
995 send_buffers(&port_info
[port
]);
999 * Handle charLpEvents and route to the appropriate routine
1001 static void vioHandleCharEvent(struct HvLpEvent
*event
)
1008 charminor
= event
->xSubtype
& VIOMINOR_SUBTYPE_MASK
;
1009 switch (charminor
) {
1011 vioHandleOpenEvent(event
);
1014 vioHandleCloseEvent(event
);
1017 vioHandleData(event
);
1020 vioHandleAck(event
);
1023 vioHandleConfig(event
);
1026 if (hvlpevent_is_int(event
) && hvlpevent_need_ack(event
)) {
1027 event
->xRc
= HvLpEvent_Rc_InvalidSubtype
;
1028 HvCallEvent_ackLpEvent(event
);
1034 * Send an open event
1036 static int send_open(HvLpIndex remoteLp
, void *sem
)
1038 return HvCallEvent_signalLpEventFast(remoteLp
,
1039 HvLpEvent_Type_VirtualIo
,
1040 viomajorsubtype_chario
| viocharopen
,
1041 HvLpEvent_AckInd_DoAck
, HvLpEvent_AckType_ImmediateAck
,
1042 viopath_sourceinst(remoteLp
),
1043 viopath_targetinst(remoteLp
),
1044 (u64
)(unsigned long)sem
, VIOVERSION
<< 16,
1048 static const struct tty_operations serial_ops
= {
1049 .open
= viotty_open
,
1050 .close
= viotty_close
,
1051 .write
= viotty_write
,
1052 .put_char
= viotty_put_char
,
1053 .write_room
= viotty_write_room
,
1054 .chars_in_buffer
= viotty_chars_in_buffer
,
1055 .ioctl
= viotty_ioctl
,
1058 static int __init
viocons_init2(void)
1064 rc
= viopath_open(HvLpConfig_getPrimaryLpIndex(),
1065 viomajorsubtype_chario
, VIOCHAR_WINDOW
+ 2);
1067 printk(VIOCONS_KERN_WARN
"error opening to primary %d\n", rc
);
1069 if (viopath_hostLp
== HvLpIndexInvalid
)
1073 * And if the primary is not the same as the hosting LP, open to the
1076 if ((viopath_hostLp
!= HvLpIndexInvalid
) &&
1077 (viopath_hostLp
!= HvLpConfig_getPrimaryLpIndex())) {
1078 printk(VIOCONS_KERN_INFO
"open path to hosting (%d)\n",
1080 rc
= viopath_open(viopath_hostLp
, viomajorsubtype_chario
,
1081 VIOCHAR_WINDOW
+ 2); /* +2 for fudge */
1083 printk(VIOCONS_KERN_WARN
1084 "error opening to partition %d: %d\n",
1085 viopath_hostLp
, rc
);
1088 if (vio_setHandler(viomajorsubtype_chario
, vioHandleCharEvent
) < 0)
1089 printk(VIOCONS_KERN_WARN
1090 "error seting handler for console events!\n");
1093 * First, try to open the console to the hosting lp.
1094 * Wait on a semaphore for the response.
1096 atomic_set(&wait_flag
, 0);
1097 if ((viopath_isactive(viopath_hostLp
)) &&
1098 (send_open(viopath_hostLp
, (void *)&wait_flag
) == 0)) {
1099 printk(VIOCONS_KERN_INFO
"hosting partition %d\n",
1101 while (atomic_read(&wait_flag
) == 0)
1103 atomic_set(&wait_flag
, 0);
1107 * If we don't have an active console, try the primary
1109 if ((!viopath_isactive(port_info
[0].lp
)) &&
1110 (viopath_isactive(HvLpConfig_getPrimaryLpIndex())) &&
1111 (send_open(HvLpConfig_getPrimaryLpIndex(), (void *)&wait_flag
)
1113 printk(VIOCONS_KERN_INFO
"opening console to primary partition\n");
1114 while (atomic_read(&wait_flag
) == 0)
1118 /* Initialize the tty_driver structure */
1119 viotty_driver
= alloc_tty_driver(VTTY_PORTS
);
1120 viotty_driver
->owner
= THIS_MODULE
;
1121 viotty_driver
->driver_name
= "vioconsole";
1122 viotty_driver
->name
= "tty";
1123 viotty_driver
->name_base
= 1;
1124 viotty_driver
->major
= TTY_MAJOR
;
1125 viotty_driver
->minor_start
= 1;
1126 viotty_driver
->type
= TTY_DRIVER_TYPE_CONSOLE
;
1127 viotty_driver
->subtype
= 1;
1128 viotty_driver
->init_termios
= tty_std_termios
;
1129 viotty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_RESET_TERMIOS
;
1130 tty_set_operations(viotty_driver
, &serial_ops
);
1132 if (tty_register_driver(viotty_driver
)) {
1133 printk(VIOCONS_KERN_WARN
"couldn't register console driver\n");
1134 put_tty_driver(viotty_driver
);
1135 viotty_driver
= NULL
;
1138 unregister_console(&viocons_early
);
1139 register_console(&viocons
);
1144 static int __init
viocons_init(void)
1148 printk(VIOCONS_KERN_INFO
"registering console\n");
1149 for (i
= 0; i
< VTTY_PORTS
; i
++) {
1150 port_info
[i
].lp
= HvLpIndexInvalid
;
1151 port_info
[i
].magic
= VIOTTY_MAGIC
;
1153 HvCall_setLogBufferFormatAndCodepage(HvCall_LogBuffer_ASCII
, 437);
1154 add_preferred_console("viocons", 0, NULL
);
1155 register_console(&viocons_early
);
1159 console_initcall(viocons_init
);
1160 module_init(viocons_init2
);