drivers/serial/sunsu.c

   1 /* $Id: su.c,v 1.55 2002/01/08 16:00:16 davem Exp $
   2  * su.c: Small serial driver for keyboard/mouse interface on sparc32/PCI
   3  *
   4  * Copyright (C) 1997  Eddie C. Dost  (ecd@skynet.be)
   5  * Copyright (C) 1998-1999  Pete Zaitcev   (zaitcev@yahoo.com)
   6  *
   7  * This is mainly a variation of 8250.c, credits go to authors mentioned
   8  * therein.  In fact this driver should be merged into the generic 8250.c
   9  * infrastructure perhaps using a 8250_sparc.c module.
  10  *
  11  * Fixed to use tty_get_baud_rate().
  12  *   Theodore Ts'o <tytso@mit.edu>, 2001-Oct-12
  13  *
  14  * Converted to new 2.5.x UART layer.
  15  *   David S. Miller (davem@redhat.com), 2002-Jul-29
  16  */
  17
  18 #include <linux/config.h>
  19 #include <linux/module.h>
  20 #include <linux/kernel.h>
  21 #include <linux/sched.h>
  22 #include <linux/spinlock.h>
  23 #include <linux/errno.h>
  24 #include <linux/tty.h>
  25 #include <linux/tty_flip.h>
  26 #include <linux/major.h>
  27 #include <linux/string.h>
  28 #include <linux/ptrace.h>
  29 #include <linux/ioport.h>
  30 #include <linux/circ_buf.h>
  31 #include <linux/serial.h>
  32 #include <linux/sysrq.h>
  33 #include <linux/console.h>
  34 #ifdef CONFIG_SERIO
  35 #include <linux/serio.h>
  36 #endif
  37 #include <linux/serial_reg.h>
  38 #include <linux/init.h>
  39 #include <linux/delay.h>
  40
  41 #include <asm/io.h>
  42 #include <asm/irq.h>
  43 #include <asm/oplib.h>
  44 #include <asm/ebus.h>
  45 #ifdef CONFIG_SPARC64
  46 #include <asm/isa.h>
  47 #endif
  48
  49 #if defined(CONFIG_SERIAL_SUNSU_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  50 #define SUPPORT_SYSRQ
  51 #endif
  52
  53 #include <linux/serial_core.h>
  54
  55 #include "suncore.h"
  56
  57 /* We are on a NS PC87303 clocked with 24.0 MHz, which results
  58  * in a UART clock of 1.8462 MHz.
  59  */
  60 #define SU_BASE_BAUD    (1846200 / 16)
  61
  62 enum su_type { SU_PORT_NONE, SU_PORT_MS, SU_PORT_KBD, SU_PORT_PORT };
  63 static char *su_typev[] = { "su(???)", "su(mouse)", "su(kbd)", "su(serial)" };
  64
  65 /*
  66  * Here we define the default xmit fifo size used for each type of UART.
  67  */
  68 static const struct serial_uart_config uart_config[PORT_MAX_8250+1] = {
  69         { "unknown",    1,      0 },
  70         { "8250",       1,      0 },
  71         { "16450",      1,      0 },
  72         { "16550",      1,      0 },
  73         { "16550A",     16,     UART_CLEAR_FIFO | UART_USE_FIFO },
  74         { "Cirrus",     1,      0 },
  75         { "ST16650",    1,      UART_CLEAR_FIFO | UART_STARTECH },
  76         { "ST16650V2",  32,     UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH },
  77         { "TI16750",    64,     UART_CLEAR_FIFO | UART_USE_FIFO },
  78         { "Startech",   1,      0 },
  79         { "16C950/954", 128,    UART_CLEAR_FIFO | UART_USE_FIFO },
  80         { "ST16654",    64,     UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH },
  81         { "XR16850",    128,    UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH },
  82         { "RSA",        2048,   UART_CLEAR_FIFO | UART_USE_FIFO }
  83 };
  84
  85 struct uart_sunsu_port {
  86         struct uart_port        port;
  87         unsigned char           acr;
  88         unsigned char           ier;
  89         unsigned short          rev;
  90         unsigned char           lcr;
  91         unsigned int            lsr_break_flag;
  92         unsigned int            cflag;
  93
  94         /* Probing information.  */
  95         enum su_type            su_type;
  96         unsigned int            type_probed;    /* XXX Stupid */
  97         int                     port_node;
  98
  99 #ifdef CONFIG_SERIO
 100         struct serio            *serio;
 101         int                     serio_open;
 102 #endif
 103 };
 104
 105 static unsigned int serial_in(struct uart_sunsu_port *up, int offset)
 106 {
 107         offset <<= up->port.regshift;
 108
 109         switch (up->port.iotype) {
 110         case UPIO_HUB6:
 111                 outb(up->port.hub6 - 1 + offset, up->port.iobase);
 112                 return inb(up->port.iobase + 1);
 113
 114         case UPIO_MEM:
 115                 return readb(up->port.membase + offset);
 116
 117         default:
 118                 return inb(up->port.iobase + offset);
 119         }
 120 }
 121
 122 static void serial_out(struct uart_sunsu_port *up, int offset, int value)
 123 {
 124 #ifndef CONFIG_SPARC64
 125         /*
 126          * MrCoffee has weird schematics: IRQ4 & P10(?) pins of SuperIO are
 127          * connected with a gate then go to SlavIO. When IRQ4 goes tristated
 128          * gate outputs a logical one. Since we use level triggered interrupts
 129          * we have lockup and watchdog reset. We cannot mask IRQ because
 130          * keyboard shares IRQ with us (Word has it as Bob Smelik's design).
 131          * This problem is similar to what Alpha people suffer, see serial.c.
 132          */
 133         if (offset == UART_MCR)
 134                 value |= UART_MCR_OUT2;
 135 #endif
 136         offset <<= up->port.regshift;
 137
 138         switch (up->port.iotype) {
 139         case UPIO_HUB6:
 140                 outb(up->port.hub6 - 1 + offset, up->port.iobase);
 141                 outb(value, up->port.iobase + 1);
 142                 break;
 143
 144         case UPIO_MEM:
 145                 writeb(value, up->port.membase + offset);
 146                 break;
 147
 148         default:
 149                 outb(value, up->port.iobase + offset);
 150         }
 151 }
 152
 153 /*
 154  * We used to support using pause I/O for certain machines.  We
 155  * haven't supported this for a while, but just in case it's badly
 156  * needed for certain old 386 machines, I've left these #define's
 157  * in....
 158  */
 159 #define serial_inp(up, offset)          serial_in(up, offset)
 160 #define serial_outp(up, offset, value)  serial_out(up, offset, value)
 161
 162
 163 /*
 164  * For the 16C950
 165  */
 166 static void serial_icr_write(struct uart_sunsu_port *up, int offset, int value)
 167 {
 168         serial_out(up, UART_SCR, offset);
 169         serial_out(up, UART_ICR, value);
 170 }
 171
 172 #if 0 /* Unused currently */
 173 static unsigned int serial_icr_read(struct uart_sunsu_port *up, int offset)
 174 {
 175         unsigned int value;
 176
 177         serial_icr_write(up, UART_ACR, up->acr | UART_ACR_ICRRD);
 178         serial_out(up, UART_SCR, offset);
 179         value = serial_in(up, UART_ICR);
 180         serial_icr_write(up, UART_ACR, up->acr);
 181
 182         return value;
 183 }
 184 #endif
 185
 186 #ifdef CONFIG_SERIAL_8250_RSA
 187 /*
 188  * Attempts to turn on the RSA FIFO.  Returns zero on failure.
 189  * We set the port uart clock rate if we succeed.
 190  */
 191 static int __enable_rsa(struct uart_sunsu_port *up)
 192 {
 193         unsigned char mode;
 194         int result;
 195
 196         mode = serial_inp(up, UART_RSA_MSR);
 197         result = mode & UART_RSA_MSR_FIFO;
 198
 199         if (!result) {
 200                 serial_outp(up, UART_RSA_MSR, mode | UART_RSA_MSR_FIFO);
 201                 mode = serial_inp(up, UART_RSA_MSR);
 202                 result = mode & UART_RSA_MSR_FIFO;
 203         }
 204
 205         if (result)
 206                 up->port.uartclk = SERIAL_RSA_BAUD_BASE * 16;
 207
 208         return result;
 209 }
 210
 211 static void enable_rsa(struct uart_sunsu_port *up)
 212 {
 213         if (up->port.type == PORT_RSA) {
 214                 if (up->port.uartclk != SERIAL_RSA_BAUD_BASE * 16) {
 215                         spin_lock_irq(&up->port.lock);
 216                         __enable_rsa(up);
 217                         spin_unlock_irq(&up->port.lock);
 218                 }
 219                 if (up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16)
 220                         serial_outp(up, UART_RSA_FRR, 0);
 221         }
 222 }
 223
 224 /*
 225  * Attempts to turn off the RSA FIFO.  Returns zero on failure.
 226  * It is unknown why interrupts were disabled in here.  However,
 227  * the caller is expected to preserve this behaviour by grabbing
 228  * the spinlock before calling this function.
 229  */
 230 static void disable_rsa(struct uart_sunsu_port *up)
 231 {
 232         unsigned char mode;
 233         int result;
 234
 235         if (up->port.type == PORT_RSA &&
 236             up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16) {
 237                 spin_lock_irq(&up->port.lock);
 238
 239                 mode = serial_inp(up, UART_RSA_MSR);
 240                 result = !(mode & UART_RSA_MSR_FIFO);
 241
 242                 if (!result) {
 243                         serial_outp(up, UART_RSA_MSR, mode & ~UART_RSA_MSR_FIFO);
 244                         mode = serial_inp(up, UART_RSA_MSR);
 245                         result = !(mode & UART_RSA_MSR_FIFO);
 246                 }
 247
 248                 if (result)
 249                         up->port.uartclk = SERIAL_RSA_BAUD_BASE_LO * 16;
 250                 spin_unlock_irq(&up->port.lock);
 251         }
 252 }
 253 #endif /* CONFIG_SERIAL_8250_RSA */
 254
 255 static inline void __stop_tx(struct uart_sunsu_port *p)
 256 {
 257         if (p->ier & UART_IER_THRI) {
 258                 p->ier &= ~UART_IER_THRI;
 259                 serial_out(p, UART_IER, p->ier);
 260         }
 261 }
 262
 263 static void sunsu_stop_tx(struct uart_port *port)
 264 {
 265         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 266
 267         __stop_tx(up);
 268
 269         /*
 270          * We really want to stop the transmitter from sending.
 271          */
 272         if (up->port.type == PORT_16C950) {
 273                 up->acr |= UART_ACR_TXDIS;
 274                 serial_icr_write(up, UART_ACR, up->acr);
 275         }
 276 }
 277
 278 static void sunsu_start_tx(struct uart_port *port)
 279 {
 280         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 281
 282         if (!(up->ier & UART_IER_THRI)) {
 283                 up->ier |= UART_IER_THRI;
 284                 serial_out(up, UART_IER, up->ier);
 285         }
 286
 287         /*
 288          * Re-enable the transmitter if we disabled it.
 289          */
 290         if (up->port.type == PORT_16C950 && up->acr & UART_ACR_TXDIS) {
 291                 up->acr &= ~UART_ACR_TXDIS;
 292                 serial_icr_write(up, UART_ACR, up->acr);
 293         }
 294 }
 295
 296 static void sunsu_stop_rx(struct uart_port *port)
 297 {
 298         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 299
 300         up->ier &= ~UART_IER_RLSI;
 301         up->port.read_status_mask &= ~UART_LSR_DR;
 302         serial_out(up, UART_IER, up->ier);
 303 }
 304
 305 static void sunsu_enable_ms(struct uart_port *port)
 306 {
 307         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 308         unsigned long flags;
 309
 310         spin_lock_irqsave(&up->port.lock, flags);
 311         up->ier |= UART_IER_MSI;
 312         serial_out(up, UART_IER, up->ier);
 313         spin_unlock_irqrestore(&up->port.lock, flags);
 314 }
 315
 316 static struct tty_struct *
 317 receive_chars(struct uart_sunsu_port *up, unsigned char *status, struct pt_regs *regs)
 318 {
 319         struct tty_struct *tty = up->port.info->tty;
 320         unsigned char ch, flag;
 321         int max_count = 256;
 322         int saw_console_brk = 0;
 323
 324         do {
 325                 ch = serial_inp(up, UART_RX);
 326                 flag = TTY_NORMAL;
 327                 up->port.icount.rx++;
 328
 329                 if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
 330                                        UART_LSR_FE | UART_LSR_OE))) {
 331                         /*
 332                          * For statistics only
 333                          */
 334                         if (*status & UART_LSR_BI) {
 335                                 *status &= ~(UART_LSR_FE | UART_LSR_PE);
 336                                 up->port.icount.brk++;
 337                                 if (up->port.cons != NULL &&
 338                                     up->port.line == up->port.cons->index)
 339                                         saw_console_brk = 1;
 340                                 /*
 341                                  * We do the SysRQ and SAK checking
 342                                  * here because otherwise the break
 343                                  * may get masked by ignore_status_mask
 344                                  * or read_status_mask.
 345                                  */
 346                                 if (uart_handle_break(&up->port))
 347                                         goto ignore_char;
 348                         } else if (*status & UART_LSR_PE)
 349                                 up->port.icount.parity++;
 350                         else if (*status & UART_LSR_FE)
 351                                 up->port.icount.frame++;
 352                         if (*status & UART_LSR_OE)
 353                                 up->port.icount.overrun++;
 354
 355                         /*
 356                          * Mask off conditions which should be ingored.
 357                          */
 358                         *status &= up->port.read_status_mask;
 359
 360                         if (up->port.cons != NULL &&
 361                             up->port.line == up->port.cons->index) {
 362                                 /* Recover the break flag from console xmit */
 363                                 *status |= up->lsr_break_flag;
 364                                 up->lsr_break_flag = 0;
 365                         }
 366
 367                         if (*status & UART_LSR_BI) {
 368                                 flag = TTY_BREAK;
 369                         } else if (*status & UART_LSR_PE)
 370                                 flag = TTY_PARITY;
 371                         else if (*status & UART_LSR_FE)
 372                                 flag = TTY_FRAME;
 373                 }
 374                 if (uart_handle_sysrq_char(&up->port, ch, regs))
 375                         goto ignore_char;
 376                 if ((*status & up->port.ignore_status_mask) == 0)
 377                         tty_insert_flip_char(tty, ch, flag);
 378                 if (*status & UART_LSR_OE)
 379                         /*
 380                          * Overrun is special, since it's reported
 381                          * immediately, and doesn't affect the current
 382                          * character.
 383                          */
 384                          tty_insert_flip_char(tty, 0, TTY_OVERRUN);
 385         ignore_char:
 386                 *status = serial_inp(up, UART_LSR);
 387         } while ((*status & UART_LSR_DR) && (max_count-- > 0));
 388
 389         if (saw_console_brk)
 390                 sun_do_break();
 391
 392         return tty;
 393 }
 394
 395 static void transmit_chars(struct uart_sunsu_port *up)
 396 {
 397         struct circ_buf *xmit = &up->port.info->xmit;
 398         int count;
 399
 400         if (up->port.x_char) {
 401                 serial_outp(up, UART_TX, up->port.x_char);
 402                 up->port.icount.tx++;
 403                 up->port.x_char = 0;
 404                 return;
 405         }
 406         if (uart_tx_stopped(&up->port)) {
 407                 sunsu_stop_tx(&up->port);
 408                 return;
 409         }
 410         if (uart_circ_empty(xmit)) {
 411                 __stop_tx(up);
 412                 return;
 413         }
 414
 415         count = up->port.fifosize;
 416         do {
 417                 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
 418                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 419                 up->port.icount.tx++;
 420                 if (uart_circ_empty(xmit))
 421                         break;
 422         } while (--count > 0);
 423
 424         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 425                 uart_write_wakeup(&up->port);
 426
 427         if (uart_circ_empty(xmit))
 428                 __stop_tx(up);
 429 }
 430
 431 static void check_modem_status(struct uart_sunsu_port *up)
 432 {
 433         int status;
 434
 435         status = serial_in(up, UART_MSR);
 436
 437         if ((status & UART_MSR_ANY_DELTA) == 0)
 438                 return;
 439
 440         if (status & UART_MSR_TERI)
 441                 up->port.icount.rng++;
 442         if (status & UART_MSR_DDSR)
 443                 up->port.icount.dsr++;
 444         if (status & UART_MSR_DDCD)
 445                 uart_handle_dcd_change(&up->port, status & UART_MSR_DCD);
 446         if (status & UART_MSR_DCTS)
 447                 uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
 448
 449         wake_up_interruptible(&up->port.info->delta_msr_wait);
 450 }
 451
 452 static irqreturn_t sunsu_serial_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 453 {
 454         struct uart_sunsu_port *up = dev_id;
 455         unsigned long flags;
 456         unsigned char status;
 457
 458         spin_lock_irqsave(&up->port.lock, flags);
 459
 460         do {
 461                 struct tty_struct *tty;
 462
 463                 status = serial_inp(up, UART_LSR);
 464                 tty = NULL;
 465                 if (status & UART_LSR_DR)
 466                         tty = receive_chars(up, &status, regs);
 467                 check_modem_status(up);
 468                 if (status & UART_LSR_THRE)
 469                         transmit_chars(up);
 470
 471                 spin_unlock_irqrestore(&up->port.lock, flags);
 472
 473                 if (tty)
 474                         tty_flip_buffer_push(tty);
 475
 476                 spin_lock_irqsave(&up->port.lock, flags);
 477
 478         } while (!(serial_in(up, UART_IIR) & UART_IIR_NO_INT));
 479
 480         spin_unlock_irqrestore(&up->port.lock, flags);
 481
 482         return IRQ_HANDLED;
 483 }
 484
 485 /* Separate interrupt handling path for keyboard/mouse ports.  */
 486
 487 static void
 488 sunsu_change_speed(struct uart_port *port, unsigned int cflag,
 489                    unsigned int iflag, unsigned int quot);
 490
 491 static void sunsu_change_mouse_baud(struct uart_sunsu_port *up)
 492 {
 493         unsigned int cur_cflag = up->cflag;
 494         int quot, new_baud;
 495
 496         up->cflag &= ~CBAUD;
 497         up->cflag |= suncore_mouse_baud_cflag_next(cur_cflag, &new_baud);
 498
 499         quot = up->port.uartclk / (16 * new_baud);
 500
 501         sunsu_change_speed(&up->port, up->cflag, 0, quot);
 502 }
 503
 504 static void receive_kbd_ms_chars(struct uart_sunsu_port *up, struct pt_regs *regs, int is_break)
 505 {
 506         do {
 507                 unsigned char ch = serial_inp(up, UART_RX);
 508
 509                 /* Stop-A is handled by drivers/char/keyboard.c now. */
 510                 if (up->su_type == SU_PORT_KBD) {
 511 #ifdef CONFIG_SERIO
 512                         serio_interrupt(up->serio, ch, 0, regs);
 513 #endif
 514                 } else if (up->su_type == SU_PORT_MS) {
 515                         int ret = suncore_mouse_baud_detection(ch, is_break);
 516
 517                         switch (ret) {
 518                         case 2:
 519                                 sunsu_change_mouse_baud(up);
 520                                 /* fallthru */
 521                         case 1:
 522                                 break;
 523
 524                         case 0:
 525 #ifdef CONFIG_SERIO
 526                                 serio_interrupt(up->serio, ch, 0, regs);
 527 #endif
 528                                 break;
 529                         };
 530                 }
 531         } while (serial_in(up, UART_LSR) & UART_LSR_DR);
 532 }
 533
 534 static irqreturn_t sunsu_kbd_ms_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 535 {
 536         struct uart_sunsu_port *up = dev_id;
 537
 538         if (!(serial_in(up, UART_IIR) & UART_IIR_NO_INT)) {
 539                 unsigned char status = serial_inp(up, UART_LSR);
 540
 541                 if ((status & UART_LSR_DR) || (status & UART_LSR_BI))
 542                         receive_kbd_ms_chars(up, regs,
 543                                              (status & UART_LSR_BI) != 0);
 544         }
 545
 546         return IRQ_HANDLED;
 547 }
 548
 549 static unsigned int sunsu_tx_empty(struct uart_port *port)
 550 {
 551         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 552         unsigned long flags;
 553         unsigned int ret;
 554
 555         spin_lock_irqsave(&up->port.lock, flags);
 556         ret = serial_in(up, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
 557         spin_unlock_irqrestore(&up->port.lock, flags);
 558
 559         return ret;
 560 }
 561
 562 static unsigned int sunsu_get_mctrl(struct uart_port *port)
 563 {
 564         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 565         unsigned char status;
 566         unsigned int ret;
 567
 568         status = serial_in(up, UART_MSR);
 569
 570         ret = 0;
 571         if (status & UART_MSR_DCD)
 572                 ret |= TIOCM_CAR;
 573         if (status & UART_MSR_RI)
 574                 ret |= TIOCM_RNG;
 575         if (status & UART_MSR_DSR)
 576                 ret |= TIOCM_DSR;
 577         if (status & UART_MSR_CTS)
 578                 ret |= TIOCM_CTS;
 579         return ret;
 580 }
 581
 582 static void sunsu_set_mctrl(struct uart_port *port, unsigned int mctrl)
 583 {
 584         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 585         unsigned char mcr = 0;
 586
 587         if (mctrl & TIOCM_RTS)
 588                 mcr |= UART_MCR_RTS;
 589         if (mctrl & TIOCM_DTR)
 590                 mcr |= UART_MCR_DTR;
 591         if (mctrl & TIOCM_OUT1)
 592                 mcr |= UART_MCR_OUT1;
 593         if (mctrl & TIOCM_OUT2)
 594                 mcr |= UART_MCR_OUT2;
 595         if (mctrl & TIOCM_LOOP)
 596                 mcr |= UART_MCR_LOOP;
 597
 598         serial_out(up, UART_MCR, mcr);
 599 }
 600
 601 static void sunsu_break_ctl(struct uart_port *port, int break_state)
 602 {
 603         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 604         unsigned long flags;
 605
 606         spin_lock_irqsave(&up->port.lock, flags);
 607         if (break_state == -1)
 608                 up->lcr |= UART_LCR_SBC;
 609         else
 610                 up->lcr &= ~UART_LCR_SBC;
 611         serial_out(up, UART_LCR, up->lcr);
 612         spin_unlock_irqrestore(&up->port.lock, flags);
 613 }
 614
 615 static int sunsu_startup(struct uart_port *port)
 616 {
 617         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 618         unsigned long flags;
 619         int retval;
 620
 621         if (up->port.type == PORT_16C950) {
 622                 /* Wake up and initialize UART */
 623                 up->acr = 0;
 624                 serial_outp(up, UART_LCR, 0xBF);
 625                 serial_outp(up, UART_EFR, UART_EFR_ECB);
 626                 serial_outp(up, UART_IER, 0);
 627                 serial_outp(up, UART_LCR, 0);
 628                 serial_icr_write(up, UART_CSR, 0); /* Reset the UART */
 629                 serial_outp(up, UART_LCR, 0xBF);
 630                 serial_outp(up, UART_EFR, UART_EFR_ECB);
 631                 serial_outp(up, UART_LCR, 0);
 632         }
 633
 634 #ifdef CONFIG_SERIAL_8250_RSA
 635         /*
 636          * If this is an RSA port, see if we can kick it up to the
 637          * higher speed clock.
 638          */
 639         enable_rsa(up);
 640 #endif
 641
 642         /*
 643          * Clear the FIFO buffers and disable them.
 644          * (they will be reenabled in set_termios())
 645          */
 646         if (uart_config[up->port.type].flags & UART_CLEAR_FIFO) {
 647                 serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
 648                 serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO |
 649                                 UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 650                 serial_outp(up, UART_FCR, 0);
 651         }
 652
 653         /*
 654          * Clear the interrupt registers.
 655          */
 656         (void) serial_inp(up, UART_LSR);
 657         (void) serial_inp(up, UART_RX);
 658         (void) serial_inp(up, UART_IIR);
 659         (void) serial_inp(up, UART_MSR);
 660
 661         /*
 662          * At this point, there's no way the LSR could still be 0xff;
 663          * if it is, then bail out, because there's likely no UART
 664          * here.
 665          */
 666         if (!(up->port.flags & UPF_BUGGY_UART) &&
 667             (serial_inp(up, UART_LSR) == 0xff)) {
 668                 printk("ttyS%d: LSR safety check engaged!\n", up->port.line);
 669                 return -ENODEV;
 670         }
 671
 672         if (up->su_type != SU_PORT_PORT) {
 673                 retval = request_irq(up->port.irq, sunsu_kbd_ms_interrupt,
 674                                      SA_SHIRQ, su_typev[up->su_type], up);
 675         } else {
 676                 retval = request_irq(up->port.irq, sunsu_serial_interrupt,
 677                                      SA_SHIRQ, su_typev[up->su_type], up);
 678         }
 679         if (retval) {
 680                 printk("su: Cannot register IRQ %d\n", up->port.irq);
 681                 return retval;
 682         }
 683
 684         /*
 685          * Now, initialize the UART
 686          */
 687         serial_outp(up, UART_LCR, UART_LCR_WLEN8);
 688
 689         spin_lock_irqsave(&up->port.lock, flags);
 690
 691         up->port.mctrl |= TIOCM_OUT2;
 692
 693         sunsu_set_mctrl(&up->port, up->port.mctrl);
 694         spin_unlock_irqrestore(&up->port.lock, flags);
 695
 696         /*
 697          * Finally, enable interrupts.  Note: Modem status interrupts
 698          * are set via set_termios(), which will be occurring imminently
 699          * anyway, so we don't enable them here.
 700          */
 701         up->ier = UART_IER_RLSI | UART_IER_RDI;
 702         serial_outp(up, UART_IER, up->ier);
 703
 704         if (up->port.flags & UPF_FOURPORT) {
 705                 unsigned int icp;
 706                 /*
 707                  * Enable interrupts on the AST Fourport board
 708                  */
 709                 icp = (up->port.iobase & 0xfe0) | 0x01f;
 710                 outb_p(0x80, icp);
 711                 (void) inb_p(icp);
 712         }
 713
 714         /*
 715          * And clear the interrupt registers again for luck.
 716          */
 717         (void) serial_inp(up, UART_LSR);
 718         (void) serial_inp(up, UART_RX);
 719         (void) serial_inp(up, UART_IIR);
 720         (void) serial_inp(up, UART_MSR);
 721
 722         return 0;
 723 }
 724
 725 static void sunsu_shutdown(struct uart_port *port)
 726 {
 727         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 728         unsigned long flags;
 729
 730         /*
 731          * Disable interrupts from this port
 732          */
 733         up->ier = 0;
 734         serial_outp(up, UART_IER, 0);
 735
 736         spin_lock_irqsave(&up->port.lock, flags);
 737         if (up->port.flags & UPF_FOURPORT) {
 738                 /* reset interrupts on the AST Fourport board */
 739                 inb((up->port.iobase & 0xfe0) | 0x1f);
 740                 up->port.mctrl |= TIOCM_OUT1;
 741         } else
 742                 up->port.mctrl &= ~TIOCM_OUT2;
 743
 744         sunsu_set_mctrl(&up->port, up->port.mctrl);
 745         spin_unlock_irqrestore(&up->port.lock, flags);
 746
 747         /*
 748          * Disable break condition and FIFOs
 749          */
 750         serial_out(up, UART_LCR, serial_inp(up, UART_LCR) & ~UART_LCR_SBC);
 751         serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO |
 752                                   UART_FCR_CLEAR_RCVR |
 753                                   UART_FCR_CLEAR_XMIT);
 754         serial_outp(up, UART_FCR, 0);
 755
 756 #ifdef CONFIG_SERIAL_8250_RSA
 757         /*
 758          * Reset the RSA board back to 115kbps compat mode.
 759          */
 760         disable_rsa(up);
 761 #endif
 762
 763         /*
 764          * Read data port to reset things.
 765          */
 766         (void) serial_in(up, UART_RX);
 767
 768         free_irq(up->port.irq, up);
 769 }
 770
 771 static void
 772 sunsu_change_speed(struct uart_port *port, unsigned int cflag,
 773                    unsigned int iflag, unsigned int quot)
 774 {
 775         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 776         unsigned char cval, fcr = 0;
 777         unsigned long flags;
 778
 779         switch (cflag & CSIZE) {
 780         case CS5:
 781                 cval = 0x00;
 782                 break;
 783         case CS6:
 784                 cval = 0x01;
 785                 break;
 786         case CS7:
 787                 cval = 0x02;
 788                 break;
 789         default:
 790         case CS8:
 791                 cval = 0x03;
 792                 break;
 793         }
 794
 795         if (cflag & CSTOPB)
 796                 cval |= 0x04;
 797         if (cflag & PARENB)
 798                 cval |= UART_LCR_PARITY;
 799         if (!(cflag & PARODD))
 800                 cval |= UART_LCR_EPAR;
 801 #ifdef CMSPAR
 802         if (cflag & CMSPAR)
 803                 cval |= UART_LCR_SPAR;
 804 #endif
 805
 806         /*
 807          * Work around a bug in the Oxford Semiconductor 952 rev B
 808          * chip which causes it to seriously miscalculate baud rates
 809          * when DLL is 0.
 810          */
 811         if ((quot & 0xff) == 0 && up->port.type == PORT_16C950 &&
 812             up->rev == 0x5201)
 813                 quot ++;
 814
 815         if (uart_config[up->port.type].flags & UART_USE_FIFO) {
 816                 if ((up->port.uartclk / quot) < (2400 * 16))
 817                         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
 818 #ifdef CONFIG_SERIAL_8250_RSA
 819                 else if (up->port.type == PORT_RSA)
 820                         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_14;
 821 #endif
 822                 else
 823                         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8;
 824         }
 825         if (up->port.type == PORT_16750)
 826                 fcr |= UART_FCR7_64BYTE;
 827
 828         /*
 829          * Ok, we're now changing the port state.  Do it with
 830          * interrupts disabled.
 831          */
 832         spin_lock_irqsave(&up->port.lock, flags);
 833
 834         /*
 835          * Update the per-port timeout.
 836          */
 837         uart_update_timeout(port, cflag, (port->uartclk / (16 * quot)));
 838
 839         up->port.read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
 840         if (iflag & INPCK)
 841                 up->port.read_status_mask |= UART_LSR_FE | UART_LSR_PE;
 842         if (iflag & (BRKINT | PARMRK))
 843                 up->port.read_status_mask |= UART_LSR_BI;
 844
 845         /*
 846          * Characteres to ignore
 847          */
 848         up->port.ignore_status_mask = 0;
 849         if (iflag & IGNPAR)
 850                 up->port.ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
 851         if (iflag & IGNBRK) {
 852                 up->port.ignore_status_mask |= UART_LSR_BI;
 853                 /*
 854                  * If we're ignoring parity and break indicators,
 855                  * ignore overruns too (for real raw support).
 856                  */
 857                 if (iflag & IGNPAR)
 858                         up->port.ignore_status_mask |= UART_LSR_OE;
 859         }
 860
 861         /*
 862          * ignore all characters if CREAD is not set
 863          */
 864         if ((cflag & CREAD) == 0)
 865                 up->port.ignore_status_mask |= UART_LSR_DR;
 866
 867         /*
 868          * CTS flow control flag and modem status interrupts
 869          */
 870         up->ier &= ~UART_IER_MSI;
 871         if (UART_ENABLE_MS(&up->port, cflag))
 872                 up->ier |= UART_IER_MSI;
 873
 874         serial_out(up, UART_IER, up->ier);
 875
 876         if (uart_config[up->port.type].flags & UART_STARTECH) {
 877                 serial_outp(up, UART_LCR, 0xBF);
 878                 serial_outp(up, UART_EFR, cflag & CRTSCTS ? UART_EFR_CTS :0);
 879         }
 880         serial_outp(up, UART_LCR, cval | UART_LCR_DLAB);/* set DLAB */
 881         serial_outp(up, UART_DLL, quot & 0xff);         /* LS of divisor */
 882         serial_outp(up, UART_DLM, quot >> 8);           /* MS of divisor */
 883         if (up->port.type == PORT_16750)
 884                 serial_outp(up, UART_FCR, fcr);         /* set fcr */
 885         serial_outp(up, UART_LCR, cval);                /* reset DLAB */
 886         up->lcr = cval;                                 /* Save LCR */
 887         if (up->port.type != PORT_16750) {
 888                 if (fcr & UART_FCR_ENABLE_FIFO) {
 889                         /* emulated UARTs (Lucent Venus 167x) need two steps */
 890                         serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
 891                 }
 892                 serial_outp(up, UART_FCR, fcr);         /* set fcr */
 893         }
 894
 895         up->cflag = cflag;
 896
 897         spin_unlock_irqrestore(&up->port.lock, flags);
 898 }
 899
 900 static void
 901 sunsu_set_termios(struct uart_port *port, struct termios *termios,
 902                   struct termios *old)
 903 {
 904         unsigned int baud, quot;
 905
 906         /*
 907          * Ask the core to calculate the divisor for us.
 908          */
 909         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
 910         quot = uart_get_divisor(port, baud);
 911
 912         sunsu_change_speed(port, termios->c_cflag, termios->c_iflag, quot);
 913 }
 914
 915 static void sunsu_release_port(struct uart_port *port)
 916 {
 917 }
 918
 919 static int sunsu_request_port(struct uart_port *port)
 920 {
 921         return 0;
 922 }
 923
 924 static void sunsu_config_port(struct uart_port *port, int flags)
 925 {
 926         struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
 927
 928         if (flags & UART_CONFIG_TYPE) {
 929                 /*
 930                  * We are supposed to call autoconfig here, but this requires
 931                  * splitting all the OBP probing crap from the UART probing.
 932                  * We'll do it when we kill sunsu.c altogether.
 933                  */
 934                 port->type = up->type_probed;   /* XXX */
 935         }
 936 }
 937
 938 static int
 939 sunsu_verify_port(struct uart_port *port, struct serial_struct *ser)
 940 {
 941         return -EINVAL;
 942 }
 943
 944 static const char *
 945 sunsu_type(struct uart_port *port)
 946 {
 947         int type = port->type;
 948
 949         if (type >= ARRAY_SIZE(uart_config))
 950                 type = 0;
 951         return uart_config[type].name;
 952 }
 953
 954 static struct uart_ops sunsu_pops = {
 955         .tx_empty       = sunsu_tx_empty,
 956         .set_mctrl      = sunsu_set_mctrl,
 957         .get_mctrl      = sunsu_get_mctrl,
 958         .stop_tx        = sunsu_stop_tx,
 959         .start_tx       = sunsu_start_tx,
 960         .stop_rx        = sunsu_stop_rx,
 961         .enable_ms      = sunsu_enable_ms,
 962         .break_ctl      = sunsu_break_ctl,
 963         .startup        = sunsu_startup,
 964         .shutdown       = sunsu_shutdown,
 965         .set_termios    = sunsu_set_termios,
 966         .type           = sunsu_type,
 967         .release_port   = sunsu_release_port,
 968         .request_port   = sunsu_request_port,
 969         .config_port    = sunsu_config_port,
 970         .verify_port    = sunsu_verify_port,
 971 };
 972
 973 #define UART_NR 4
 974
 975 static struct uart_sunsu_port sunsu_ports[UART_NR];
 976
 977 #ifdef CONFIG_SERIO
 978
 979 static DEFINE_SPINLOCK(sunsu_serio_lock);
 980
 981 static int sunsu_serio_write(struct serio *serio, unsigned char ch)
 982 {
 983         struct uart_sunsu_port *up = serio->port_data;
 984         unsigned long flags;
 985         int lsr;
 986
 987         spin_lock_irqsave(&sunsu_serio_lock, flags);
 988
 989         do {
 990                 lsr = serial_in(up, UART_LSR);
 991         } while (!(lsr & UART_LSR_THRE));
 992
 993         /* Send the character out. */
 994         serial_out(up, UART_TX, ch);
 995
 996         spin_unlock_irqrestore(&sunsu_serio_lock, flags);
 997
 998         return 0;
 999 }
1000
1001 static int sunsu_serio_open(struct serio *serio)
1002 {
1003         struct uart_sunsu_port *up = serio->port_data;
1004         unsigned long flags;
1005         int ret;
1006
1007         spin_lock_irqsave(&sunsu_serio_lock, flags);
1008         if (!up->serio_open) {
1009                 up->serio_open = 1;
1010                 ret = 0;
1011         } else
1012                 ret = -EBUSY;
1013         spin_unlock_irqrestore(&sunsu_serio_lock, flags);
1014
1015         return ret;
1016 }
1017
1018 static void sunsu_serio_close(struct serio *serio)
1019 {
1020         struct uart_sunsu_port *up = serio->port_data;
1021         unsigned long flags;
1022
1023         spin_lock_irqsave(&sunsu_serio_lock, flags);
1024         up->serio_open = 0;
1025         spin_unlock_irqrestore(&sunsu_serio_lock, flags);
1026 }
1027
1028 #endif /* CONFIG_SERIO */
1029
1030 static void sunsu_autoconfig(struct uart_sunsu_port *up)
1031 {
1032         unsigned char status1, status2, scratch, scratch2, scratch3;
1033         unsigned char save_lcr, save_mcr;
1034         struct linux_ebus_device *dev = NULL;
1035         struct linux_ebus *ebus;
1036 #ifdef CONFIG_SPARC64
1037         struct sparc_isa_bridge *isa_br;
1038         struct sparc_isa_device *isa_dev;
1039 #endif
1040 #ifndef CONFIG_SPARC64
1041         struct linux_prom_registers reg0;
1042 #endif
1043         unsigned long flags;
1044
1045         if (!up->port_node || !up->su_type)
1046                 return;
1047
1048         up->type_probed = PORT_UNKNOWN;
1049         up->port.iotype = UPIO_MEM;
1050
1051         /*
1052          * First we look for Ebus-bases su's
1053          */
1054         for_each_ebus(ebus) {
1055                 for_each_ebusdev(dev, ebus) {
1056                         if (dev->prom_node == up->port_node) {
1057                                 /*
1058                                  * The EBus is broken on sparc; it delivers
1059                                  * virtual addresses in resources. Oh well...
1060                                  * This is correct on sparc64, though.
1061                                  */
1062                                 up->port.membase = (char *) dev->resource[0].start;
1063                                 /*
1064                                  * This is correct on both architectures.
1065                                  */
1066                                 up->port.mapbase = dev->resource[0].start;
1067                                 up->port.irq = dev->irqs[0];
1068                                 goto ebus_done;
1069                         }
1070                 }
1071         }
1072
1073 #ifdef CONFIG_SPARC64
1074         for_each_isa(isa_br) {
1075                 for_each_isadev(isa_dev, isa_br) {
1076                         if (isa_dev->prom_node == up->port_node) {
1077                                 /* Same on sparc64. Cool architecure... */
1078                                 up->port.membase = (char *) isa_dev->resource.start;
1079                                 up->port.mapbase = isa_dev->resource.start;
1080                                 up->port.irq = isa_dev->irq;
1081                                 goto ebus_done;
1082                         }
1083                 }
1084         }
1085 #endif
1086
1087 #ifdef CONFIG_SPARC64
1088         /*
1089          * Not on Ebus, bailing.
1090          */
1091         return;
1092 #else
1093         /*
1094          * Not on Ebus, must be OBIO.
1095          */
1096         if (prom_getproperty(up->port_node, "reg",
1097                              (char *)&reg0, sizeof(reg0)) == -1) {
1098                 prom_printf("sunsu: no \"reg\" property\n");
1099                 return;
1100         }
1101         prom_apply_obio_ranges(&reg0, 1);
1102         if (reg0.which_io != 0) {       /* Just in case... */
1103                 prom_printf("sunsu: bus number nonzero: 0x%x:%x\n",
1104                     reg0.which_io, reg0.phys_addr);
1105                 return;
1106         }
1107         up->port.mapbase = reg0.phys_addr;
1108         if ((up->port.membase = ioremap(reg0.phys_addr, reg0.reg_size)) == 0) {
1109                 prom_printf("sunsu: Cannot map registers.\n");
1110                 return;
1111         }
1112
1113         /*
1114          * 0x20 is sun4m thing, Dave Redman heritage.
1115          * See arch/sparc/kernel/irq.c.
1116          */
1117 #define IRQ_4M(n)       ((n)|0x20)
1118
1119         /*
1120          * There is no intr property on MrCoffee, so hardwire it.
1121          */
1122         up->port.irq = IRQ_4M(13);
1123 #endif
1124
1125 ebus_done:
1126
1127         spin_lock_irqsave(&up->port.lock, flags);
1128
1129         if (!(up->port.flags & UPF_BUGGY_UART)) {
1130                 /*
1131                  * Do a simple existence test first; if we fail this, there's
1132                  * no point trying anything else.
1133                  *
1134                  * 0x80 is used as a nonsense port to prevent against false
1135                  * positives due to ISA bus float.  The assumption is that
1136                  * 0x80 is a non-existent port; which should be safe since
1137                  * include/asm/io.h also makes this assumption.
1138                  */
1139                 scratch = serial_inp(up, UART_IER);
1140                 serial_outp(up, UART_IER, 0);
1141 #ifdef __i386__
1142                 outb(0xff, 0x080);
1143 #endif
1144                 scratch2 = serial_inp(up, UART_IER);
1145                 serial_outp(up, UART_IER, 0x0f);
1146 #ifdef __i386__
1147                 outb(0, 0x080);
1148 #endif
1149                 scratch3 = serial_inp(up, UART_IER);
1150                 serial_outp(up, UART_IER, scratch);
1151                 if (scratch2 != 0 || scratch3 != 0x0F)
1152                         goto out;       /* We failed; there's nothing here */
1153         }
1154
1155         save_mcr = serial_in(up, UART_MCR);
1156         save_lcr = serial_in(up, UART_LCR);
1157
1158         /*
1159          * Check to see if a UART is really there.  Certain broken
1160          * internal modems based on the Rockwell chipset fail this
1161          * test, because they apparently don't implement the loopback
1162          * test mode.  So this test is skipped on the COM 1 through
1163          * COM 4 ports.  This *should* be safe, since no board
1164          * manufacturer would be stupid enough to design a board
1165          * that conflicts with COM 1-4 --- we hope!
1166          */
1167         if (!(up->port.flags & UPF_SKIP_TEST)) {
1168                 serial_outp(up, UART_MCR, UART_MCR_LOOP | 0x0A);
1169                 status1 = serial_inp(up, UART_MSR) & 0xF0;
1170                 serial_outp(up, UART_MCR, save_mcr);
1171                 if (status1 != 0x90)
1172                         goto out;       /* We failed loopback test */
1173         }
1174         serial_outp(up, UART_LCR, 0xBF);        /* set up for StarTech test */
1175         serial_outp(up, UART_EFR, 0);           /* EFR is the same as FCR */
1176         serial_outp(up, UART_LCR, 0);
1177         serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
1178         scratch = serial_in(up, UART_IIR) >> 6;
1179         switch (scratch) {
1180                 case 0:
1181                         up->port.type = PORT_16450;
1182                         break;
1183                 case 1:
1184                         up->port.type = PORT_UNKNOWN;
1185                         break;
1186                 case 2:
1187                         up->port.type = PORT_16550;
1188                         break;
1189                 case 3:
1190                         up->port.type = PORT_16550A;
1191                         break;
1192         }
1193         if (up->port.type == PORT_16550A) {
1194                 /* Check for Startech UART's */
1195                 serial_outp(up, UART_LCR, UART_LCR_DLAB);
1196                 if (serial_in(up, UART_EFR) == 0) {
1197                         up->port.type = PORT_16650;
1198                 } else {
1199                         serial_outp(up, UART_LCR, 0xBF);
1200                         if (serial_in(up, UART_EFR) == 0)
1201                                 up->port.type = PORT_16650V2;
1202                 }
1203         }
1204         if (up->port.type == PORT_16550A) {
1205                 /* Check for TI 16750 */
1206                 serial_outp(up, UART_LCR, save_lcr | UART_LCR_DLAB);
1207                 serial_outp(up, UART_FCR,
1208                             UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
1209                 scratch = serial_in(up, UART_IIR) >> 5;
1210                 if (scratch == 7) {
1211                         /*
1212                          * If this is a 16750, and not a cheap UART
1213                          * clone, then it should only go into 64 byte
1214                          * mode if the UART_FCR7_64BYTE bit was set
1215                          * while UART_LCR_DLAB was latched.
1216                          */
1217                         serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
1218                         serial_outp(up, UART_LCR, 0);
1219                         serial_outp(up, UART_FCR,
1220                                     UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
1221                         scratch = serial_in(up, UART_IIR) >> 5;
1222                         if (scratch == 6)
1223                                 up->port.type = PORT_16750;
1224                 }
1225                 serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
1226         }
1227         serial_outp(up, UART_LCR, save_lcr);
1228         if (up->port.type == PORT_16450) {
1229                 scratch = serial_in(up, UART_SCR);
1230                 serial_outp(up, UART_SCR, 0xa5);
1231                 status1 = serial_in(up, UART_SCR);
1232                 serial_outp(up, UART_SCR, 0x5a);
1233                 status2 = serial_in(up, UART_SCR);
1234                 serial_outp(up, UART_SCR, scratch);
1235
1236                 if ((status1 != 0xa5) || (status2 != 0x5a))
1237                         up->port.type = PORT_8250;
1238         }
1239
1240         up->port.fifosize = uart_config[up->port.type].dfl_xmit_fifo_size;
1241
1242         if (up->port.type == PORT_UNKNOWN)
1243                 goto out;
1244         up->type_probed = up->port.type;        /* XXX */
1245
1246         /*
1247          * Reset the UART.
1248          */
1249 #ifdef CONFIG_SERIAL_8250_RSA
1250         if (up->port.type == PORT_RSA)
1251                 serial_outp(up, UART_RSA_FRR, 0);
1252 #endif
1253         serial_outp(up, UART_MCR, save_mcr);
1254         serial_outp(up, UART_FCR, (UART_FCR_ENABLE_FIFO |
1255                                      UART_FCR_CLEAR_RCVR |
1256                                      UART_FCR_CLEAR_XMIT));
1257         serial_outp(up, UART_FCR, 0);
1258         (void)serial_in(up, UART_RX);
1259         serial_outp(up, UART_IER, 0);
1260
1261 out:
1262         spin_unlock_irqrestore(&up->port.lock, flags);
1263 }
1264
1265 static struct uart_driver sunsu_reg = {
1266         .owner                  = THIS_MODULE,
1267         .driver_name            = "serial",
1268         .devfs_name             = "tts/",
1269         .dev_name               = "ttyS",
1270         .major                  = TTY_MAJOR,
1271 };
1272
1273 static int __init sunsu_kbd_ms_init(struct uart_sunsu_port *up, int channel)
1274 {
1275         int quot, baud;
1276 #ifdef CONFIG_SERIO
1277         struct serio *serio;
1278 #endif
1279
1280         spin_lock_init(&up->port.lock);
1281         up->port.line = channel;
1282         up->port.type = PORT_UNKNOWN;
1283         up->port.uartclk = (SU_BASE_BAUD * 16);
1284
1285         if (up->su_type == SU_PORT_KBD) {
1286                 up->cflag = B1200 | CS8 | CLOCAL | CREAD;
1287                 baud = 1200;
1288         } else {
1289                 up->cflag = B4800 | CS8 | CLOCAL | CREAD;
1290                 baud = 4800;
1291         }
1292         quot = up->port.uartclk / (16 * baud);
1293
1294         sunsu_autoconfig(up);
1295         if (up->port.type == PORT_UNKNOWN)
1296                 return -1;
1297
1298         printk(KERN_INFO "su%d at 0x%p (irq = %s) is a %s\n",
1299                channel,
1300                up->port.membase, __irq_itoa(up->port.irq),
1301                sunsu_type(&up->port));
1302
1303 #ifdef CONFIG_SERIO
1304         up->serio = serio = kmalloc(sizeof(struct serio), GFP_KERNEL);
1305         if (serio) {
1306                 memset(serio, 0, sizeof(*serio));
1307
1308                 serio->port_data = up;
1309
1310                 serio->id.type = SERIO_RS232;
1311                 if (up->su_type == SU_PORT_KBD) {
1312                         serio->id.proto = SERIO_SUNKBD;
1313                         strlcpy(serio->name, "sukbd", sizeof(serio->name));
1314                 } else {
1315                         serio->id.proto = SERIO_SUN;
1316                         serio->id.extra = 1;
1317                         strlcpy(serio->name, "sums", sizeof(serio->name));
1318                 }
1319                 strlcpy(serio->phys, (channel == 0 ? "su/serio0" : "su/serio1"),
1320                         sizeof(serio->phys));
1321
1322                 serio->write = sunsu_serio_write;
1323                 serio->open = sunsu_serio_open;
1324                 serio->close = sunsu_serio_close;
1325
1326                 serio_register_port(serio);
1327         } else {
1328                 printk(KERN_WARNING "su%d: not enough memory for serio port\n",
1329                         channel);
1330         }
1331 #endif
1332
1333         sunsu_change_speed(&up->port, up->cflag, 0, quot);
1334
1335         sunsu_startup(&up->port);
1336         return 0;
1337 }
1338
1339 /*
1340  * ------------------------------------------------------------
1341  * Serial console driver
1342  * ------------------------------------------------------------
1343  */
1344
1345 #ifdef CONFIG_SERIAL_SUNSU_CONSOLE
1346
1347 #define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
1348
1349 /*
1350  *      Wait for transmitter & holding register to empty
1351  */
1352 static __inline__ void wait_for_xmitr(struct uart_sunsu_port *up)
1353 {
1354         unsigned int status, tmout = 10000;
1355
1356         /* Wait up to 10ms for the character(s) to be sent. */
1357         do {
1358                 status = serial_in(up, UART_LSR);
1359
1360                 if (status & UART_LSR_BI)
1361                         up->lsr_break_flag = UART_LSR_BI;
1362
1363                 if (--tmout == 0)
1364                         break;
1365                 udelay(1);
1366         } while ((status & BOTH_EMPTY) != BOTH_EMPTY);
1367
1368         /* Wait up to 1s for flow control if necessary */
1369         if (up->port.flags & UPF_CONS_FLOW) {
1370                 tmout = 1000000;
1371                 while (--tmout &&
1372                        ((serial_in(up, UART_MSR) & UART_MSR_CTS) == 0))
1373                         udelay(1);
1374         }
1375 }
1376
1377 static void sunsu_console_putchar(struct uart_port *port, int ch)
1378 {
1379         struct uart_sunsu_port *up = (struct uart_sunsu_port *)port;
1380
1381         wait_for_xmitr(up);
1382         serial_out(up, UART_TX, ch);
1383 }
1384
1385 /*
1386  *      Print a string to the serial port trying not to disturb
1387  *      any possible real use of the port...
1388  */
1389 static void sunsu_console_write(struct console *co, const char *s,
1390                                 unsigned int count)
1391 {
1392         struct uart_sunsu_port *up = &sunsu_ports[co->index];
1393         unsigned int ier;
1394
1395         /*
1396          *      First save the UER then disable the interrupts
1397          */
1398         ier = serial_in(up, UART_IER);
1399         serial_out(up, UART_IER, 0);
1400
1401         uart_console_write(&up->port, s, count, sunsu_console_putchar);
1402
1403         /*
1404          *      Finally, wait for transmitter to become empty
1405          *      and restore the IER
1406          */
1407         wait_for_xmitr(up);
1408         serial_out(up, UART_IER, ier);
1409 }
1410
1411 /*
1412  *      Setup initial baud/bits/parity. We do two things here:
1413  *      - construct a cflag setting for the first su_open()
1414  *      - initialize the serial port
1415  *      Return non-zero if we didn't find a serial port.
1416  */
1417 static int sunsu_console_setup(struct console *co, char *options)
1418 {
1419         struct uart_port *port;
1420         int baud = 9600;
1421         int bits = 8;
1422         int parity = 'n';
1423         int flow = 'n';
1424
1425         printk("Console: ttyS%d (SU)\n",
1426                (sunsu_reg.minor - 64) + co->index);
1427
1428         /*
1429          * Check whether an invalid uart number has been specified, and
1430          * if so, search for the first available port that does have
1431          * console support.
1432          */
1433         if (co->index >= UART_NR)
1434                 co->index = 0;
1435         port = &sunsu_ports[co->index].port;
1436
1437         /*
1438          * Temporary fix.
1439          */
1440         spin_lock_init(&port->lock);
1441
1442         if (options)
1443                 uart_parse_options(options, &baud, &parity, &bits, &flow);
1444
1445         return uart_set_options(port, co, baud, parity, bits, flow);
1446 }
1447
1448 static struct console sunsu_cons = {
1449         .name   =       "ttyS",
1450         .write  =       sunsu_console_write,
1451         .device =       uart_console_device,
1452         .setup  =       sunsu_console_setup,
1453         .flags  =       CON_PRINTBUFFER,
1454         .index  =       -1,
1455         .data   =       &sunsu_reg,
1456 };
1457
1458 /*
1459  *      Register console.
1460  */
1461
1462 static inline struct console *SUNSU_CONSOLE(void)
1463 {
1464         int i;
1465
1466         if (con_is_present())
1467                 return NULL;
1468
1469         for (i = 0; i < UART_NR; i++) {
1470                 int this_minor = sunsu_reg.minor + i;
1471
1472                 if ((this_minor - 64) == (serial_console - 1))
1473                         break;
1474         }
1475         if (i == UART_NR)
1476                 return NULL;
1477         if (sunsu_ports[i].port_node == 0)
1478                 return NULL;
1479
1480         sunsu_cons.index = i;
1481
1482         return &sunsu_cons;
1483 }
1484 #else
1485 #define SUNSU_CONSOLE()                 (NULL)
1486 #define sunsu_serial_console_init()     do { } while (0)
1487 #endif
1488
1489 static int __init sunsu_serial_init(void)
1490 {
1491         int instance, ret, i;
1492
1493         /* How many instances do we need?  */
1494         instance = 0;
1495         for (i = 0; i < UART_NR; i++) {
1496                 struct uart_sunsu_port *up = &sunsu_ports[i];
1497
1498                 if (up->su_type == SU_PORT_MS ||
1499                     up->su_type == SU_PORT_KBD)
1500                         continue;
1501
1502                 spin_lock_init(&up->port.lock);
1503                 up->port.flags |= UPF_BOOT_AUTOCONF;
1504                 up->port.type = PORT_UNKNOWN;
1505                 up->port.uartclk = (SU_BASE_BAUD * 16);
1506
1507                 sunsu_autoconfig(up);
1508                 if (up->port.type == PORT_UNKNOWN)
1509                         continue;
1510
1511                 up->port.line = instance++;
1512                 up->port.ops = &sunsu_pops;
1513         }
1514
1515         sunsu_reg.minor = sunserial_current_minor;
1516
1517         sunsu_reg.nr = instance;
1518
1519         ret = uart_register_driver(&sunsu_reg);
1520         if (ret < 0)
1521                 return ret;
1522
1523         sunsu_reg.tty_driver->name_base = sunsu_reg.minor - 64;
1524
1525         sunserial_current_minor += instance;
1526
1527         sunsu_reg.cons = SUNSU_CONSOLE();
1528
1529         for (i = 0; i < UART_NR; i++) {
1530                 struct uart_sunsu_port *up = &sunsu_ports[i];
1531
1532                 /* Do not register Keyboard/Mouse lines with UART
1533                  * layer.
1534                  */
1535                 if (up->su_type == SU_PORT_MS ||
1536                     up->su_type == SU_PORT_KBD)
1537                         continue;
1538
1539                 if (up->port.type == PORT_UNKNOWN)
1540                         continue;
1541
1542                 uart_add_one_port(&sunsu_reg, &up->port);
1543         }
1544
1545         return 0;
1546 }
1547
1548 static int su_node_ok(int node, char *name, int namelen)
1549 {
1550         if (strncmp(name, "su", namelen) == 0 ||
1551             strncmp(name, "su_pnp", namelen) == 0)
1552                 return 1;
1553
1554         if (strncmp(name, "serial", namelen) == 0) {
1555                 char compat[32];
1556                 int clen;
1557
1558                 /* Is it _really_ a 'su' device? */
1559                 clen = prom_getproperty(node, "compatible", compat, sizeof(compat));
1560                 if (clen > 0) {
1561                         if (strncmp(compat, "sab82532", 8) == 0) {
1562                                 /* Nope, Siemens serial, not for us. */
1563                                 return 0;
1564                         }
1565                 }
1566                 return 1;
1567         }
1568
1569         return 0;
1570 }
1571
1572 #define SU_PROPSIZE     128
1573
1574 /*
1575  * Scan status structure.
1576  * "prop" is a local variable but it eats stack to keep it in each
1577  * stack frame of a recursive procedure.
1578  */
1579 struct su_probe_scan {
1580         int msnode, kbnode;     /* PROM nodes for mouse and keyboard */
1581         int msx, kbx;           /* minors for mouse and keyboard */
1582         int devices;            /* scan index */
1583         char prop[SU_PROPSIZE];
1584 };
1585
1586 /*
1587  * We have several platforms which present 'su' in different parts
1588  * of the device tree. 'su' may be found under obio, ebus, isa and pci.
1589  * We walk over the tree and find them wherever PROM hides them.
1590  */
1591 static void __init su_probe_any(struct su_probe_scan *t, int sunode)
1592 {
1593         struct uart_sunsu_port *up;
1594         int len;
1595
1596         if (t->devices >= UART_NR)
1597                 return;
1598
1599         for (; sunode != 0; sunode = prom_getsibling(sunode)) {
1600                 len = prom_getproperty(sunode, "name", t->prop, SU_PROPSIZE);
1601                 if (len <= 1)
1602                         continue;               /* Broken PROM node */
1603
1604                 if (su_node_ok(sunode, t->prop, len)) {
1605                         up = &sunsu_ports[t->devices];
1606                         if (t->kbnode != 0 && sunode == t->kbnode) {
1607                                 t->kbx = t->devices;
1608                                 up->su_type = SU_PORT_KBD;
1609                         } else if (t->msnode != 0 && sunode == t->msnode) {
1610                                 t->msx = t->devices;
1611                                 up->su_type = SU_PORT_MS;
1612                         } else {
1613 #ifdef CONFIG_SPARC64
1614                                 /*
1615                                  * Do not attempt to use the truncated
1616                                  * keyboard/mouse ports as serial ports
1617                                  * on Ultras with PC keyboard attached.
1618                                  */
1619                                 if (prom_getbool(sunode, "mouse"))
1620                                         continue;
1621                                 if (prom_getbool(sunode, "keyboard"))
1622                                         continue;
1623 #endif
1624                                 up->su_type = SU_PORT_PORT;
1625                         }
1626                         up->port_node = sunode;
1627                         ++t->devices;
1628                 } else {
1629                         su_probe_any(t, prom_getchild(sunode));
1630                 }
1631         }
1632 }
1633
1634 static int __init sunsu_probe(void)
1635 {
1636         int node;
1637         int len;
1638         struct su_probe_scan scan;
1639
1640         /*
1641          * First, we scan the tree.
1642          */
1643         scan.devices = 0;
1644         scan.msx = -1;
1645         scan.kbx = -1;
1646         scan.kbnode = 0;
1647         scan.msnode = 0;
1648
1649         /*
1650          * Get the nodes for keyboard and mouse from 'aliases'...
1651          */
1652         node = prom_getchild(prom_root_node);
1653         node = prom_searchsiblings(node, "aliases");
1654         if (node != 0) {
1655                 len = prom_getproperty(node, "keyboard", scan.prop, SU_PROPSIZE);
1656                 if (len > 0) {
1657                         scan.prop[len] = 0;
1658                         scan.kbnode = prom_finddevice(scan.prop);
1659                 }
1660
1661                 len = prom_getproperty(node, "mouse", scan.prop, SU_PROPSIZE);
1662                 if (len > 0) {
1663                         scan.prop[len] = 0;
1664                         scan.msnode = prom_finddevice(scan.prop);
1665                 }
1666         }
1667
1668         su_probe_any(&scan, prom_getchild(prom_root_node));
1669
1670         /*
1671          * Second, we process the special case of keyboard and mouse.
1672          *
1673          * Currently if we got keyboard and mouse hooked to "su" ports
1674          * we do not use any possible remaining "su" as a serial port.
1675          * Thus, we ignore values of .msx and .kbx, then compact ports.
1676          */
1677         if (scan.msx != -1 && scan.kbx != -1) {
1678                 sunsu_ports[0].su_type = SU_PORT_MS;
1679                 sunsu_ports[0].port_node = scan.msnode;
1680                 sunsu_kbd_ms_init(&sunsu_ports[0], 0);
1681
1682                 sunsu_ports[1].su_type = SU_PORT_KBD;
1683                 sunsu_ports[1].port_node = scan.kbnode;
1684                 sunsu_kbd_ms_init(&sunsu_ports[1], 1);
1685
1686                 return 0;
1687         }
1688
1689         if (scan.msx != -1 || scan.kbx != -1) {
1690                 printk("sunsu_probe: cannot match keyboard and mouse, confused\n");
1691                 return -ENODEV;
1692         }
1693
1694         if (scan.devices == 0)
1695                 return -ENODEV;
1696
1697         /*
1698          * Console must be initiated after the generic initialization.
1699          */
1700         sunsu_serial_init();
1701
1702         return 0;
1703 }
1704
1705 static void __exit sunsu_exit(void)
1706 {
1707         int i, saw_uart;
1708
1709         saw_uart = 0;
1710         for (i = 0; i < UART_NR; i++) {
1711                 struct uart_sunsu_port *up = &sunsu_ports[i];
1712
1713                 if (up->su_type == SU_PORT_MS ||
1714                     up->su_type == SU_PORT_KBD) {
1715 #ifdef CONFIG_SERIO
1716                         if (up->serio) {
1717                                 serio_unregister_port(up->serio);
1718                                 up->serio = NULL;
1719                         }
1720 #endif
1721                 } else if (up->port.type != PORT_UNKNOWN) {
1722                         uart_remove_one_port(&sunsu_reg, &up->port);
1723                         saw_uart++;
1724                 }
1725         }
1726
1727         if (saw_uart)
1728                 uart_unregister_driver(&sunsu_reg);
1729 }
1730
1731 module_init(sunsu_probe);
1732 module_exit(sunsu_exit);
1733 MODULE_LICENSE("GPL");