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