drivers/tty/serial/sn_console.c

   1 /*
   2  * C-Brick Serial Port (and console) driver for SGI Altix machines.
   3  *
   4  * This driver is NOT suitable for talking to the l1-controller for
   5  * anything other than 'console activities' --- please use the l1
   6  * driver for that.
   7  *
   8  *
   9  * Copyright (c) 2004-2006 Silicon Graphics, Inc.  All Rights Reserved.
  10  *
  11  * Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,
  12  * Mountain View, CA  94043, or:
  13  *
  14  * http://www.sgi.com
  15  *
  16  * For further information regarding this notice, see:
  17  *
  18  * http://oss.sgi.com/projects/GenInfo/NoticeExplan
  19  */
  20
  21 #include <linux/interrupt.h>
  22 #include <linux/tty.h>
  23 #include <linux/tty_flip.h>
  24 #include <linux/serial.h>
  25 #include <linux/console.h>
  26 #include <linux/init.h>
  27 #include <linux/sysrq.h>
  28 #include <linux/circ_buf.h>
  29 #include <linux/serial_reg.h>
  30 #include <linux/delay.h> /* for mdelay */
  31 #include <linux/miscdevice.h>
  32 #include <linux/serial_core.h>
  33
  34 #include <asm/io.h>
  35 #include <asm/sn/simulator.h>
  36 #include <asm/sn/sn_sal.h>
  37
  38 /* number of characters we can transmit to the SAL console at a time */
  39 #define SN_SAL_MAX_CHARS 120
  40
  41 /* 64K, when we're asynch, it must be at least printk's LOG_BUF_LEN to
  42  * avoid losing chars, (always has to be a power of 2) */
  43 #define SN_SAL_BUFFER_SIZE (64 * (1 << 10))
  44
  45 #define SN_SAL_UART_FIFO_DEPTH 16
  46 #define SN_SAL_UART_FIFO_SPEED_CPS (9600/10)
  47
  48 /* sn_transmit_chars() calling args */
  49 #define TRANSMIT_BUFFERED       0
  50 #define TRANSMIT_RAW            1
  51
  52 /* To use dynamic numbers only and not use the assigned major and minor,
  53  * define the following.. */
  54                                   /* #define USE_DYNAMIC_MINOR 1 *//* use dynamic minor number */
  55 #define USE_DYNAMIC_MINOR 0     /* Don't rely on misc_register dynamic minor */
  56
  57 /* Device name we're using */
  58 #define DEVICE_NAME "ttySG"
  59 #define DEVICE_NAME_DYNAMIC "ttySG0"    /* need full name for misc_register */
  60 /* The major/minor we are using, ignored for USE_DYNAMIC_MINOR */
  61 #define DEVICE_MAJOR 204
  62 #define DEVICE_MINOR 40
  63
  64 #ifdef CONFIG_MAGIC_SYSRQ
  65 static char sysrq_serial_str[] = "\eSYS";
  66 static char *sysrq_serial_ptr = sysrq_serial_str;
  67 static unsigned long sysrq_requested;
  68 #endif /* CONFIG_MAGIC_SYSRQ */
  69
  70 /*
  71  * Port definition - this kinda drives it all
  72  */
  73 struct sn_cons_port {
  74         struct timer_list sc_timer;
  75         struct uart_port sc_port;
  76         struct sn_sal_ops {
  77                 int (*sal_puts_raw) (const char *s, int len);
  78                 int (*sal_puts) (const char *s, int len);
  79                 int (*sal_getc) (void);
  80                 int (*sal_input_pending) (void);
  81                 void (*sal_wakeup_transmit) (struct sn_cons_port *, int);
  82         } *sc_ops;
  83         unsigned long sc_interrupt_timeout;
  84         int sc_is_asynch;
  85 };
  86
  87 static struct sn_cons_port sal_console_port;
  88 static int sn_process_input;
  89
  90 /* Only used if USE_DYNAMIC_MINOR is set to 1 */
  91 static struct miscdevice misc;  /* used with misc_register for dynamic */
  92
  93 extern void early_sn_setup(void);
  94
  95 #undef DEBUG
  96 #ifdef DEBUG
  97 static int sn_debug_printf(const char *fmt, ...);
  98 #define DPRINTF(x...) sn_debug_printf(x)
  99 #else
 100 #define DPRINTF(x...) do { } while (0)
 101 #endif
 102
 103 /* Prototypes */
 104 static int snt_hw_puts_raw(const char *, int);
 105 static int snt_hw_puts_buffered(const char *, int);
 106 static int snt_poll_getc(void);
 107 static int snt_poll_input_pending(void);
 108 static int snt_intr_getc(void);
 109 static int snt_intr_input_pending(void);
 110 static void sn_transmit_chars(struct sn_cons_port *, int);
 111
 112 /* A table for polling:
 113  */
 114 static struct sn_sal_ops poll_ops = {
 115         .sal_puts_raw = snt_hw_puts_raw,
 116         .sal_puts = snt_hw_puts_raw,
 117         .sal_getc = snt_poll_getc,
 118         .sal_input_pending = snt_poll_input_pending
 119 };
 120
 121 /* A table for interrupts enabled */
 122 static struct sn_sal_ops intr_ops = {
 123         .sal_puts_raw = snt_hw_puts_raw,
 124         .sal_puts = snt_hw_puts_buffered,
 125         .sal_getc = snt_intr_getc,
 126         .sal_input_pending = snt_intr_input_pending,
 127         .sal_wakeup_transmit = sn_transmit_chars
 128 };
 129
 130 /* the console does output in two distinctly different ways:
 131  * synchronous (raw) and asynchronous (buffered).  initially, early_printk
 132  * does synchronous output.  any data written goes directly to the SAL
 133  * to be output (incidentally, it is internally buffered by the SAL)
 134  * after interrupts and timers are initialized and available for use,
 135  * the console init code switches to asynchronous output.  this is
 136  * also the earliest opportunity to begin polling for console input.
 137  * after console initialization, console output and tty (serial port)
 138  * output is buffered and sent to the SAL asynchronously (either by
 139  * timer callback or by UART interrupt) */
 140
 141 /* routines for running the console in polling mode */
 142
 143 /**
 144  * snt_poll_getc - Get a character from the console in polling mode
 145  *
 146  */
 147 static int snt_poll_getc(void)
 148 {
 149         int ch;
 150
 151         ia64_sn_console_getc(&ch);
 152         return ch;
 153 }
 154
 155 /**
 156  * snt_poll_input_pending - Check if any input is waiting - polling mode.
 157  *
 158  */
 159 static int snt_poll_input_pending(void)
 160 {
 161         int status, input;
 162
 163         status = ia64_sn_console_check(&input);
 164         return !status && input;
 165 }
 166
 167 /* routines for an interrupt driven console (normal) */
 168
 169 /**
 170  * snt_intr_getc - Get a character from the console, interrupt mode
 171  *
 172  */
 173 static int snt_intr_getc(void)
 174 {
 175         return ia64_sn_console_readc();
 176 }
 177
 178 /**
 179  * snt_intr_input_pending - Check if input is pending, interrupt mode
 180  *
 181  */
 182 static int snt_intr_input_pending(void)
 183 {
 184         return ia64_sn_console_intr_status() & SAL_CONSOLE_INTR_RECV;
 185 }
 186
 187 /* these functions are polled and interrupt */
 188
 189 /**
 190  * snt_hw_puts_raw - Send raw string to the console, polled or interrupt mode
 191  * @s: String
 192  * @len: Length
 193  *
 194  */
 195 static int snt_hw_puts_raw(const char *s, int len)
 196 {
 197         /* this will call the PROM and not return until this is done */
 198         return ia64_sn_console_putb(s, len);
 199 }
 200
 201 /**
 202  * snt_hw_puts_buffered - Send string to console, polled or interrupt mode
 203  * @s: String
 204  * @len: Length
 205  *
 206  */
 207 static int snt_hw_puts_buffered(const char *s, int len)
 208 {
 209         /* queue data to the PROM */
 210         return ia64_sn_console_xmit_chars((char *)s, len);
 211 }
 212
 213 /* uart interface structs
 214  * These functions are associated with the uart_port that the serial core
 215  * infrastructure calls.
 216  *
 217  * Note: Due to how the console works, many routines are no-ops.
 218  */
 219
 220 /**
 221  * snp_type - What type of console are we?
 222  * @port: Port to operate with (we ignore since we only have one port)
 223  *
 224  */
 225 static const char *snp_type(struct uart_port *port)
 226 {
 227         return ("SGI SN L1");
 228 }
 229
 230 /**
 231  * snp_tx_empty - Is the transmitter empty?  We pretend we're always empty
 232  * @port: Port to operate on (we ignore since we only have one port)
 233  *
 234  */
 235 static unsigned int snp_tx_empty(struct uart_port *port)
 236 {
 237         return 1;
 238 }
 239
 240 /**
 241  * snp_stop_tx - stop the transmitter - no-op for us
 242  * @port: Port to operat eon - we ignore - no-op function
 243  *
 244  */
 245 static void snp_stop_tx(struct uart_port *port)
 246 {
 247 }
 248
 249 /**
 250  * snp_release_port - Free i/o and resources for port - no-op for us
 251  * @port: Port to operate on - we ignore - no-op function
 252  *
 253  */
 254 static void snp_release_port(struct uart_port *port)
 255 {
 256 }
 257
 258 /**
 259  * snp_shutdown - shut down the port - free irq and disable - no-op for us
 260  * @port: Port to shut down - we ignore
 261  *
 262  */
 263 static void snp_shutdown(struct uart_port *port)
 264 {
 265 }
 266
 267 /**
 268  * snp_set_mctrl - set control lines (dtr, rts, etc) - no-op for our console
 269  * @port: Port to operate on - we ignore
 270  * @mctrl: Lines to set/unset - we ignore
 271  *
 272  */
 273 static void snp_set_mctrl(struct uart_port *port, unsigned int mctrl)
 274 {
 275 }
 276
 277 /**
 278  * snp_get_mctrl - get contorl line info, we just return a static value
 279  * @port: port to operate on - we only have one port so we ignore this
 280  *
 281  */
 282 static unsigned int snp_get_mctrl(struct uart_port *port)
 283 {
 284         return TIOCM_CAR | TIOCM_RNG | TIOCM_DSR | TIOCM_CTS;
 285 }
 286
 287 /**
 288  * snp_stop_rx - Stop the receiver - we ignor ethis
 289  * @port: Port to operate on - we ignore
 290  *
 291  */
 292 static void snp_stop_rx(struct uart_port *port)
 293 {
 294 }
 295
 296 /**
 297  * snp_start_tx - Start transmitter
 298  * @port: Port to operate on
 299  *
 300  */
 301 static void snp_start_tx(struct uart_port *port)
 302 {
 303         if (sal_console_port.sc_ops->sal_wakeup_transmit)
 304                 sal_console_port.sc_ops->sal_wakeup_transmit(&sal_console_port,
 305                                                              TRANSMIT_BUFFERED);
 306
 307 }
 308
 309 /**
 310  * snp_break_ctl - handle breaks - ignored by us
 311  * @port: Port to operate on
 312  * @break_state: Break state
 313  *
 314  */
 315 static void snp_break_ctl(struct uart_port *port, int break_state)
 316 {
 317 }
 318
 319 /**
 320  * snp_startup - Start up the serial port - always return 0 (We're always on)
 321  * @port: Port to operate on
 322  *
 323  */
 324 static int snp_startup(struct uart_port *port)
 325 {
 326         return 0;
 327 }
 328
 329 /**
 330  * snp_set_termios - set termios stuff - we ignore these
 331  * @port: port to operate on
 332  * @termios: New settings
 333  * @termios: Old
 334  *
 335  */
 336 static void
 337 snp_set_termios(struct uart_port *port, struct ktermios *termios,
 338                 struct ktermios *old)
 339 {
 340 }
 341
 342 /**
 343  * snp_request_port - allocate resources for port - ignored by us
 344  * @port: port to operate on
 345  *
 346  */
 347 static int snp_request_port(struct uart_port *port)
 348 {
 349         return 0;
 350 }
 351
 352 /**
 353  * snp_config_port - allocate resources, set up - we ignore,  we're always on
 354  * @port: Port to operate on
 355  * @flags: flags used for port setup
 356  *
 357  */
 358 static void snp_config_port(struct uart_port *port, int flags)
 359 {
 360 }
 361
 362 /* Associate the uart functions above - given to serial core */
 363
 364 static const struct uart_ops sn_console_ops = {
 365         .tx_empty = snp_tx_empty,
 366         .set_mctrl = snp_set_mctrl,
 367         .get_mctrl = snp_get_mctrl,
 368         .stop_tx = snp_stop_tx,
 369         .start_tx = snp_start_tx,
 370         .stop_rx = snp_stop_rx,
 371         .break_ctl = snp_break_ctl,
 372         .startup = snp_startup,
 373         .shutdown = snp_shutdown,
 374         .set_termios = snp_set_termios,
 375         .pm = NULL,
 376         .type = snp_type,
 377         .release_port = snp_release_port,
 378         .request_port = snp_request_port,
 379         .config_port = snp_config_port,
 380         .verify_port = NULL,
 381 };
 382
 383 /* End of uart struct functions and defines */
 384
 385 #ifdef DEBUG
 386
 387 /**
 388  * sn_debug_printf - close to hardware debugging printf
 389  * @fmt: printf format
 390  *
 391  * This is as "close to the metal" as we can get, used when the driver
 392  * itself may be broken.
 393  *
 394  */
 395 static int sn_debug_printf(const char *fmt, ...)
 396 {
 397         static char printk_buf[1024];
 398         int printed_len;
 399         va_list args;
 400
 401         va_start(args, fmt);
 402         printed_len = vsnprintf(printk_buf, sizeof(printk_buf), fmt, args);
 403
 404         if (!sal_console_port.sc_ops) {
 405                 sal_console_port.sc_ops = &poll_ops;
 406                 early_sn_setup();
 407         }
 408         sal_console_port.sc_ops->sal_puts_raw(printk_buf, printed_len);
 409
 410         va_end(args);
 411         return printed_len;
 412 }
 413 #endif                          /* DEBUG */
 414
 415 /*
 416  * Interrupt handling routines.
 417  */
 418
 419 /**
 420  * sn_receive_chars - Grab characters, pass them to tty layer
 421  * @port: Port to operate on
 422  * @flags: irq flags
 423  *
 424  * Note: If we're not registered with the serial core infrastructure yet,
 425  * we don't try to send characters to it...
 426  *
 427  */
 428 static void
 429 sn_receive_chars(struct sn_cons_port *port, unsigned long flags)
 430 {
 431         struct tty_port *tport = NULL;
 432         int ch;
 433
 434         if (!port) {
 435                 printk(KERN_ERR "sn_receive_chars - port NULL so can't receive\n");
 436                 return;
 437         }
 438
 439         if (!port->sc_ops) {
 440                 printk(KERN_ERR "sn_receive_chars - port->sc_ops  NULL so can't receive\n");
 441                 return;
 442         }
 443
 444         if (port->sc_port.state) {
 445                 /* The serial_core stuffs are initialized, use them */
 446                 tport = &port->sc_port.state->port;
 447         }
 448
 449         while (port->sc_ops->sal_input_pending()) {
 450                 ch = port->sc_ops->sal_getc();
 451                 if (ch < 0) {
 452                         printk(KERN_ERR "sn_console: An error occurred while "
 453                                "obtaining data from the console (0x%0x)\n", ch);
 454                         break;
 455                 }
 456 #ifdef CONFIG_MAGIC_SYSRQ
 457                 if (sysrq_requested) {
 458                         unsigned long sysrq_timeout = sysrq_requested + HZ*5;
 459
 460                         sysrq_requested = 0;
 461                         if (ch && time_before(jiffies, sysrq_timeout)) {
 462                                 spin_unlock_irqrestore(&port->sc_port.lock, flags);
 463                                 handle_sysrq(ch);
 464                                 spin_lock_irqsave(&port->sc_port.lock, flags);
 465                                 /* ignore actual sysrq command char */
 466                                 continue;
 467                         }
 468                 }
 469                 if (ch == *sysrq_serial_ptr) {
 470                         if (!(*++sysrq_serial_ptr)) {
 471                                 sysrq_requested = jiffies;
 472                                 sysrq_serial_ptr = sysrq_serial_str;
 473                         }
 474                         /*
 475                          * ignore the whole sysrq string except for the
 476                          * leading escape
 477                          */
 478                         if (ch != '\e')
 479                                 continue;
 480                 }
 481                 else
 482                         sysrq_serial_ptr = sysrq_serial_str;
 483 #endif /* CONFIG_MAGIC_SYSRQ */
 484
 485                 /* record the character to pass up to the tty layer */
 486                 if (tport) {
 487                         if (tty_insert_flip_char(tport, ch, TTY_NORMAL) == 0)
 488                                 break;
 489                 }
 490                 port->sc_port.icount.rx++;
 491         }
 492
 493         if (tport)
 494                 tty_flip_buffer_push(tport);
 495 }
 496
 497 /**
 498  * sn_transmit_chars - grab characters from serial core, send off
 499  * @port: Port to operate on
 500  * @raw: Transmit raw or buffered
 501  *
 502  * Note: If we're early, before we're registered with serial core, the
 503  * writes are going through sn_sal_console_write because that's how
 504  * register_console has been set up.  We currently could have asynch
 505  * polls calling this function due to sn_sal_switch_to_asynch but we can
 506  * ignore them until we register with the serial core stuffs.
 507  *
 508  */
 509 static void sn_transmit_chars(struct sn_cons_port *port, int raw)
 510 {
 511         int xmit_count, tail, head, loops, ii;
 512         int result;
 513         char *start;
 514         struct circ_buf *xmit;
 515
 516         if (!port)
 517                 return;
 518
 519         BUG_ON(!port->sc_is_asynch);
 520
 521         if (port->sc_port.state) {
 522                 /* We're initialized, using serial core infrastructure */
 523                 xmit = &port->sc_port.state->xmit;
 524         } else {
 525                 /* Probably sn_sal_switch_to_asynch has been run but serial core isn't
 526                  * initialized yet.  Just return.  Writes are going through
 527                  * sn_sal_console_write (due to register_console) at this time.
 528                  */
 529                 return;
 530         }
 531
 532         if (uart_circ_empty(xmit) || uart_tx_stopped(&port->sc_port)) {
 533                 /* Nothing to do. */
 534                 ia64_sn_console_intr_disable(SAL_CONSOLE_INTR_XMIT);
 535                 return;
 536         }
 537
 538         head = xmit->head;
 539         tail = xmit->tail;
 540         start = &xmit->buf[tail];
 541
 542         /* twice around gets the tail to the end of the buffer and
 543          * then to the head, if needed */
 544         loops = (head < tail) ? 2 : 1;
 545
 546         for (ii = 0; ii < loops; ii++) {
 547                 xmit_count = (head < tail) ?
 548                     (UART_XMIT_SIZE - tail) : (head - tail);
 549
 550                 if (xmit_count > 0) {
 551                         if (raw == TRANSMIT_RAW)
 552                                 result =
 553                                     port->sc_ops->sal_puts_raw(start,
 554                                                                xmit_count);
 555                         else
 556                                 result =
 557                                     port->sc_ops->sal_puts(start, xmit_count);
 558 #ifdef DEBUG
 559                         if (!result)
 560                                 DPRINTF("`");
 561 #endif
 562                         if (result > 0) {
 563                                 xmit_count -= result;
 564                                 port->sc_port.icount.tx += result;
 565                                 tail += result;
 566                                 tail &= UART_XMIT_SIZE - 1;
 567                                 xmit->tail = tail;
 568                                 start = &xmit->buf[tail];
 569                         }
 570                 }
 571         }
 572
 573         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 574                 uart_write_wakeup(&port->sc_port);
 575
 576         if (uart_circ_empty(xmit))
 577                 snp_stop_tx(&port->sc_port);    /* no-op for us */
 578 }
 579
 580 /**
 581  * sn_sal_interrupt - Handle console interrupts
 582  * @irq: irq #, useful for debug statements
 583  * @dev_id: our pointer to our port (sn_cons_port which contains the uart port)
 584  *
 585  */
 586 static irqreturn_t sn_sal_interrupt(int irq, void *dev_id)
 587 {
 588         struct sn_cons_port *port = (struct sn_cons_port *)dev_id;
 589         unsigned long flags;
 590         int status = ia64_sn_console_intr_status();
 591
 592         if (!port)
 593                 return IRQ_NONE;
 594
 595         spin_lock_irqsave(&port->sc_port.lock, flags);
 596         if (status & SAL_CONSOLE_INTR_RECV) {
 597                 sn_receive_chars(port, flags);
 598         }
 599         if (status & SAL_CONSOLE_INTR_XMIT) {
 600                 sn_transmit_chars(port, TRANSMIT_BUFFERED);
 601         }
 602         spin_unlock_irqrestore(&port->sc_port.lock, flags);
 603         return IRQ_HANDLED;
 604 }
 605
 606 /**
 607  * sn_sal_timer_poll - this function handles polled console mode
 608  * @data: A pointer to our sn_cons_port (which contains the uart port)
 609  *
 610  * data is the pointer that init_timer will store for us.  This function is
 611  * associated with init_timer to see if there is any console traffic.
 612  * Obviously not used in interrupt mode
 613  *
 614  */
 615 static void sn_sal_timer_poll(struct timer_list *t)
 616 {
 617         struct sn_cons_port *port = from_timer(port, t, sc_timer);
 618         unsigned long flags;
 619
 620         if (!port)
 621                 return;
 622
 623         if (!port->sc_port.irq) {
 624                 spin_lock_irqsave(&port->sc_port.lock, flags);
 625                 if (sn_process_input)
 626                         sn_receive_chars(port, flags);
 627                 sn_transmit_chars(port, TRANSMIT_RAW);
 628                 spin_unlock_irqrestore(&port->sc_port.lock, flags);
 629                 mod_timer(&port->sc_timer,
 630                           jiffies + port->sc_interrupt_timeout);
 631         }
 632 }
 633
 634 /*
 635  * Boot-time initialization code
 636  */
 637
 638 /**
 639  * sn_sal_switch_to_asynch - Switch to async mode (as opposed to synch)
 640  * @port: Our sn_cons_port (which contains the uart port)
 641  *
 642  * So this is used by sn_sal_serial_console_init (early on, before we're
 643  * registered with serial core).  It's also used by sn_sal_init
 644  * right after we've registered with serial core.  The later only happens
 645  * if we didn't already come through here via sn_sal_serial_console_init.
 646  *
 647  */
 648 static void __init sn_sal_switch_to_asynch(struct sn_cons_port *port)
 649 {
 650         unsigned long flags;
 651
 652         if (!port)
 653                 return;
 654
 655         DPRINTF("sn_console: about to switch to asynchronous console\n");
 656
 657         /* without early_printk, we may be invoked late enough to race
 658          * with other cpus doing console IO at this point, however
 659          * console interrupts will never be enabled */
 660         spin_lock_irqsave(&port->sc_port.lock, flags);
 661
 662         /* early_printk invocation may have done this for us */
 663         if (!port->sc_ops)
 664                 port->sc_ops = &poll_ops;
 665
 666         /* we can't turn on the console interrupt (as request_irq
 667          * calls kmalloc, which isn't set up yet), so we rely on a
 668          * timer to poll for input and push data from the console
 669          * buffer.
 670          */
 671         timer_setup(&port->sc_timer, sn_sal_timer_poll, 0);
 672
 673         if (IS_RUNNING_ON_SIMULATOR())
 674                 port->sc_interrupt_timeout = 6;
 675         else {
 676                 /* 960cps / 16 char FIFO = 60HZ
 677                  * HZ / (SN_SAL_FIFO_SPEED_CPS / SN_SAL_FIFO_DEPTH) */
 678                 port->sc_interrupt_timeout =
 679                     HZ * SN_SAL_UART_FIFO_DEPTH / SN_SAL_UART_FIFO_SPEED_CPS;
 680         }
 681         mod_timer(&port->sc_timer, jiffies + port->sc_interrupt_timeout);
 682
 683         port->sc_is_asynch = 1;
 684         spin_unlock_irqrestore(&port->sc_port.lock, flags);
 685 }
 686
 687 /**
 688  * sn_sal_switch_to_interrupts - Switch to interrupt driven mode
 689  * @port: Our sn_cons_port (which contains the uart port)
 690  *
 691  * In sn_sal_init, after we're registered with serial core and
 692  * the port is added, this function is called to switch us to interrupt
 693  * mode.  We were previously in asynch/polling mode (using init_timer).
 694  *
 695  * We attempt to switch to interrupt mode here by calling
 696  * request_irq.  If that works out, we enable receive interrupts.
 697  */
 698 static void __init sn_sal_switch_to_interrupts(struct sn_cons_port *port)
 699 {
 700         unsigned long flags;
 701
 702         if (port) {
 703                 DPRINTF("sn_console: switching to interrupt driven console\n");
 704
 705                 if (request_irq(SGI_UART_VECTOR, sn_sal_interrupt,
 706                                 IRQF_SHARED,
 707                                 "SAL console driver", port) >= 0) {
 708                         spin_lock_irqsave(&port->sc_port.lock, flags);
 709                         port->sc_port.irq = SGI_UART_VECTOR;
 710                         port->sc_ops = &intr_ops;
 711                         irq_set_handler(port->sc_port.irq, handle_level_irq);
 712
 713                         /* turn on receive interrupts */
 714                         ia64_sn_console_intr_enable(SAL_CONSOLE_INTR_RECV);
 715                         spin_unlock_irqrestore(&port->sc_port.lock, flags);
 716                 }
 717                 else {
 718                         printk(KERN_INFO
 719                             "sn_console: console proceeding in polled mode\n");
 720                 }
 721         }
 722 }
 723
 724 /*
 725  * Kernel console definitions
 726  */
 727
 728 static void sn_sal_console_write(struct console *, const char *, unsigned);
 729 static int sn_sal_console_setup(struct console *, char *);
 730 static struct uart_driver sal_console_uart;
 731 extern struct tty_driver *uart_console_device(struct console *, int *);
 732
 733 static struct console sal_console = {
 734         .name = DEVICE_NAME,
 735         .write = sn_sal_console_write,
 736         .device = uart_console_device,
 737         .setup = sn_sal_console_setup,
 738         .index = -1,            /* unspecified */
 739         .data = &sal_console_uart,
 740 };
 741
 742 #define SAL_CONSOLE     &sal_console
 743
 744 static struct uart_driver sal_console_uart = {
 745         .owner = THIS_MODULE,
 746         .driver_name = "sn_console",
 747         .dev_name = DEVICE_NAME,
 748         .major = 0,             /* major/minor set at registration time per USE_DYNAMIC_MINOR */
 749         .minor = 0,
 750         .nr = 1,                /* one port */
 751         .cons = SAL_CONSOLE,
 752 };
 753
 754 /**
 755  * sn_sal_init - When the kernel loads us, get us rolling w/ serial core
 756  *
 757  * Before this is called, we've been printing kernel messages in a special
 758  * early mode not making use of the serial core infrastructure.  When our
 759  * driver is loaded for real, we register the driver and port with serial
 760  * core and try to enable interrupt driven mode.
 761  *
 762  */
 763 static int __init sn_sal_init(void)
 764 {
 765         int retval;
 766
 767         if (!ia64_platform_is("sn2"))
 768                 return 0;
 769
 770         printk(KERN_INFO "sn_console: Console driver init\n");
 771
 772         if (USE_DYNAMIC_MINOR == 1) {
 773                 misc.minor = MISC_DYNAMIC_MINOR;
 774                 misc.name = DEVICE_NAME_DYNAMIC;
 775                 retval = misc_register(&misc);
 776                 if (retval != 0) {
 777                         printk(KERN_WARNING "Failed to register console "
 778                                "device using misc_register.\n");
 779                         return -ENODEV;
 780                 }
 781                 sal_console_uart.major = MISC_MAJOR;
 782                 sal_console_uart.minor = misc.minor;
 783         } else {
 784                 sal_console_uart.major = DEVICE_MAJOR;
 785                 sal_console_uart.minor = DEVICE_MINOR;
 786         }
 787
 788         /* We register the driver and the port before switching to interrupts
 789          * or async above so the proper uart structures are populated */
 790
 791         if (uart_register_driver(&sal_console_uart) < 0) {
 792                 printk
 793                     ("ERROR sn_sal_init failed uart_register_driver, line %d\n",
 794                      __LINE__);
 795                 return -ENODEV;
 796         }
 797
 798         spin_lock_init(&sal_console_port.sc_port.lock);
 799
 800         /* Setup the port struct with the minimum needed */
 801         sal_console_port.sc_port.membase = (char *)1;   /* just needs to be non-zero */
 802         sal_console_port.sc_port.type = PORT_16550A;
 803         sal_console_port.sc_port.fifosize = SN_SAL_MAX_CHARS;
 804         sal_console_port.sc_port.ops = &sn_console_ops;
 805         sal_console_port.sc_port.line = 0;
 806
 807         if (uart_add_one_port(&sal_console_uart, &sal_console_port.sc_port) < 0) {
 808                 /* error - not sure what I'd do - so I'll do nothing */
 809                 printk(KERN_ERR "%s: unable to add port\n", __func__);
 810         }
 811
 812         /* when this driver is compiled in, the console initialization
 813          * will have already switched us into asynchronous operation
 814          * before we get here through the initcalls */
 815         if (!sal_console_port.sc_is_asynch) {
 816                 sn_sal_switch_to_asynch(&sal_console_port);
 817         }
 818
 819         /* at this point (device_init) we can try to turn on interrupts */
 820         if (!IS_RUNNING_ON_SIMULATOR()) {
 821                 sn_sal_switch_to_interrupts(&sal_console_port);
 822         }
 823         sn_process_input = 1;
 824         return 0;
 825 }
 826 device_initcall(sn_sal_init);
 827
 828 /**
 829  * puts_raw_fixed - sn_sal_console_write helper for adding \r's as required
 830  * @puts_raw : puts function to do the writing
 831  * @s: input string
 832  * @count: length
 833  *
 834  * We need a \r ahead of every \n for direct writes through
 835  * ia64_sn_console_putb (what sal_puts_raw below actually does).
 836  *
 837  */
 838
 839 static void puts_raw_fixed(int (*puts_raw) (const char *s, int len),
 840                            const char *s, int count)
 841 {
 842         const char *s1;
 843
 844         /* Output '\r' before each '\n' */
 845         while ((s1 = memchr(s, '\n', count)) != NULL) {
 846                 puts_raw(s, s1 - s);
 847                 puts_raw("\r\n", 2);
 848                 count -= s1 + 1 - s;
 849                 s = s1 + 1;
 850         }
 851         puts_raw(s, count);
 852 }
 853
 854 /**
 855  * sn_sal_console_write - Print statements before serial core available
 856  * @console: Console to operate on - we ignore since we have just one
 857  * @s: String to send
 858  * @count: length
 859  *
 860  * This is referenced in the console struct.  It is used for early
 861  * console printing before we register with serial core and for things
 862  * such as kdb.  The console_lock must be held when we get here.
 863  *
 864  * This function has some code for trying to print output even if the lock
 865  * is held.  We try to cover the case where a lock holder could have died.
 866  * We don't use this special case code if we're not registered with serial
 867  * core yet.  After we're registered with serial core, the only time this
 868  * function would be used is for high level kernel output like magic sys req,
 869  * kdb, and printk's.
 870  */
 871 static void
 872 sn_sal_console_write(struct console *co, const char *s, unsigned count)
 873 {
 874         unsigned long flags = 0;
 875         struct sn_cons_port *port = &sal_console_port;
 876         static int stole_lock = 0;
 877
 878         BUG_ON(!port->sc_is_asynch);
 879
 880         /* We can't look at the xmit buffer if we're not registered with serial core
 881          *  yet.  So only do the fancy recovery after registering
 882          */
 883         if (!port->sc_port.state) {
 884                 /* Not yet registered with serial core - simple case */
 885                 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
 886                 return;
 887         }
 888
 889         /* somebody really wants this output, might be an
 890          * oops, kdb, panic, etc.  make sure they get it. */
 891         if (spin_is_locked(&port->sc_port.lock)) {
 892                 int lhead = port->sc_port.state->xmit.head;
 893                 int ltail = port->sc_port.state->xmit.tail;
 894                 int counter, got_lock = 0;
 895
 896                 /*
 897                  * We attempt to determine if someone has died with the
 898                  * lock. We wait ~20 secs after the head and tail ptrs
 899                  * stop moving and assume the lock holder is not functional
 900                  * and plow ahead. If the lock is freed within the time out
 901                  * period we re-get the lock and go ahead normally. We also
 902                  * remember if we have plowed ahead so that we don't have
 903                  * to wait out the time out period again - the asumption
 904                  * is that we will time out again.
 905                  */
 906
 907                 for (counter = 0; counter < 150; mdelay(125), counter++) {
 908                         if (!spin_is_locked(&port->sc_port.lock)
 909                             || stole_lock) {
 910                                 if (!stole_lock) {
 911                                         spin_lock_irqsave(&port->sc_port.lock,
 912                                                           flags);
 913                                         got_lock = 1;
 914                                 }
 915                                 break;
 916                         } else {
 917                                 /* still locked */
 918                                 if ((lhead != port->sc_port.state->xmit.head)
 919                                     || (ltail !=
 920                                         port->sc_port.state->xmit.tail)) {
 921                                         lhead =
 922                                                 port->sc_port.state->xmit.head;
 923                                         ltail =
 924                                                 port->sc_port.state->xmit.tail;
 925                                         counter = 0;
 926                                 }
 927                         }
 928                 }
 929                 /* flush anything in the serial core xmit buffer, raw */
 930                 sn_transmit_chars(port, 1);
 931                 if (got_lock) {
 932                         spin_unlock_irqrestore(&port->sc_port.lock, flags);
 933                         stole_lock = 0;
 934                 } else {
 935                         /* fell thru */
 936                         stole_lock = 1;
 937                 }
 938                 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
 939         } else {
 940                 stole_lock = 0;
 941                 spin_lock_irqsave(&port->sc_port.lock, flags);
 942                 sn_transmit_chars(port, 1);
 943                 spin_unlock_irqrestore(&port->sc_port.lock, flags);
 944
 945                 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
 946         }
 947 }
 948
 949
 950 /**
 951  * sn_sal_console_setup - Set up console for early printing
 952  * @co: Console to work with
 953  * @options: Options to set
 954  *
 955  * Altix console doesn't do anything with baud rates, etc, anyway.
 956  *
 957  * This isn't required since not providing the setup function in the
 958  * console struct is ok.  However, other patches like KDB plop something
 959  * here so providing it is easier.
 960  *
 961  */
 962 static int sn_sal_console_setup(struct console *co, char *options)
 963 {
 964         return 0;
 965 }
 966
 967 /**
 968  * sn_sal_console_write_early - simple early output routine
 969  * @co - console struct
 970  * @s - string to print
 971  * @count - count
 972  *
 973  * Simple function to provide early output, before even
 974  * sn_sal_serial_console_init is called.  Referenced in the
 975  * console struct registerd in sn_serial_console_early_setup.
 976  *
 977  */
 978 static void __init
 979 sn_sal_console_write_early(struct console *co, const char *s, unsigned count)
 980 {
 981         puts_raw_fixed(sal_console_port.sc_ops->sal_puts_raw, s, count);
 982 }
 983
 984 /* Used for very early console printing - again, before
 985  * sn_sal_serial_console_init is run */
 986 static struct console sal_console_early __initdata = {
 987         .name = "sn_sal",
 988         .write = sn_sal_console_write_early,
 989         .flags = CON_PRINTBUFFER,
 990         .index = -1,
 991 };
 992
 993 /**
 994  * sn_serial_console_early_setup - Sets up early console output support
 995  *
 996  * Register a console early on...  This is for output before even
 997  * sn_sal_serial_cosnole_init is called.  This function is called from
 998  * setup.c.  This allows us to do really early polled writes. When
 999  * sn_sal_serial_console_init is called, this console is unregistered
1000  * and a new one registered.
1001  */
1002 int __init sn_serial_console_early_setup(void)
1003 {
1004         if (!ia64_platform_is("sn2"))
1005                 return -1;
1006
1007         sal_console_port.sc_ops = &poll_ops;
1008         spin_lock_init(&sal_console_port.sc_port.lock);
1009         early_sn_setup();       /* Find SAL entry points */
1010         register_console(&sal_console_early);
1011
1012         return 0;
1013 }
1014
1015 /**
1016  * sn_sal_serial_console_init - Early console output - set up for register
1017  *
1018  * This function is called when regular console init happens.  Because we
1019  * support even earlier console output with sn_serial_console_early_setup
1020  * (called from setup.c directly), this function unregisters the really
1021  * early console.
1022  *
1023  * Note: Even if setup.c doesn't register sal_console_early, unregistering
1024  * it here doesn't hurt anything.
1025  *
1026  */
1027 static int __init sn_sal_serial_console_init(void)
1028 {
1029         if (ia64_platform_is("sn2")) {
1030                 sn_sal_switch_to_asynch(&sal_console_port);
1031                 DPRINTF("sn_sal_serial_console_init : register console\n");
1032                 register_console(&sal_console);
1033                 unregister_console(&sal_console_early);
1034         }
1035         return 0;
1036 }
1037
1038 console_initcall(sn_sal_serial_console_init);