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