libata: Grand renaming.
[linux-2.6.git] / drivers / char / viocons.c
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>
44
45 #include <asm/iseries/vio.h>
46
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>
51
52 #ifdef CONFIG_VT
53 #error You must turn off CONFIG_VT to use CONFIG_VIOCONS
54 #endif
55
56 #define VIOTTY_MAGIC (0x0DCB)
57 #define VTTY_PORTS 10
58
59 #define VIOCONS_KERN_WARN       KERN_WARNING "viocons: "
60 #define VIOCONS_KERN_INFO       KERN_INFO "viocons: "
61
62 static DEFINE_SPINLOCK(consolelock);
63 static DEFINE_SPINLOCK(consoleloglock);
64
65 #ifdef CONFIG_MAGIC_SYSRQ
66 static int vio_sysrq_pressed;
67 extern int sysrq_enabled;
68 #endif
69
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 };
83
84 #define VIOCHAR_WINDOW          10
85 #define VIOCHAR_HIGHWATERMARK   3
86
87 enum viocharsubtype {
88         viocharopen = 0x0001,
89         viocharclose = 0x0002,
90         viochardata = 0x0003,
91         viocharack = 0x0004,
92         viocharconfig = 0x0005
93 };
94
95 enum viochar_rc {
96         viochar_rc_ebusy = 1
97 };
98
99 #define VIOCHAR_NUM_BUF         16
100
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];
125
126 #define viochar_is_console(pi)  ((pi) == &port_info[0])
127 #define viochar_port(pi)        ((pi) - &port_info[0])
128
129 static void initDataEvent(struct viocharlpevent *viochar, HvLpIndex lp);
130
131 static struct tty_driver *viotty_driver;
132
133 static void hvlog(char *fmt, ...)
134 {
135         int i;
136         unsigned long flags;
137         va_list args;
138         static char buf[256];
139
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 }
148
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';
155
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 }
174
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";
186
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 }
197
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;
210
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                 }
225
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);
231
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                 }
244
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];
250
251                 /* Copy the data into the buffer. */
252                 memcpy(pi->buffer[pi->curbuf] + pi->bufferBytes[pi->curbuf],
253                                 curbuf, curlen);
254
255                 pi->bufferBytes[pi->curbuf] += curlen;
256                 curbuf += curlen;
257                 bleft -= curlen;
258
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 }
276
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;
289
290         spin_lock_irqsave(&consolelock, flags);
291
292         viochar = (struct viocharlpevent *)
293             vio_get_event_buffer(viomajorsubtype_chario);
294
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         }
301
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         }
308
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;
314
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;
320
321         initDataEvent(viochar, pi->lp);
322
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;
333
334                 memcpy(viochar->data, pi->buffer[nextbuf], viochar->len);
335
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);
343
344                         printk(VIOCONS_KERN_WARN
345                                "error sending event! return code %d\n",
346                                (int)hvrc);
347                         return;
348                 }
349
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         }
358
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;
365
366                 if (pi->overflowMessage)
367                         pi->overflowMessage = 0;
368
369                 if (pi->tty) {
370                         tty_wakeup(pi->tty);
371                 }
372         }
373
374         vio_free_event_buffer(viomajorsubtype_chario, viochar);
375         spin_unlock_irqrestore(&consolelock, flags);
376 }
377
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;
394
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);
406
407         spin_lock_irqsave(&consolelock, flags);
408
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);
416
417         curbuf = buf;
418         bleft = len;
419
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;
426
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;
432
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         }
441
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 }
450
451 static struct port_info *get_port_data(struct tty_struct *tty)
452 {
453         unsigned long flags;
454         struct port_info *pi;
455
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 }
472
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;
479
480         memset(viochar, 0, sizeof(struct viocharlpevent));
481
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 }
492
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 }
500
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;
509
510         static const char cr = '\r';
511
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         }
521
522         hvlogOutput(s, count);
523
524         if (!viopath_isactive(pi->lp))
525                 return;
526
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         }
544
545         /* If any characters left to write, write them now */
546         if ((index - begin) > 0)
547                 internal_write(pi, &s[begin], index - begin);
548 }
549
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 }
558
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 };
568
569 static struct console viocons = {
570         .name = "viocons",
571         .write = viocons_write,
572         .device = viocons_device,
573         .flags = CON_PRINTBUFFER,
574         .index = -1,
575 };
576
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;
585
586         port = tty->index;
587
588         if ((port < 0) || (port >= VTTY_PORTS))
589                 return -ENODEV;
590
591         spin_lock_irqsave(&consolelock, flags);
592
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);
604
605         return 0;
606 }
607
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;
615
616         spin_lock_irqsave(&consolelock, flags);
617         pi = (struct port_info *)tty->driver_data;
618
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 }
627
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;
635
636         pi = get_port_data(tty);
637         if (pi == NULL) {
638                 hvlog("\n\rviotty_write: no port data.");
639                 return -ENODEV;
640         }
641
642         if (viochar_is_console(pi))
643                 hvlogOutput(buf, count);
644
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;
656
657         return internal_write(pi, buf, count);
658 }
659
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;
666
667         pi = get_port_data(tty);
668         if (pi == NULL)
669                 return;
670
671         /* This will append '\r' as well if the char is '\n' */
672         if (viochar_is_console(pi))
673                 hvlogOutput(&ch, 1);
674
675         if (viopath_isactive(pi->lp))
676                 internal_write(pi, &ch, 1);
677 }
678
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;
688
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         }
695
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         }
701
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);
710
711         if (room > VIOCHAR_MAX_DATA)
712                 room = VIOCHAR_MAX_DATA;
713         return room;
714 }
715
716 /*
717  * TTY chars_in_buffer method
718  */
719 static int viotty_chars_in_buffer(struct tty_struct *tty)
720 {
721         return 0;
722 }
723
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);
735
736         case KDSKBLED:
737                 return 0;
738         }
739
740         return n_tty_ioctl(tty, file, cmd, arg);
741 }
742
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;
753
754         if (hvlpevent_is_ack(event)) {
755                 if (port >= VTTY_PORTS)
756                         return;
757
758                 spin_lock_irqsave(&consolelock, flags);
759                 /* Got the lock, don't cause console output */
760
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                 }
773
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);
779
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         }
788
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         }
794
795         spin_lock_irqsave(&consolelock, flags);
796         /* Got the lock, don't cause console output */
797
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         }
826
827         spin_unlock_irqrestore(&consolelock, flags);
828
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");
834
835         /* Return the acknowledgement */
836         HvCallEvent_ackLpEvent(event);
837 }
838
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;
857
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                 }
864
865                 /* For closes, just mark the console partition invalid */
866                 spin_lock_irqsave(&consolelock, flags);
867                 /* Got the lock, don't cause console output */
868
869                 if (port_info[port].lp == event->xSourceLp)
870                         port_info[port].lp = HvLpIndexInvalid;
871
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 }
878
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;
885
886         HvCall_writeLogBuffer(cevent->data, cevent->len);
887
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 }
895
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;
908
909         if (port >= VTTY_PORTS) {
910                 printk(VIOCONS_KERN_WARN "data on invalid virtual device %d\n",
911                                 port);
912                 return;
913         }
914
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];
922
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         }
936
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         }
944
945         if (tty->magic != TTY_MAGIC) {
946                 spin_unlock_irqrestore(&consolelock, flags);
947                 printk(VIOCONS_KERN_WARN "tty bad magic\n");
948                 return;
949         }
950
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);
960
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;
1000                 }
1001                 num_pushed++;
1002         }
1003
1004         if (num_pushed)
1005                 tty_flip_buffer_push(tty);
1006 }
1007
1008 /*
1009  * Handle an ack charLpEvent. 
1010  */
1011 static void vioHandleAck(struct HvLpEvent *event)
1012 {
1013         struct viocharlpevent *cevent = (struct viocharlpevent *)event;
1014         unsigned long flags;
1015         u8 port = cevent->virtual_device;
1016
1017         if (port >= VTTY_PORTS) {
1018                 printk(VIOCONS_KERN_WARN "data on invalid virtual device\n");
1019                 return;
1020         }
1021
1022         spin_lock_irqsave(&consolelock, flags);
1023         port_info[port].ack = event->xCorrelationToken;
1024         spin_unlock_irqrestore(&consolelock, flags);
1025
1026         if (port_info[port].used)
1027                 send_buffers(&port_info[port]);
1028 }
1029
1030 /*
1031  * Handle charLpEvents and route to the appropriate routine
1032  */
1033 static void vioHandleCharEvent(struct HvLpEvent *event)
1034 {
1035         int charminor;
1036
1037         if (event == NULL)
1038                 return;
1039
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);
1061                 }
1062         }
1063 }
1064
1065 /*
1066  * Send an open event
1067  */
1068 static int send_open(HvLpIndex remoteLp, void *sem)
1069 {
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);
1078 }
1079
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 };
1089
1090 static int __init viocons_init2(void)
1091 {
1092         atomic_t wait_flag;
1093         int rc;
1094
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);
1100
1101         if (viopath_hostLp == HvLpIndexInvalid)
1102                 vio_set_hostlp();
1103
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);
1118         }
1119
1120         if (vio_setHandler(viomajorsubtype_chario, vioHandleCharEvent) < 0)
1121                 printk(VIOCONS_KERN_WARN
1122                                 "error seting handler for console events!\n");
1123
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);
1136         }
1137
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();
1148         }
1149
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);
1163
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;
1168         }
1169
1170         unregister_console(&viocons_early);
1171         register_console(&viocons);
1172
1173         return 0;
1174 }
1175
1176 static int __init viocons_init(void)
1177 {
1178         int i;
1179
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;
1184         }
1185         HvCall_setLogBufferFormatAndCodepage(HvCall_LogBuffer_ASCII, 437);
1186         register_console(&viocons_early);
1187         return 0;
1188 }
1189
1190 console_initcall(viocons_init);
1191 module_init(viocons_init2);