arch/ia64/hp/sim/simserial.c

   1 /*
   2  * Simulated Serial Driver (fake serial)
   3  *
   4  * This driver is mostly used for bringup purposes and will go away.
   5  * It has a strong dependency on the system console. All outputs
   6  * are rerouted to the same facility as the one used by printk which, in our
   7  * case means sys_sim.c console (goes via the simulator). The code hereafter
   8  * is completely leveraged from the serial.c driver.
   9  *
  10  * Copyright (C) 1999-2000, 2002-2003 Hewlett-Packard Co
  11  *      Stephane Eranian <eranian@hpl.hp.com>
  12  *      David Mosberger-Tang <davidm@hpl.hp.com>
  13  *
  14  * 02/04/00 D. Mosberger        Merged in serial.c bug fixes in rs_close().
  15  * 02/25/00 D. Mosberger        Synced up with 2.3.99pre-5 version of serial.c.
  16  * 07/30/02 D. Mosberger        Replace sti()/cli() with explicit spinlocks & local irq masking
  17  */
  18
  19 #include <linux/config.h>
  20 #include <linux/init.h>
  21 #include <linux/errno.h>
  22 #include <linux/sched.h>
  23 #include <linux/tty.h>
  24 #include <linux/tty_flip.h>
  25 #include <linux/major.h>
  26 #include <linux/fcntl.h>
  27 #include <linux/mm.h>
  28 #include <linux/slab.h>
  29 #include <linux/capability.h>
  30 #include <linux/console.h>
  31 #include <linux/module.h>
  32 #include <linux/serial.h>
  33 #include <linux/serialP.h>
  34 #include <linux/sysrq.h>
  35
  36 #include <asm/irq.h>
  37 #include <asm/hw_irq.h>
  38 #include <asm/uaccess.h>
  39
  40 #ifdef CONFIG_KDB
  41 # include <linux/kdb.h>
  42 #endif
  43
  44 #undef SIMSERIAL_DEBUG  /* define this to get some debug information */
  45
  46 #define KEYBOARD_INTR   3       /* must match with simulator! */
  47
  48 #define NR_PORTS        1       /* only one port for now */
  49
  50 #define IRQ_T(info) ((info->flags & ASYNC_SHARE_IRQ) ? SA_SHIRQ : SA_INTERRUPT)
  51
  52 #define SSC_GETCHAR     21
  53
  54 extern long ia64_ssc (long, long, long, long, int);
  55 extern void ia64_ssc_connect_irq (long intr, long irq);
  56
  57 static char *serial_name = "SimSerial driver";
  58 static char *serial_version = "0.6";
  59
  60 /*
  61  * This has been extracted from asm/serial.h. We need one eventually but
  62  * I don't know exactly what we're going to put in it so just fake one
  63  * for now.
  64  */
  65 #define BASE_BAUD ( 1843200 / 16 )
  66
  67 #define STD_COM_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST)
  68
  69 /*
  70  * Most of the values here are meaningless to this particular driver.
  71  * However some values must be preserved for the code (leveraged from serial.c
  72  * to work correctly).
  73  * port must not be 0
  74  * type must not be UNKNOWN
  75  * So I picked arbitrary (guess from where?) values instead
  76  */
  77 static struct serial_state rs_table[NR_PORTS]={
  78   /* UART CLK   PORT IRQ     FLAGS        */
  79   { 0, BASE_BAUD, 0x3F8, 0, STD_COM_FLAGS,0,PORT_16550 }  /* ttyS0 */
  80 };
  81
  82 /*
  83  * Just for the fun of it !
  84  */
  85 static struct serial_uart_config uart_config[] = {
  86         { "unknown", 1, 0 },
  87         { "8250", 1, 0 },
  88         { "16450", 1, 0 },
  89         { "16550", 1, 0 },
  90         { "16550A", 16, UART_CLEAR_FIFO | UART_USE_FIFO },
  91         { "cirrus", 1, 0 },
  92         { "ST16650", 1, UART_CLEAR_FIFO | UART_STARTECH },
  93         { "ST16650V2", 32, UART_CLEAR_FIFO | UART_USE_FIFO |
  94                   UART_STARTECH },
  95         { "TI16750", 64, UART_CLEAR_FIFO | UART_USE_FIFO},
  96         { 0, 0}
  97 };
  98
  99 struct tty_driver *hp_simserial_driver;
 100
 101 static struct async_struct *IRQ_ports[NR_IRQS];
 102
 103 static struct console *console;
 104
 105 static unsigned char *tmp_buf;
 106
 107 extern struct console *console_drivers; /* from kernel/printk.c */
 108
 109 /*
 110  * ------------------------------------------------------------
 111  * rs_stop() and rs_start()
 112  *
 113  * This routines are called before setting or resetting tty->stopped.
 114  * They enable or disable transmitter interrupts, as necessary.
 115  * ------------------------------------------------------------
 116  */
 117 static void rs_stop(struct tty_struct *tty)
 118 {
 119 #ifdef SIMSERIAL_DEBUG
 120         printk("rs_stop: tty->stopped=%d tty->hw_stopped=%d tty->flow_stopped=%d\n",
 121                 tty->stopped, tty->hw_stopped, tty->flow_stopped);
 122 #endif
 123
 124 }
 125
 126 static void rs_start(struct tty_struct *tty)
 127 {
 128 #ifdef SIMSERIAL_DEBUG
 129         printk("rs_start: tty->stopped=%d tty->hw_stopped=%d tty->flow_stopped=%d\n",
 130                 tty->stopped, tty->hw_stopped, tty->flow_stopped);
 131 #endif
 132 }
 133
 134 static  void receive_chars(struct tty_struct *tty, struct pt_regs *regs)
 135 {
 136         unsigned char ch;
 137         static unsigned char seen_esc = 0;
 138
 139         while ( (ch = ia64_ssc(0, 0, 0, 0, SSC_GETCHAR)) ) {
 140                 if ( ch == 27 && seen_esc == 0 ) {
 141                         seen_esc = 1;
 142                         continue;
 143                 } else {
 144                         if ( seen_esc==1 && ch == 'O' ) {
 145                                 seen_esc = 2;
 146                                 continue;
 147                         } else if ( seen_esc == 2 ) {
 148                                 if ( ch == 'P' ) /* F1 */
 149                                         show_state();
 150 #ifdef CONFIG_MAGIC_SYSRQ
 151                                 if ( ch == 'S' ) { /* F4 */
 152                                         do
 153                                                 ch = ia64_ssc(0, 0, 0, 0,
 154                                                               SSC_GETCHAR);
 155                                         while (!ch);
 156                                         handle_sysrq(ch, regs, NULL);
 157                                 }
 158 #endif
 159                                 seen_esc = 0;
 160                                 continue;
 161                         }
 162                 }
 163                 seen_esc = 0;
 164
 165                 if (tty_insert_flip_char(tty, ch, TTY_NORMAL) == 0)
 166                         break;
 167         }
 168         tty_flip_buffer_push(tty);
 169 }
 170
 171 /*
 172  * This is the serial driver's interrupt routine for a single port
 173  */
 174 static irqreturn_t rs_interrupt_single(int irq, void *dev_id, struct pt_regs * regs)
 175 {
 176         struct async_struct * info;
 177
 178         /*
 179          * I don't know exactly why they don't use the dev_id opaque data
 180          * pointer instead of this extra lookup table
 181          */
 182         info = IRQ_ports[irq];
 183         if (!info || !info->tty) {
 184                 printk(KERN_INFO "simrs_interrupt_single: info|tty=0 info=%p problem\n", info);
 185                 return IRQ_NONE;
 186         }
 187         /*
 188          * pretty simple in our case, because we only get interrupts
 189          * on inbound traffic
 190          */
 191         receive_chars(info->tty, regs);
 192         return IRQ_HANDLED;
 193 }
 194
 195 /*
 196  * -------------------------------------------------------------------
 197  * Here ends the serial interrupt routines.
 198  * -------------------------------------------------------------------
 199  */
 200
 201 #if 0
 202 /*
 203  * not really used in our situation so keep them commented out for now
 204  */
 205 static DECLARE_TASK_QUEUE(tq_serial); /* used to be at the top of the file */
 206 static void do_serial_bh(void)
 207 {
 208         run_task_queue(&tq_serial);
 209         printk(KERN_ERR "do_serial_bh: called\n");
 210 }
 211 #endif
 212
 213 static void do_softint(void *private_)
 214 {
 215         printk(KERN_ERR "simserial: do_softint called\n");
 216 }
 217
 218 static void rs_put_char(struct tty_struct *tty, unsigned char ch)
 219 {
 220         struct async_struct *info = (struct async_struct *)tty->driver_data;
 221         unsigned long flags;
 222
 223         if (!tty || !info->xmit.buf) return;
 224
 225         local_irq_save(flags);
 226         if (CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE) == 0) {
 227                 local_irq_restore(flags);
 228                 return;
 229         }
 230         info->xmit.buf[info->xmit.head] = ch;
 231         info->xmit.head = (info->xmit.head + 1) & (SERIAL_XMIT_SIZE-1);
 232         local_irq_restore(flags);
 233 }
 234
 235 static void transmit_chars(struct async_struct *info, int *intr_done)
 236 {
 237         int count;
 238         unsigned long flags;
 239
 240
 241         local_irq_save(flags);
 242
 243         if (info->x_char) {
 244                 char c = info->x_char;
 245
 246                 console->write(console, &c, 1);
 247
 248                 info->state->icount.tx++;
 249                 info->x_char = 0;
 250
 251                 goto out;
 252         }
 253
 254         if (info->xmit.head == info->xmit.tail || info->tty->stopped || info->tty->hw_stopped) {
 255 #ifdef SIMSERIAL_DEBUG
 256                 printk("transmit_chars: head=%d, tail=%d, stopped=%d\n",
 257                        info->xmit.head, info->xmit.tail, info->tty->stopped);
 258 #endif
 259                 goto out;
 260         }
 261         /*
 262          * We removed the loop and try to do it in to chunks. We need
 263          * 2 operations maximum because it's a ring buffer.
 264          *
 265          * First from current to tail if possible.
 266          * Then from the beginning of the buffer until necessary
 267          */
 268
 269         count = min(CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE),
 270                     SERIAL_XMIT_SIZE - info->xmit.tail);
 271         console->write(console, info->xmit.buf+info->xmit.tail, count);
 272
 273         info->xmit.tail = (info->xmit.tail+count) & (SERIAL_XMIT_SIZE-1);
 274
 275         /*
 276          * We have more at the beginning of the buffer
 277          */
 278         count = CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
 279         if (count) {
 280                 console->write(console, info->xmit.buf, count);
 281                 info->xmit.tail += count;
 282         }
 283 out:
 284         local_irq_restore(flags);
 285 }
 286
 287 static void rs_flush_chars(struct tty_struct *tty)
 288 {
 289         struct async_struct *info = (struct async_struct *)tty->driver_data;
 290
 291         if (info->xmit.head == info->xmit.tail || tty->stopped || tty->hw_stopped ||
 292             !info->xmit.buf)
 293                 return;
 294
 295         transmit_chars(info, NULL);
 296 }
 297
 298
 299 static int rs_write(struct tty_struct * tty,
 300                     const unsigned char *buf, int count)
 301 {
 302         int     c, ret = 0;
 303         struct async_struct *info = (struct async_struct *)tty->driver_data;
 304         unsigned long flags;
 305
 306         if (!tty || !info->xmit.buf || !tmp_buf) return 0;
 307
 308         local_irq_save(flags);
 309         while (1) {
 310                 c = CIRC_SPACE_TO_END(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
 311                 if (count < c)
 312                         c = count;
 313                 if (c <= 0) {
 314                         break;
 315                 }
 316                 memcpy(info->xmit.buf + info->xmit.head, buf, c);
 317                 info->xmit.head = ((info->xmit.head + c) &
 318                                    (SERIAL_XMIT_SIZE-1));
 319                 buf += c;
 320                 count -= c;
 321                 ret += c;
 322         }
 323         local_irq_restore(flags);
 324         /*
 325          * Hey, we transmit directly from here in our case
 326          */
 327         if (CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE)
 328             && !tty->stopped && !tty->hw_stopped) {
 329                 transmit_chars(info, NULL);
 330         }
 331         return ret;
 332 }
 333
 334 static int rs_write_room(struct tty_struct *tty)
 335 {
 336         struct async_struct *info = (struct async_struct *)tty->driver_data;
 337
 338         return CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
 339 }
 340
 341 static int rs_chars_in_buffer(struct tty_struct *tty)
 342 {
 343         struct async_struct *info = (struct async_struct *)tty->driver_data;
 344
 345         return CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
 346 }
 347
 348 static void rs_flush_buffer(struct tty_struct *tty)
 349 {
 350         struct async_struct *info = (struct async_struct *)tty->driver_data;
 351         unsigned long flags;
 352
 353         local_irq_save(flags);
 354         info->xmit.head = info->xmit.tail = 0;
 355         local_irq_restore(flags);
 356
 357         wake_up_interruptible(&tty->write_wait);
 358
 359         if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
 360             tty->ldisc.write_wakeup)
 361                 (tty->ldisc.write_wakeup)(tty);
 362 }
 363
 364 /*
 365  * This function is used to send a high-priority XON/XOFF character to
 366  * the device
 367  */
 368 static void rs_send_xchar(struct tty_struct *tty, char ch)
 369 {
 370         struct async_struct *info = (struct async_struct *)tty->driver_data;
 371
 372         info->x_char = ch;
 373         if (ch) {
 374                 /*
 375                  * I guess we could call console->write() directly but
 376                  * let's do that for now.
 377                  */
 378                 transmit_chars(info, NULL);
 379         }
 380 }
 381
 382 /*
 383  * ------------------------------------------------------------
 384  * rs_throttle()
 385  *
 386  * This routine is called by the upper-layer tty layer to signal that
 387  * incoming characters should be throttled.
 388  * ------------------------------------------------------------
 389  */
 390 static void rs_throttle(struct tty_struct * tty)
 391 {
 392         if (I_IXOFF(tty)) rs_send_xchar(tty, STOP_CHAR(tty));
 393
 394         printk(KERN_INFO "simrs_throttle called\n");
 395 }
 396
 397 static void rs_unthrottle(struct tty_struct * tty)
 398 {
 399         struct async_struct *info = (struct async_struct *)tty->driver_data;
 400
 401         if (I_IXOFF(tty)) {
 402                 if (info->x_char)
 403                         info->x_char = 0;
 404                 else
 405                         rs_send_xchar(tty, START_CHAR(tty));
 406         }
 407         printk(KERN_INFO "simrs_unthrottle called\n");
 408 }
 409
 410 /*
 411  * rs_break() --- routine which turns the break handling on or off
 412  */
 413 static void rs_break(struct tty_struct *tty, int break_state)
 414 {
 415 }
 416
 417 static int rs_ioctl(struct tty_struct *tty, struct file * file,
 418                     unsigned int cmd, unsigned long arg)
 419 {
 420         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
 421             (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) &&
 422             (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
 423                 if (tty->flags & (1 << TTY_IO_ERROR))
 424                     return -EIO;
 425         }
 426
 427         switch (cmd) {
 428                 case TIOCMGET:
 429                         printk(KERN_INFO "rs_ioctl: TIOCMGET called\n");
 430                         return -EINVAL;
 431                 case TIOCMBIS:
 432                 case TIOCMBIC:
 433                 case TIOCMSET:
 434                         printk(KERN_INFO "rs_ioctl: TIOCMBIS/BIC/SET called\n");
 435                         return -EINVAL;
 436                 case TIOCGSERIAL:
 437                         printk(KERN_INFO "simrs_ioctl TIOCGSERIAL called\n");
 438                         return 0;
 439                 case TIOCSSERIAL:
 440                         printk(KERN_INFO "simrs_ioctl TIOCSSERIAL called\n");
 441                         return 0;
 442                 case TIOCSERCONFIG:
 443                         printk(KERN_INFO "rs_ioctl: TIOCSERCONFIG called\n");
 444                         return -EINVAL;
 445
 446                 case TIOCSERGETLSR: /* Get line status register */
 447                         printk(KERN_INFO "rs_ioctl: TIOCSERGETLSR called\n");
 448                         return  -EINVAL;
 449
 450                 case TIOCSERGSTRUCT:
 451                         printk(KERN_INFO "rs_ioctl: TIOCSERGSTRUCT called\n");
 452 #if 0
 453                         if (copy_to_user((struct async_struct *) arg,
 454                                          info, sizeof(struct async_struct)))
 455                                 return -EFAULT;
 456 #endif
 457                         return 0;
 458
 459                 /*
 460                  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
 461                  * - mask passed in arg for lines of interest
 462                  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
 463                  * Caller should use TIOCGICOUNT to see which one it was
 464                  */
 465                 case TIOCMIWAIT:
 466                         printk(KERN_INFO "rs_ioctl: TIOCMIWAIT: called\n");
 467                         return 0;
 468                 /*
 469                  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
 470                  * Return: write counters to the user passed counter struct
 471                  * NB: both 1->0 and 0->1 transitions are counted except for
 472                  *     RI where only 0->1 is counted.
 473                  */
 474                 case TIOCGICOUNT:
 475                         printk(KERN_INFO "rs_ioctl: TIOCGICOUNT called\n");
 476                         return 0;
 477
 478                 case TIOCSERGWILD:
 479                 case TIOCSERSWILD:
 480                         /* "setserial -W" is called in Debian boot */
 481                         printk (KERN_INFO "TIOCSER?WILD ioctl obsolete, ignored.\n");
 482                         return 0;
 483
 484                 default:
 485                         return -ENOIOCTLCMD;
 486                 }
 487         return 0;
 488 }
 489
 490 #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
 491
 492 static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
 493 {
 494         unsigned int cflag = tty->termios->c_cflag;
 495
 496         if (   (cflag == old_termios->c_cflag)
 497             && (   RELEVANT_IFLAG(tty->termios->c_iflag)
 498                 == RELEVANT_IFLAG(old_termios->c_iflag)))
 499           return;
 500
 501
 502         /* Handle turning off CRTSCTS */
 503         if ((old_termios->c_cflag & CRTSCTS) &&
 504             !(tty->termios->c_cflag & CRTSCTS)) {
 505                 tty->hw_stopped = 0;
 506                 rs_start(tty);
 507         }
 508 }
 509 /*
 510  * This routine will shutdown a serial port; interrupts are disabled, and
 511  * DTR is dropped if the hangup on close termio flag is on.
 512  */
 513 static void shutdown(struct async_struct * info)
 514 {
 515         unsigned long   flags;
 516         struct serial_state *state;
 517         int             retval;
 518
 519         if (!(info->flags & ASYNC_INITIALIZED)) return;
 520
 521         state = info->state;
 522
 523 #ifdef SIMSERIAL_DEBUG
 524         printk("Shutting down serial port %d (irq %d)....", info->line,
 525                state->irq);
 526 #endif
 527
 528         local_irq_save(flags);
 529         {
 530                 /*
 531                  * First unlink the serial port from the IRQ chain...
 532                  */
 533                 if (info->next_port)
 534                         info->next_port->prev_port = info->prev_port;
 535                 if (info->prev_port)
 536                         info->prev_port->next_port = info->next_port;
 537                 else
 538                         IRQ_ports[state->irq] = info->next_port;
 539
 540                 /*
 541                  * Free the IRQ, if necessary
 542                  */
 543                 if (state->irq && (!IRQ_ports[state->irq] ||
 544                                    !IRQ_ports[state->irq]->next_port)) {
 545                         if (IRQ_ports[state->irq]) {
 546                                 free_irq(state->irq, NULL);
 547                                 retval = request_irq(state->irq, rs_interrupt_single,
 548                                                      IRQ_T(info), "serial", NULL);
 549
 550                                 if (retval)
 551                                         printk(KERN_ERR "serial shutdown: request_irq: error %d"
 552                                                "  Couldn't reacquire IRQ.\n", retval);
 553                         } else
 554                                 free_irq(state->irq, NULL);
 555                 }
 556
 557                 if (info->xmit.buf) {
 558                         free_page((unsigned long) info->xmit.buf);
 559                         info->xmit.buf = 0;
 560                 }
 561
 562                 if (info->tty) set_bit(TTY_IO_ERROR, &info->tty->flags);
 563
 564                 info->flags &= ~ASYNC_INITIALIZED;
 565         }
 566         local_irq_restore(flags);
 567 }
 568
 569 /*
 570  * ------------------------------------------------------------
 571  * rs_close()
 572  *
 573  * This routine is called when the serial port gets closed.  First, we
 574  * wait for the last remaining data to be sent.  Then, we unlink its
 575  * async structure from the interrupt chain if necessary, and we free
 576  * that IRQ if nothing is left in the chain.
 577  * ------------------------------------------------------------
 578  */
 579 static void rs_close(struct tty_struct *tty, struct file * filp)
 580 {
 581         struct async_struct * info = (struct async_struct *)tty->driver_data;
 582         struct serial_state *state;
 583         unsigned long flags;
 584
 585         if (!info ) return;
 586
 587         state = info->state;
 588
 589         local_irq_save(flags);
 590         if (tty_hung_up_p(filp)) {
 591 #ifdef SIMSERIAL_DEBUG
 592                 printk("rs_close: hung_up\n");
 593 #endif
 594                 local_irq_restore(flags);
 595                 return;
 596         }
 597 #ifdef SIMSERIAL_DEBUG
 598         printk("rs_close ttys%d, count = %d\n", info->line, state->count);
 599 #endif
 600         if ((tty->count == 1) && (state->count != 1)) {
 601                 /*
 602                  * Uh, oh.  tty->count is 1, which means that the tty
 603                  * structure will be freed.  state->count should always
 604                  * be one in these conditions.  If it's greater than
 605                  * one, we've got real problems, since it means the
 606                  * serial port won't be shutdown.
 607                  */
 608                 printk(KERN_ERR "rs_close: bad serial port count; tty->count is 1, "
 609                        "state->count is %d\n", state->count);
 610                 state->count = 1;
 611         }
 612         if (--state->count < 0) {
 613                 printk(KERN_ERR "rs_close: bad serial port count for ttys%d: %d\n",
 614                        info->line, state->count);
 615                 state->count = 0;
 616         }
 617         if (state->count) {
 618                 local_irq_restore(flags);
 619                 return;
 620         }
 621         info->flags |= ASYNC_CLOSING;
 622         local_irq_restore(flags);
 623
 624         /*
 625          * Now we wait for the transmit buffer to clear; and we notify
 626          * the line discipline to only process XON/XOFF characters.
 627          */
 628         shutdown(info);
 629         if (tty->driver->flush_buffer) tty->driver->flush_buffer(tty);
 630         if (tty->ldisc.flush_buffer) tty->ldisc.flush_buffer(tty);
 631         info->event = 0;
 632         info->tty = 0;
 633         if (info->blocked_open) {
 634                 if (info->close_delay)
 635                         schedule_timeout_interruptible(info->close_delay);
 636                 wake_up_interruptible(&info->open_wait);
 637         }
 638         info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
 639         wake_up_interruptible(&info->close_wait);
 640 }
 641
 642 /*
 643  * rs_wait_until_sent() --- wait until the transmitter is empty
 644  */
 645 static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
 646 {
 647 }
 648
 649
 650 /*
 651  * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
 652  */
 653 static void rs_hangup(struct tty_struct *tty)
 654 {
 655         struct async_struct * info = (struct async_struct *)tty->driver_data;
 656         struct serial_state *state = info->state;
 657
 658 #ifdef SIMSERIAL_DEBUG
 659         printk("rs_hangup: called\n");
 660 #endif
 661
 662         state = info->state;
 663
 664         rs_flush_buffer(tty);
 665         if (info->flags & ASYNC_CLOSING)
 666                 return;
 667         shutdown(info);
 668
 669         info->event = 0;
 670         state->count = 0;
 671         info->flags &= ~ASYNC_NORMAL_ACTIVE;
 672         info->tty = 0;
 673         wake_up_interruptible(&info->open_wait);
 674 }
 675
 676
 677 static int get_async_struct(int line, struct async_struct **ret_info)
 678 {
 679         struct async_struct *info;
 680         struct serial_state *sstate;
 681
 682         sstate = rs_table + line;
 683         sstate->count++;
 684         if (sstate->info) {
 685                 *ret_info = sstate->info;
 686                 return 0;
 687         }
 688         info = kmalloc(sizeof(struct async_struct), GFP_KERNEL);
 689         if (!info) {
 690                 sstate->count--;
 691                 return -ENOMEM;
 692         }
 693         memset(info, 0, sizeof(struct async_struct));
 694         init_waitqueue_head(&info->open_wait);
 695         init_waitqueue_head(&info->close_wait);
 696         init_waitqueue_head(&info->delta_msr_wait);
 697         info->magic = SERIAL_MAGIC;
 698         info->port = sstate->port;
 699         info->flags = sstate->flags;
 700         info->xmit_fifo_size = sstate->xmit_fifo_size;
 701         info->line = line;
 702         INIT_WORK(&info->work, do_softint, info);
 703         info->state = sstate;
 704         if (sstate->info) {
 705                 kfree(info);
 706                 *ret_info = sstate->info;
 707                 return 0;
 708         }
 709         *ret_info = sstate->info = info;
 710         return 0;
 711 }
 712
 713 static int
 714 startup(struct async_struct *info)
 715 {
 716         unsigned long flags;
 717         int     retval=0;
 718         irqreturn_t (*handler)(int, void *, struct pt_regs *);
 719         struct serial_state *state= info->state;
 720         unsigned long page;
 721
 722         page = get_zeroed_page(GFP_KERNEL);
 723         if (!page)
 724                 return -ENOMEM;
 725
 726         local_irq_save(flags);
 727
 728         if (info->flags & ASYNC_INITIALIZED) {
 729                 free_page(page);
 730                 goto errout;
 731         }
 732
 733         if (!state->port || !state->type) {
 734                 if (info->tty) set_bit(TTY_IO_ERROR, &info->tty->flags);
 735                 free_page(page);
 736                 goto errout;
 737         }
 738         if (info->xmit.buf)
 739                 free_page(page);
 740         else
 741                 info->xmit.buf = (unsigned char *) page;
 742
 743 #ifdef SIMSERIAL_DEBUG
 744         printk("startup: ttys%d (irq %d)...", info->line, state->irq);
 745 #endif
 746
 747         /*
 748          * Allocate the IRQ if necessary
 749          */
 750         if (state->irq && (!IRQ_ports[state->irq] ||
 751                           !IRQ_ports[state->irq]->next_port)) {
 752                 if (IRQ_ports[state->irq]) {
 753                         retval = -EBUSY;
 754                         goto errout;
 755                 } else
 756                         handler = rs_interrupt_single;
 757
 758                 retval = request_irq(state->irq, handler, IRQ_T(info), "simserial", NULL);
 759                 if (retval) {
 760                         if (capable(CAP_SYS_ADMIN)) {
 761                                 if (info->tty)
 762                                         set_bit(TTY_IO_ERROR,
 763                                                 &info->tty->flags);
 764                                 retval = 0;
 765                         }
 766                         goto errout;
 767                 }
 768         }
 769
 770         /*
 771          * Insert serial port into IRQ chain.
 772          */
 773         info->prev_port = 0;
 774         info->next_port = IRQ_ports[state->irq];
 775         if (info->next_port)
 776                 info->next_port->prev_port = info;
 777         IRQ_ports[state->irq] = info;
 778
 779         if (info->tty) clear_bit(TTY_IO_ERROR, &info->tty->flags);
 780
 781         info->xmit.head = info->xmit.tail = 0;
 782
 783 #if 0
 784         /*
 785          * Set up serial timers...
 786          */
 787         timer_table[RS_TIMER].expires = jiffies + 2*HZ/100;
 788         timer_active |= 1 << RS_TIMER;
 789 #endif
 790
 791         /*
 792          * Set up the tty->alt_speed kludge
 793          */
 794         if (info->tty) {
 795                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
 796                         info->tty->alt_speed = 57600;
 797                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
 798                         info->tty->alt_speed = 115200;
 799                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
 800                         info->tty->alt_speed = 230400;
 801                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
 802                         info->tty->alt_speed = 460800;
 803         }
 804
 805         info->flags |= ASYNC_INITIALIZED;
 806         local_irq_restore(flags);
 807         return 0;
 808
 809 errout:
 810         local_irq_restore(flags);
 811         return retval;
 812 }
 813
 814
 815 /*
 816  * This routine is called whenever a serial port is opened.  It
 817  * enables interrupts for a serial port, linking in its async structure into
 818  * the IRQ chain.   It also performs the serial-specific
 819  * initialization for the tty structure.
 820  */
 821 static int rs_open(struct tty_struct *tty, struct file * filp)
 822 {
 823         struct async_struct     *info;
 824         int                     retval, line;
 825         unsigned long           page;
 826
 827         line = tty->index;
 828         if ((line < 0) || (line >= NR_PORTS))
 829                 return -ENODEV;
 830         retval = get_async_struct(line, &info);
 831         if (retval)
 832                 return retval;
 833         tty->driver_data = info;
 834         info->tty = tty;
 835
 836 #ifdef SIMSERIAL_DEBUG
 837         printk("rs_open %s, count = %d\n", tty->name, info->state->count);
 838 #endif
 839         info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 840
 841         if (!tmp_buf) {
 842                 page = get_zeroed_page(GFP_KERNEL);
 843                 if (!page)
 844                         return -ENOMEM;
 845                 if (tmp_buf)
 846                         free_page(page);
 847                 else
 848                         tmp_buf = (unsigned char *) page;
 849         }
 850
 851         /*
 852          * If the port is the middle of closing, bail out now
 853          */
 854         if (tty_hung_up_p(filp) ||
 855             (info->flags & ASYNC_CLOSING)) {
 856                 if (info->flags & ASYNC_CLOSING)
 857                         interruptible_sleep_on(&info->close_wait);
 858 #ifdef SERIAL_DO_RESTART
 859                 return ((info->flags & ASYNC_HUP_NOTIFY) ?
 860                         -EAGAIN : -ERESTARTSYS);
 861 #else
 862                 return -EAGAIN;
 863 #endif
 864         }
 865
 866         /*
 867          * Start up serial port
 868          */
 869         retval = startup(info);
 870         if (retval) {
 871                 return retval;
 872         }
 873
 874         /*
 875          * figure out which console to use (should be one already)
 876          */
 877         console = console_drivers;
 878         while (console) {
 879                 if ((console->flags & CON_ENABLED) && console->write) break;
 880                 console = console->next;
 881         }
 882
 883 #ifdef SIMSERIAL_DEBUG
 884         printk("rs_open ttys%d successful\n", info->line);
 885 #endif
 886         return 0;
 887 }
 888
 889 /*
 890  * /proc fs routines....
 891  */
 892
 893 static inline int line_info(char *buf, struct serial_state *state)
 894 {
 895         return sprintf(buf, "%d: uart:%s port:%lX irq:%d\n",
 896                        state->line, uart_config[state->type].name,
 897                        state->port, state->irq);
 898 }
 899
 900 static int rs_read_proc(char *page, char **start, off_t off, int count,
 901                  int *eof, void *data)
 902 {
 903         int i, len = 0, l;
 904         off_t   begin = 0;
 905
 906         len += sprintf(page, "simserinfo:1.0 driver:%s\n", serial_version);
 907         for (i = 0; i < NR_PORTS && len < 4000; i++) {
 908                 l = line_info(page + len, &rs_table[i]);
 909                 len += l;
 910                 if (len+begin > off+count)
 911                         goto done;
 912                 if (len+begin < off) {
 913                         begin += len;
 914                         len = 0;
 915                 }
 916         }
 917         *eof = 1;
 918 done:
 919         if (off >= len+begin)
 920                 return 0;
 921         *start = page + (begin-off);
 922         return ((count < begin+len-off) ? count : begin+len-off);
 923 }
 924
 925 /*
 926  * ---------------------------------------------------------------------
 927  * rs_init() and friends
 928  *
 929  * rs_init() is called at boot-time to initialize the serial driver.
 930  * ---------------------------------------------------------------------
 931  */
 932
 933 /*
 934  * This routine prints out the appropriate serial driver version
 935  * number, and identifies which options were configured into this
 936  * driver.
 937  */
 938 static inline void show_serial_version(void)
 939 {
 940         printk(KERN_INFO "%s version %s with", serial_name, serial_version);
 941         printk(KERN_INFO " no serial options enabled\n");
 942 }
 943
 944 static struct tty_operations hp_ops = {
 945         .open = rs_open,
 946         .close = rs_close,
 947         .write = rs_write,
 948         .put_char = rs_put_char,
 949         .flush_chars = rs_flush_chars,
 950         .write_room = rs_write_room,
 951         .chars_in_buffer = rs_chars_in_buffer,
 952         .flush_buffer = rs_flush_buffer,
 953         .ioctl = rs_ioctl,
 954         .throttle = rs_throttle,
 955         .unthrottle = rs_unthrottle,
 956         .send_xchar = rs_send_xchar,
 957         .set_termios = rs_set_termios,
 958         .stop = rs_stop,
 959         .start = rs_start,
 960         .hangup = rs_hangup,
 961         .break_ctl = rs_break,
 962         .wait_until_sent = rs_wait_until_sent,
 963         .read_proc = rs_read_proc,
 964 };
 965
 966 /*
 967  * The serial driver boot-time initialization code!
 968  */
 969 static int __init
 970 simrs_init (void)
 971 {
 972         int                     i, rc;
 973         struct serial_state     *state;
 974
 975         if (!ia64_platform_is("hpsim"))
 976                 return -ENODEV;
 977
 978         hp_simserial_driver = alloc_tty_driver(1);
 979         if (!hp_simserial_driver)
 980                 return -ENOMEM;
 981
 982         show_serial_version();
 983
 984         /* Initialize the tty_driver structure */
 985
 986         hp_simserial_driver->owner = THIS_MODULE;
 987         hp_simserial_driver->driver_name = "simserial";
 988         hp_simserial_driver->name = "ttyS";
 989         hp_simserial_driver->major = TTY_MAJOR;
 990         hp_simserial_driver->minor_start = 64;
 991         hp_simserial_driver->type = TTY_DRIVER_TYPE_SERIAL;
 992         hp_simserial_driver->subtype = SERIAL_TYPE_NORMAL;
 993         hp_simserial_driver->init_termios = tty_std_termios;
 994         hp_simserial_driver->init_termios.c_cflag =
 995                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
 996         hp_simserial_driver->flags = TTY_DRIVER_REAL_RAW;
 997         tty_set_operations(hp_simserial_driver, &hp_ops);
 998
 999         /*
1000          * Let's have a little bit of fun !
1001          */
1002         for (i = 0, state = rs_table; i < NR_PORTS; i++,state++) {
1003
1004                 if (state->type == PORT_UNKNOWN) continue;
1005
1006                 if (!state->irq) {
1007                         if ((rc = assign_irq_vector(AUTO_ASSIGN)) < 0)
1008                                 panic("%s: out of interrupt vectors!\n",
1009                                       __FUNCTION__);
1010                         state->irq = rc;
1011                         ia64_ssc_connect_irq(KEYBOARD_INTR, state->irq);
1012                 }
1013
1014                 printk(KERN_INFO "ttyS%d at 0x%04lx (irq = %d) is a %s\n",
1015                        state->line,
1016                        state->port, state->irq,
1017                        uart_config[state->type].name);
1018         }
1019
1020         if (tty_register_driver(hp_simserial_driver))
1021                 panic("Couldn't register simserial driver\n");
1022
1023         return 0;
1024 }
1025
1026 #ifndef MODULE
1027 __initcall(simrs_init);
1028 #endif