root/drivers/char/serial.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. serial_in
  2. serial_inp
  3. serial_out
  4. serial_outp
  5. rs_stop
  6. rs_start
  7. rs_probe
  8. rs_sched_event
  9. receive_chars
  10. transmit_chars
  11. check_modem_status
  12. figure_RS_timer
  13. rs_interrupt
  14. handle_rs_break
  15. do_softint
  16. rs_timer
  17. grab_all_interrupts
  18. free_all_interrupts
  19. figure_IRQ_timeout
  20. startup
  21. shutdown
  22. change_speed
  23. restart_port
  24. rs_write
  25. rs_throttle
  26. get_serial_info
  27. set_serial_info
  28. get_modem_info
  29. set_modem_info
  30. do_autoconfig
  31. send_break
  32. check_wild_interrupts
  33. rs_ioctl
  34. rs_set_termios
  35. rs_close
  36. rs_hangup
  37. block_til_ready
  38. rs_open
  39. show_serial_version
  40. get_auto_irq
  41. do_auto_irq
  42. autoconfig
  43. rs_init

   1 /*
   2  *  linux/kernel/serial.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *
   6  *  Extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92.  Now
   7  *  much more extensible to support other serial cards based on the
   8  *  16450/16550A UART's.  Added support for the AST FourPort and the
   9  *  Accent Async board.  
  10  *
  11  *  set_serial_info fixed to set the flags, custom divisor, and uart
  12  *      type fields.  Fix suggested by Michael K. Johnson 12/12/92.
  13  *
  14  * This module exports the following rs232 io functions:
  15  *
  16  *      long rs_init(long);
  17  *      int  rs_open(struct tty_struct * tty, struct file * filp)
  18  */
  19 
  20 #include <linux/errno.h>
  21 #include <linux/signal.h>
  22 #include <linux/sched.h>
  23 #include <linux/timer.h>
  24 #include <linux/tty.h>
  25 #include <linux/serial.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/config.h>
  28 #include <linux/major.h>
  29 #include <linux/string.h>
  30 #include <linux/fcntl.h>
  31 #include <linux/ptrace.h>
  32 
  33 #include <asm/system.h>
  34 #include <asm/io.h>
  35 #include <asm/segment.h>
  36 #include <asm/bitops.h>
  37 
  38 /*
  39  * Serial driver configuration section.  Here are the various options:
  40  *
  41  * CONFIG_AUTO_IRQ
  42  *              Enables automatic IRQ detection.  I've put in some
  43  *              fixes to this which should make this work much more
  44  *              cleanly than it used to in 0.98pl2-6.  It should be
  45  *              much less vulnerable to false IRQs now.
  46  * 
  47  * CONFIG_AST_FOURPORT
  48  *              Enables support for the AST Fourport serial port.
  49  * 
  50  * CONFIG_ACCENT_ASYNC
  51  *              Enables support for the Accent Async 4 port serial
  52  *              port.
  53  *
  54  * CONFIG_HUB6
  55  *              Enables support for the venerable Bell Technologies
  56  *              HUB6 card.
  57  */
  58 
  59 #undef ISR_HACK
  60 
  61 /*
  62  * rs_event             - Bitfield of serial lines that events pending
  63  *                              to be processed at the next clock tick.
  64  * IRQ_timeout          - How long the timeout should be for each IRQ
  65  *                              should be after the IRQ has been active.
  66  * IRQ_timer            - Array of timeout values for each interrupt IRQ.
  67  *                              This is based on jiffies; not offsets.
  68  * 
  69  * We assume here that int's are 32 bits, so an array of two gives us
  70  * 64 lines, which is the maximum we can support.
  71  */
  72 static int rs_event[2];
  73 
  74 static struct async_struct *IRQ_ports[16];
  75 static int IRQ_active;
  76 static unsigned long IRQ_timer[16];
  77 static int IRQ_timeout[16];
  78 static volatile int rs_irq_triggered;
  79 static volatile int rs_triggered;
  80 static int rs_wild_int_mask;
  81 
  82 static void autoconfig(struct async_struct * info);
  83 static void change_speed(unsigned int line);
  84         
  85 /*
  86  * This assumes you have a 1.8432 MHz clock for your UART.
  87  *
  88  * It'd be nice if someone built a serial card with a 24.576 MHz
  89  * clock, since the 16550A is capable of handling a top speed of 1.5
  90  * megabits/second; but this requires the faster clock.
  91  */
  92 #define BASE_BAUD ( 1843200 / 16 )
  93 
  94 #ifdef CONFIG_AUTO_IRQ
  95 #define AUTO_IRQ_FLAG ASYNC_AUTO_IRQ
  96 #else
  97 #define AUTO_IRQ_FLAG 0
  98 #endif
  99 
 100 /* Standard COM flags (except for COM4, because of the 8514 problem) */
 101 #define STD_COM_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST | AUTO_IRQ_FLAG)
 102 #define STD_COM4_FLAGS (ASYNC_BOOT_AUTOCONF | AUTO_IRQ_FLAG)
 103 
 104 #ifdef CONFIG_AST_FOURPORT
 105 #define FOURPORT_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_FOURPORT | AUTO_IRQ_FLAG)
 106 #else
 107 #define FOURPORT_FLAGS (ASYNC_FOURPORT | AUTO_IRQ_FLAG)
 108 #endif
 109 
 110 #ifdef CONFIG_ACCENT_ASYNC
 111 #define ACCENT_FLAGS (ASYNC_BOOT_AUTOCONF | AUTO_IRQ_FLAG)
 112 #else
 113 #define ACCENT_FLAGS AUTO_IRQ_FLAG
 114 #endif
 115 
 116 #ifdef CONFIG_BOCA
 117 #define BOCA_FLAGS (ASYNC_BOOT_AUTOCONF | AUTO_IRQ_FLAG)
 118 #else
 119 #define BOCA_FLAGS AUTO_IRQ_FLAG
 120 #endif
 121 
 122 #ifdef CONFIG_HUB6
 123 #define HUB6_FLAGS (ASYNC_BOOT_AUTOCONF)
 124 #else
 125 #define HUB6_FLAGS 0
 126 #endif
 127         
 128 /*
 129  * The following define the access methods for the HUB6 card. All
 130  * access is through two ports for all 24 possible chips. The card is
 131  * selected through the high 2 bits, the port on that card with the
 132  * "middle" 3 bits, and the register on that port with the bottom
 133  * 3 bits.
 134  *
 135  * While the access port and interrupt is configurable, the default
 136  * port locations are 0x302 for the port control register, and 0x303
 137  * for the data read/write register. Normally, the interrupt is at irq3
 138  * but can be anything from 3 to 7 inclusive. Note tht using 3 will
 139  * require disabling com2.
 140  */
 141 
 142 #define C_P(card,port) (((card)<<6|(port)<<3) + 1)
 143 
 144 struct async_struct rs_table[] = {
 145         /* UART CLK   PORT IRQ     FLAGS        */
 146         { BASE_BAUD, 0x3F8, 4, STD_COM_FLAGS },         /* ttyS0 */
 147         { BASE_BAUD, 0x2F8, 3, STD_COM_FLAGS },         /* ttyS1 */
 148         { BASE_BAUD, 0x3E8, 4, STD_COM_FLAGS },         /* ttyS2 */
 149         { BASE_BAUD, 0x2E8, 3, STD_COM4_FLAGS },        /* ttyS3 */
 150 
 151         { BASE_BAUD, 0x1A0, 9, FOURPORT_FLAGS },        /* ttyS4 */
 152         { BASE_BAUD, 0x1A8, 9, FOURPORT_FLAGS },        /* ttyS5 */
 153         { BASE_BAUD, 0x1B0, 9, FOURPORT_FLAGS },        /* ttyS6 */
 154         { BASE_BAUD, 0x1B8, 9, FOURPORT_FLAGS },        /* ttyS7 */
 155 
 156         { BASE_BAUD, 0x2A0, 5, FOURPORT_FLAGS },        /* ttyS8 */
 157         { BASE_BAUD, 0x2A8, 5, FOURPORT_FLAGS },        /* ttyS9 */
 158         { BASE_BAUD, 0x2B0, 5, FOURPORT_FLAGS },        /* ttyS10 */
 159         { BASE_BAUD, 0x2B8, 5, FOURPORT_FLAGS },        /* ttyS11 */
 160         
 161         { BASE_BAUD, 0x330, 4, ACCENT_FLAGS },          /* ttyS12 */
 162         { BASE_BAUD, 0x338, 4, ACCENT_FLAGS },          /* ttyS13 */
 163         { BASE_BAUD, 0x000, 0, 0 },     /* ttyS14 (spare; user configurable) */
 164         { BASE_BAUD, 0x000, 0, 0 },     /* ttyS15 (spare; user configurable) */
 165 
 166         { BASE_BAUD, 0x100, 12, BOCA_FLAGS },   /* ttyS16 */
 167         { BASE_BAUD, 0x108, 12, BOCA_FLAGS },   /* ttyS17 */
 168         { BASE_BAUD, 0x110, 12, BOCA_FLAGS },   /* ttyS18 */
 169         { BASE_BAUD, 0x118, 12, BOCA_FLAGS },   /* ttyS19 */
 170         { BASE_BAUD, 0x120, 12, BOCA_FLAGS },   /* ttyS20 */
 171         { BASE_BAUD, 0x128, 12, BOCA_FLAGS },   /* ttyS21 */
 172         { BASE_BAUD, 0x130, 12, BOCA_FLAGS },   /* ttyS22 */
 173         { BASE_BAUD, 0x138, 12, BOCA_FLAGS },   /* ttyS23 */
 174         { BASE_BAUD, 0x140, 12, BOCA_FLAGS },   /* ttyS24 */
 175         { BASE_BAUD, 0x148, 12, BOCA_FLAGS },   /* ttyS25 */
 176         { BASE_BAUD, 0x150, 12, BOCA_FLAGS },   /* ttyS26 */
 177         { BASE_BAUD, 0x158, 12, BOCA_FLAGS },   /* ttyS27 */
 178         { BASE_BAUD, 0x160, 12, BOCA_FLAGS },   /* ttyS28 */
 179         { BASE_BAUD, 0x168, 12, BOCA_FLAGS },   /* ttyS29 */
 180         { BASE_BAUD, 0x170, 12, BOCA_FLAGS },   /* ttyS30 */
 181         { BASE_BAUD, 0x178, 12, BOCA_FLAGS },   /* ttyS31 */
 182 
 183 /* You can have up to four HUB6's in the system, but I've only
 184  * included two cards here for a total of twelve ports.
 185  */
 186         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,0) },  /* ttyS32 */
 187         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,1) },  /* ttyS33 */
 188         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,2) },  /* ttyS34 */
 189         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,3) },  /* ttyS35 */
 190         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,4) },  /* ttyS36 */
 191         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,5) },  /* ttyS37 */
 192         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,0) },  /* ttyS32 */
 193         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,1) },  /* ttyS33 */
 194         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,2) },  /* ttyS34 */
 195         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,3) },  /* ttyS35 */
 196         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,4) },  /* ttyS36 */
 197         { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,5) },  /* ttyS37 */
 198 };
 199 
 200 #define NR_PORTS        (sizeof(rs_table)/sizeof(struct async_struct))
 201 
 202 /*
 203  * This is used to figure out the divsor speeds and the timeouts
 204  */
 205 static int baud_table[] = {
 206         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
 207         9600, 19200, 38400, 57600, 115200, 0 };
 208 
 209 static void rs_throttle(struct tty_struct * tty, int status);
 210 
 211 static inline unsigned int serial_in(struct async_struct *info, int offset)
     /* [previous][next][first][last][top][bottom][index][help] */
 212 {
 213     if (info->hub6) {
 214         outb(info->hub6 - 1 + offset, info->port);
 215         return inb(info->port+1);
 216     } else
 217         return inb(info->port + offset);
 218 }
 219 
 220 static inline unsigned int serial_inp(struct async_struct *info, int offset)
     /* [previous][next][first][last][top][bottom][index][help] */
 221 {
 222     if (info->hub6) {
 223         outb(info->hub6 - 1 + offset, info->port);
 224         return inb_p(info->port+1);
 225     } else
 226         return inb_p(info->port + offset);
 227 }
 228 
 229 static inline void serial_out(struct async_struct *info, int offset, int value)
     /* [previous][next][first][last][top][bottom][index][help] */
 230 {
 231     if (info->hub6) {
 232         outb(info->hub6 - 1 + offset, info->port);
 233         outb(value, info->port+1);
 234     } else
 235         outb(value, info->port+offset);
 236 }
 237 
 238 static inline void serial_outp(struct async_struct *info, int offset,
     /* [previous][next][first][last][top][bottom][index][help] */
 239                                int value)
 240 {
 241     if (info->hub6) {
 242         outb(info->hub6 - 1 + offset, info->port);
 243         outb_p(value, info->port+1);
 244     } else
 245         outb_p(value, info->port+offset);
 246 }
 247 
 248 /*
 249  * ------------------------------------------------------------
 250  * rs_stop() and rs_start()
 251  *
 252  * This routines are called before setting or resetting tty->stopped.
 253  * They enable or disable transmitter interrupts, as necessary.
 254  * ------------------------------------------------------------
 255  */
 256 static void rs_stop(struct tty_struct *tty)
     /* [previous][next][first][last][top][bottom][index][help] */
 257 {
 258         struct async_struct *info;
 259         
 260         info = rs_table + DEV_TO_SL(tty->line);
 261 
 262         if (info->flags & ASYNC_CLOSING) {
 263                 tty->stopped = 0;
 264                 tty->hw_stopped = 0;
 265                 return;
 266         }
 267 
 268         info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
 269 #ifdef ISR_HACK
 270         serial_out(info, UART_IER, info->IER);
 271 #endif
 272 }
 273 
 274 static void rs_start(struct tty_struct *tty)
     /* [previous][next][first][last][top][bottom][index][help] */
 275 {
 276         struct async_struct *info;
 277         
 278         info = rs_table + DEV_TO_SL(tty->line);
 279         
 280         info->IER = (UART_IER_MSI | UART_IER_RLSI |
 281                      UART_IER_THRI | UART_IER_RDI);
 282 #ifdef ISR_HACK
 283         serial_out(info, UART_IER, info->IER);
 284 #endif
 285 }
 286 
 287 /*
 288  * ----------------------------------------------------------------------
 289  *
 290  * Here starts the interrupt handling routines.  All of the following
 291  * subroutines are declared as inline and are folded into
 292  * rs_interrupt().  They were separated out for readability's sake.
 293  *
 294  * Note: rs_interrupt() is a "fast" interrupt, which means that it
 295  * runs with interrupts turned off.  People who may want to modify
 296  * rs_interrupt() should try to keep the interrupt handler as fast as
 297  * possible.  After you are done making modifications, it is not a bad
 298  * idea to do:
 299  * 
 300  * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
 301  *
 302  * and look at the resulting assemble code in serial.s.
 303  *
 304  *                              - Ted Ts'o (tytso@mit.edu), 7-Mar-93
 305  * -----------------------------------------------------------------------
 306  */
 307 
 308 /*
 309  * This is the serial driver's interrupt routine while we are probing
 310  * for submarines.
 311  */
 312 static void rs_probe(int irq)
     /* [previous][next][first][last][top][bottom][index][help] */
 313 {
 314         rs_irq_triggered = irq;
 315         rs_triggered |= 1 << irq;
 316         return;
 317 }
 318 
 319 /*
 320  * This routine is used by the interrupt handler to schedule
 321  * processing in the software interrupt portion of the driver.
 322  */
 323 static inline void rs_sched_event(struct async_struct *info,
     /* [previous][next][first][last][top][bottom][index][help] */
 324                                   int event)
 325 {
 326         info->event |= 1 << event;
 327         set_bit(info->line, rs_event);
 328         mark_bh(SERIAL_BH);
 329 }
 330 
 331 static inline void receive_chars(struct async_struct *info,
     /* [previous][next][first][last][top][bottom][index][help] */
 332                                  int *status)
 333 {
 334         struct tty_queue * queue;
 335         int head, tail, ch;
 336 
 337 /*
 338  * Just like the LEFT(x) macro, except it uses the loal tail
 339  * and head variables.
 340  */
 341 #define VLEFT ((tail-head-1)&(TTY_BUF_SIZE-1))
 342 
 343         queue = &info->tty->read_q;
 344         head = queue->head;
 345         tail = queue->tail;
 346         do {
 347                 ch = serial_inp(info, UART_RX);
 348                 /*
 349                  * There must be at least 2 characters
 350                  * free in the queue; otherwise we punt.
 351                  */
 352                 if (VLEFT < 2)
 353                         break;
 354                 if (*status & info->read_status_mask) {
 355                         set_bit(head, &info->tty->readq_flags);
 356                         if (*status & (UART_LSR_BI)) {
 357                                 queue->buf[head++]= TTY_BREAK;
 358                                 rs_sched_event(info, RS_EVENT_BREAK);
 359                         } else if (*status & UART_LSR_PE)
 360                                 queue->buf[head++]= TTY_PARITY;
 361                         else if (*status & UART_LSR_FE)
 362                                 queue->buf[head++]= TTY_FRAME;
 363                         else if (*status & UART_LSR_OE)
 364                                 queue->buf[head++]= TTY_OVERRUN;
 365                         head &= TTY_BUF_SIZE-1;
 366                 }
 367                 queue->buf[head++] = ch;
 368                 head &= TTY_BUF_SIZE-1;
 369         } while ((*status = serial_inp(info, UART_LSR)) & UART_LSR_DR);
 370         queue->head = head;
 371         if ((VLEFT < RQ_THRESHOLD_LW) && !set_bit(TTY_RQ_THROTTLED,
 372                                                   &info->tty->flags)) 
 373                 rs_throttle(info->tty, TTY_THROTTLE_RQ_FULL);
 374         rs_sched_event(info, RS_EVENT_READ_PROCESS);
 375 #ifdef SERIAL_DEBUG_INTR
 376         printk("DR...");
 377 #endif
 378 }
 379 
 380 static inline void transmit_chars(struct async_struct *info, int *done_work)
     /* [previous][next][first][last][top][bottom][index][help] */
 381 {
 382         struct tty_queue * queue;
 383         int head, tail, count;
 384         
 385         queue = &info->tty->write_q;
 386         head = queue->head;
 387         tail = queue->tail;
 388         if (head==tail && !info->x_char) {
 389                 info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
 390 #ifdef ISR_HACK
 391                 serial_out(info, UART_IER, info->IER);
 392 #endif
 393                 return;
 394         }
 395         count = info->xmit_fifo_size;
 396         if (info->x_char) {
 397                 serial_outp(info, UART_TX, info->x_char);
 398                 info->x_char = 0;
 399                 count--;
 400         }
 401         while (count-- && (tail != head)) {
 402                 serial_outp(info, UART_TX, queue->buf[tail++]);
 403                 tail &= TTY_BUF_SIZE-1;
 404         }
 405         queue->tail = tail;
 406         if (VLEFT > WAKEUP_CHARS) {
 407                 rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
 408                 if (info->tty->write_data_cnt) {
 409                         set_bit(info->tty->line, &tty_check_write);
 410                         mark_bh(TTY_BH);
 411                 }
 412         }
 413 #ifdef SERIAL_DEBUG_INTR
 414         printk("THRE...");
 415 #endif
 416         (*done_work)++;
 417 }
 418 
 419 static inline int check_modem_status(struct async_struct *info)
     /* [previous][next][first][last][top][bottom][index][help] */
 420 {
 421         int     status;
 422         
 423         status = serial_in(info, UART_MSR);
 424                 
 425         if ((status & UART_MSR_DDCD) && !C_CLOCAL(info->tty)) {
 426 #if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
 427                 printk("ttys%d CD now %s...", info->line,
 428                        (status & UART_MSR_DCD) ? "on" : "off");
 429 #endif          
 430                 if (status & UART_MSR_DCD)
 431                         rs_sched_event(info, RS_EVENT_OPEN_WAKEUP);
 432                 else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) &&
 433                            (info->flags & ASYNC_CALLOUT_NOHUP))) {
 434 #ifdef SERIAL_DEBUG_OPEN
 435                         printk("scheduling hangup...");
 436 #endif
 437                         rs_sched_event(info, RS_EVENT_HANGUP);
 438                 }
 439         }
 440         if (C_CRTSCTS(info->tty) && !(info->flags & ASYNC_CLOSING)) {
 441                 if (info->tty->hw_stopped) {
 442                         if (status & UART_MSR_CTS) {
 443 #ifdef SERIAL_DEBUG_INTR
 444                                 printk("CTS tx start...");
 445 #endif
 446                                 info->tty->hw_stopped = 0;
 447                                 rs_start(info->tty);
 448                                 return 1;
 449                         }
 450                 } else {
 451                         if (!(status & UART_MSR_CTS)) {
 452 #ifdef SERIAL_DEBUG_INTR
 453                                 printk("CTS tx stop...");
 454 #endif
 455                                 info->tty->hw_stopped = 1;
 456                                 rs_stop(info->tty);
 457                         }
 458                 }
 459         }
 460         return 0;
 461 }
 462 
 463 static inline void figure_RS_timer(void)
     /* [previous][next][first][last][top][bottom][index][help] */
 464 {
 465         int     timeout = jiffies + 60*HZ; /* 60 seconds; really big :-) */
 466         int     i, mask;
 467         
 468         if (!IRQ_active)
 469                 return;
 470         for (i=0, mask = 1; mask <= IRQ_active; i++, mask <<= 1) {
 471                 if (!(mask & IRQ_active))
 472                         continue;
 473                 if (IRQ_timer[i] < timeout)
 474                         timeout = IRQ_timer[i];
 475         }
 476         timer_table[RS_TIMER].expires = timeout;
 477         timer_active |= 1 << RS_TIMER;
 478 }
 479 
 480 
 481 /*
 482  * This is the serial driver's generic interrupt routine
 483  */
 484 static void rs_interrupt(int irq)
     /* [previous][next][first][last][top][bottom][index][help] */
 485 {
 486         int status;
 487         struct async_struct * info;
 488         int done, done_work, pass_number, recheck_count;
 489 
 490         rs_irq_triggered = irq;
 491         rs_triggered |= 1 << irq;
 492         
 493         info = IRQ_ports[irq];
 494         done = 1;
 495         done_work = 0;
 496         pass_number = 0;
 497         while (info) {
 498                 if (info->tty &&
 499                     info->tty->termios &&
 500                     (!pass_number ||
 501                      !(serial_inp(info, UART_IIR) & UART_IIR_NO_INT))) {
 502                         done = 0;
 503                         status = serial_inp(info, UART_LSR);
 504                         if (status & UART_LSR_DR) {
 505                                 receive_chars(info, &status);
 506                                 done_work++;
 507                         }
 508                 recheck_count = 0;
 509                 recheck_write:
 510                         if (status & UART_LSR_THRE) {
 511                                 wake_up_interruptible(&info->xmit_wait);
 512                                 if (!info->tty->stopped &&
 513                                     !info->tty->hw_stopped)
 514                                         transmit_chars(info, &done_work);
 515                         }
 516                         if (check_modem_status(info) &&
 517                             (recheck_count++ <= 64))
 518                                 goto recheck_write;
 519 #ifdef SERIAL_DEBUG_INTR
 520                         if (recheck_count > 16)
 521                                 printk("recheck_count = %d\n", recheck_count);
 522 #endif
 523                 }
 524 #ifdef ISR_HACK
 525                 serial_outp(info, UART_IER, 0);
 526                 serial_out(info, UART_IER, info->IER);
 527 #endif
 528                 
 529                 info = info->next_port;
 530                 if (!info && !done) {
 531                         info = IRQ_ports[irq];
 532                         done = 1;
 533                         if (pass_number++ > 64)
 534                                 break;          /* Prevent infinite loops */
 535                 }
 536         }
 537         if ((info = IRQ_ports[irq]) != NULL) {
 538 #ifdef 0
 539                 do {
 540                         serial_outp(info, UART_IER, 0);
 541                         serial_out(info, UART_IER, info->IER);
 542                         info = info->next_port;
 543                 } while (info);
 544 #endif                  
 545                 if (irq && !done_work)
 546                         IRQ_timer[irq] = jiffies + 1500;
 547                 else
 548                         IRQ_timer[irq] = jiffies + IRQ_timeout[irq];
 549                 IRQ_active |= 1 << irq;
 550         }
 551         figure_RS_timer();
 552 }
 553 
 554 /*
 555  * -------------------------------------------------------------------
 556  * Here ends the serial interrupt routines.
 557  * -------------------------------------------------------------------
 558  */
 559 
 560 /*
 561  * This routine is called when we receive a break on a serial line.
 562  * It is executed out of the software interrupt routine.
 563  */
 564 static inline void handle_rs_break(struct async_struct *info)
     /* [previous][next][first][last][top][bottom][index][help] */
 565 {
 566         if (info->flags & ASYNC_SAK)
 567                 do_SAK(info->tty);
 568                 
 569         if (!I_IGNBRK(info->tty) && I_BRKINT(info->tty)) {
 570                 flush_input(info->tty);
 571                 flush_output(info->tty);
 572                 if (info->tty->pgrp > 0)
 573                         kill_pg(info->tty->pgrp, SIGINT,1);
 574         }
 575 }
 576 
 577 /*
 578  * This routine is used to handle the "bottom half" processing for the
 579  * serial driver, known also the "software interrupt" processing.
 580  * This processing is done at the kernel interrupt level, after the
 581  * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
 582  * is where time-consuming activities which can not be done in the
 583  * interrupt driver proper are done; the interrupt driver schedules
 584  * them using rs_sched_event(), and they get done here.
 585  */
 586 static void do_softint(void *unused)
     /* [previous][next][first][last][top][bottom][index][help] */
 587 {
 588         int                     i;
 589         struct async_struct     *info;
 590         
 591         for (i = 0, info = rs_table; i < NR_PORTS; i++,info++) {
 592                 if (clear_bit(i, rs_event)) {
 593                         if (!info->tty) 
 594                                 continue;
 595                         if (clear_bit(RS_EVENT_READ_PROCESS, &info->event)) {
 596                                 TTY_READ_FLUSH(info->tty);
 597                         }
 598                         if (clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
 599                                 wake_up_interruptible(&info->tty->write_q.proc_list);
 600                         }
 601                         if (clear_bit(RS_EVENT_HANGUP, &info->event)) {
 602                                 tty_hangup(info->tty);
 603                                 wake_up_interruptible(&info->open_wait);
 604                                 info->flags &= ~(ASYNC_NORMAL_ACTIVE|
 605                                                  ASYNC_CALLOUT_ACTIVE);
 606                         }
 607                         if (clear_bit(RS_EVENT_BREAK, &info->event))
 608                                 handle_rs_break(info);
 609                         if (clear_bit(RS_EVENT_OPEN_WAKEUP, &info->event)) {
 610                                 wake_up_interruptible(&info->open_wait);
 611                         }
 612                 }
 613         }
 614 }
 615 
 616 /*
 617  * This subroutine is called when the RS_TIMER goes off.  It is used
 618  * by the serial driver to run the rs_interrupt routine at certain
 619  * intervals, either because a serial interrupt might have been lost,
 620  * or because (in the case of IRQ=0) the serial port does not have an
 621  * interrupt, and is being checked only via the timer interrupts.
 622  */
 623 static void rs_timer(void)
     /* [previous][next][first][last][top][bottom][index][help] */
 624 {
 625         int     i, mask;
 626         int     timeout = 0;
 627 
 628         for (i = 0, mask = 1; mask <= IRQ_active; i++, mask <<= 1) {
 629                 if ((mask & IRQ_active) && (IRQ_timer[i] <= jiffies)) {
 630                         IRQ_active &= ~mask;
 631                         cli();
 632 #ifdef SERIAL_DEBUG_TIMER
 633                         printk("rs_timer: rs_interrupt(%d)...", i);
 634 #endif
 635                         rs_interrupt(i);
 636                         sti();
 637                 }
 638                 if (mask & IRQ_active) {
 639                         if (!timeout || (IRQ_timer[i] < timeout))
 640                                 timeout = IRQ_timer[i];
 641                 }
 642         }
 643         if (timeout) {
 644                 timer_table[RS_TIMER].expires = timeout;
 645                 timer_active |= 1 << RS_TIMER;
 646         }
 647 }
 648 
 649 /*
 650  * ---------------------------------------------------------------
 651  * Low level utility subroutines for the serial driver:  routines to
 652  * figure out the appropriate timeout for an interrupt chain, routines
 653  * to initialize and startup a serial port, and routines to shutdown a
 654  * serial port.  Useful stuff like that.
 655  * ---------------------------------------------------------------
 656  */
 657 
 658 /*
 659  * Grab all interrupts in preparation for doing an automatic irq
 660  * detection.  dontgrab is a mask of irq's _not_ to grab.  Returns a
 661  * mask of irq's which were grabbed and should therefore be freed
 662  * using free_all_interrupts().
 663  */
 664 static int grab_all_interrupts(int dontgrab)
     /* [previous][next][first][last][top][bottom][index][help] */
 665 {
 666         int                     irq_lines = 0;
 667         int                     i, mask;
 668         struct sigaction        sa;
 669         
 670         sa.sa_handler = rs_probe;
 671         sa.sa_flags = (SA_INTERRUPT);
 672         sa.sa_mask = 0;
 673         sa.sa_restorer = NULL;
 674         
 675         for (i = 0, mask = 1; i < 16; i++, mask <<= 1) {
 676                 if (!(mask & dontgrab) && !irqaction(i, &sa)) {
 677                         irq_lines |= mask;
 678                 }
 679         }
 680         return irq_lines;
 681 }
 682 
 683 /*
 684  * Release all interrupts grabbed by grab_all_interrupts
 685  */
 686 static void free_all_interrupts(int irq_lines)
     /* [previous][next][first][last][top][bottom][index][help] */
 687 {
 688         int     i;
 689         
 690         for (i = 0; i < 16; i++) {
 691                 if (irq_lines & (1 << i))
 692                         free_irq(i);
 693         }
 694 }
 695 
 696 /*
 697  * This routine figures out the correct timeout for a particular IRQ.
 698  * It uses the smallest timeout of all of the serial ports in a
 699  * particular interrupt chain.
 700  */
 701 static void figure_IRQ_timeout(int irq)
     /* [previous][next][first][last][top][bottom][index][help] */
 702 {
 703         struct  async_struct    *info;
 704         int     timeout = 6000; /* 60 seconds === a long time :-) */
 705 
 706         info = IRQ_ports[irq];
 707         if (!info) {
 708                 IRQ_timeout[irq] = 6000;
 709                 return;
 710         }
 711         while (info) {
 712                 if (info->timeout < timeout)
 713                         timeout = info->timeout;
 714                 info = info->next_port;
 715         }
 716         if (!irq)
 717                 timeout = timeout / 2;
 718         IRQ_timeout[irq] = timeout ? timeout : 1;
 719 }
 720 
 721 static int startup(struct async_struct * info, int get_irq)
     /* [previous][next][first][last][top][bottom][index][help] */
 722 {
 723         unsigned short ICP;
 724         unsigned long flags;
 725         struct sigaction        sa;
 726         int                     retval;
 727 
 728         if (info->flags & ASYNC_INITIALIZED)
 729                 return 0;
 730 
 731         if (!info->port || !info->type) {
 732                 if (info->tty)
 733                         set_bit(TTY_IO_ERROR, &info->tty->flags);
 734                 return 0;
 735         }
 736 
 737         save_flags(flags); cli();
 738 
 739 #ifdef SERIAL_DEBUG_OPEN
 740         printk("starting up ttys%d (irq %d)...", info->line, info->irq);
 741 #endif
 742 
 743         /*
 744          * Allocate the IRQ if necessary
 745          */
 746         if (get_irq && info->irq && !IRQ_ports[info->irq]) {
 747                 sa.sa_handler = rs_interrupt;
 748                 sa.sa_flags = (SA_INTERRUPT);
 749                 sa.sa_mask = 0;
 750                 sa.sa_restorer = NULL;
 751                 retval = irqaction(info->irq,&sa);
 752                 if (retval) {
 753                         restore_flags(flags);
 754                         return retval;
 755                 }
 756         }
 757 
 758         /*
 759          * Clear the FIFO buffers and disable them
 760          * (they will be reenabled in change_speed())
 761          */
 762         if (info->type == PORT_16550A) {
 763                 serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
 764                                              UART_FCR_CLEAR_XMIT));
 765                 info->xmit_fifo_size = 16;
 766         } else
 767                 info->xmit_fifo_size = 1;
 768 
 769         /*
 770          * Clear the interrupt registers.
 771          */
 772         (void)serial_inp(info, UART_LSR);
 773         (void)serial_inp(info, UART_RX);
 774         (void)serial_inp(info, UART_IIR);
 775         (void)serial_inp(info, UART_MSR);
 776 
 777         /*
 778          * Now, initialize the UART 
 779          */
 780         serial_outp(info, UART_LCR, UART_LCR_WLEN8);    /* reset DLAB */
 781         if (info->flags & ASYNC_FOURPORT) 
 782                 serial_outp(info, UART_MCR, UART_MCR_DTR | UART_MCR_RTS);
 783         else
 784                 serial_outp(info, UART_MCR,
 785                             UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
 786         
 787         /*
 788          * Finally, enable interrupts
 789          */
 790 #ifdef ISR_HACK
 791         info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
 792         serial_outp(info, UART_IER, info->IER); /* enable interrupts */
 793 #else
 794         info->IER = (UART_IER_MSI | UART_IER_RLSI |
 795                      UART_IER_THRI | UART_IER_RDI);
 796         serial_outp(info, UART_IER, info->IER); /* enable all intrs */
 797 #endif
 798         if (info->flags & ASYNC_FOURPORT) {
 799                 /* Enable interrupts on the AST Fourport board */
 800                 ICP = (info->port & 0xFE0) | 0x01F;
 801                 outb_p(0x80, ICP);
 802                 (void) inb_p(ICP);
 803         }
 804 
 805         /*
 806          * And clear the interrupt registers again for luck.
 807          */
 808         (void)serial_inp(info, UART_LSR);
 809         (void)serial_inp(info, UART_RX);
 810         (void)serial_inp(info, UART_IIR);
 811         (void)serial_inp(info, UART_MSR);
 812 
 813         if (info->tty)
 814                 clear_bit(TTY_IO_ERROR, &info->tty->flags);
 815         /*
 816          * Set up parity check flag
 817          */
 818         if (info->tty && info->tty->termios && I_INPCK(info->tty))
 819                 info->read_status_mask = (UART_LSR_OE | UART_LSR_BI |
 820                                           UART_LSR_FE | UART_LSR_PE);
 821         else
 822                 info->read_status_mask = (UART_LSR_OE | UART_LSR_BI |
 823                                           UART_LSR_FE);
 824 
 825         /*
 826          * Insert serial port into IRQ chain.
 827          */
 828         info->prev_port = 0;
 829         info->next_port = IRQ_ports[info->irq];
 830         if (info->next_port)
 831                 info->next_port->prev_port = info;
 832         IRQ_ports[info->irq] = info;
 833         figure_IRQ_timeout(info->irq);
 834 
 835         /*
 836          * Set up serial timers...
 837          */
 838         IRQ_active |= 1 << info->irq;
 839         figure_RS_timer();
 840 
 841         /*
 842          * and set the speed of the serial port
 843          */
 844         change_speed(info->line);
 845 
 846         info->flags |= ASYNC_INITIALIZED;
 847         restore_flags(flags);
 848         return 0;
 849 }
 850 
 851 /*
 852  * This routine will shutdown a serial port; interrupts are disabled, and
 853  * DTR is dropped if the hangup on close termio flag is on.
 854  */
 855 static void shutdown(struct async_struct * info, int do_free_irq)
     /* [previous][next][first][last][top][bottom][index][help] */
 856 {
 857         unsigned long flags;
 858 
 859         if (!(info->flags & ASYNC_INITIALIZED))
 860                 return;
 861 
 862 #ifdef SERIAL_DEBUG_OPEN
 863         printk("Shutting down serial port %d (irq %d)....", info->line,
 864                info->irq);
 865 #endif
 866         
 867         save_flags(flags); cli(); /* Disable interrupts */
 868         
 869         /*
 870          * First unlink the serial port from the IRQ chain...
 871          */
 872         if (info->next_port)
 873                 info->next_port->prev_port = info->prev_port;
 874         if (info->prev_port)
 875                 info->prev_port->next_port = info->next_port;
 876         else
 877                 IRQ_ports[info->irq] = info->next_port;
 878         figure_IRQ_timeout(info->irq);
 879         
 880         /*
 881          * Free the IRQ, if necessary
 882          */
 883         if (do_free_irq && info->irq && !IRQ_ports[info->irq])
 884                 free_irq(info->irq);
 885         
 886         info->IER = 0;
 887         serial_outp(info, UART_IER, 0x00);      /* disable all intrs */
 888         if (info->flags & ASYNC_FOURPORT) {
 889                 /* reset interrupts on the AST Fourport board */
 890                 (void) inb((info->port & 0xFE0) | 0x01F);
 891         }
 892         if (info->tty && !(info->tty->termios->c_cflag & HUPCL))
 893                 serial_outp(info, UART_MCR, UART_MCR_DTR);
 894         else
 895                 /* reset DTR,RTS,OUT_2 */               
 896                 serial_outp(info, UART_MCR, 0x00);
 897 
 898         /* disable FIFO's */    
 899         serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
 900                                      UART_FCR_CLEAR_XMIT));
 901         (void)serial_in(info, UART_RX);    /* read data port to reset things */
 902         
 903         if (info->tty)
 904                 set_bit(TTY_IO_ERROR, &info->tty->flags);
 905         
 906         info->flags &= ~ASYNC_INITIALIZED;
 907         restore_flags(flags);
 908 }
 909 
 910 /*
 911  * This routine is called to set the UART divisor registers to match
 912  * the specified baud rate for a serial port.
 913  */
 914 static void change_speed(unsigned int line)
     /* [previous][next][first][last][top][bottom][index][help] */
 915 {
 916         struct async_struct * info;
 917         unsigned short port;
 918         int     quot = 0;
 919         unsigned cflag,cval,mcr,fcr;
 920         int     i;
 921 
 922         if (line >= NR_PORTS)
 923                 return;
 924         info = rs_table + line;
 925         if (!info->tty || !info->tty->termios)
 926                 return;
 927         cflag = info->tty->termios->c_cflag;
 928         if (!(port = info->port))
 929                 return;
 930         i = cflag & CBAUD;
 931         if (i == 15) {
 932                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
 933                         i += 1;
 934                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
 935                         i += 2;
 936                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
 937                         quot = info->custom_divisor;
 938         }
 939         if (quot) {
 940                 info->timeout = ((info->xmit_fifo_size*HZ*15*quot) /
 941                                  info->baud_base) + 2;
 942         } else if (baud_table[i] == 134) {
 943                 quot = (2*info->baud_base / 269);
 944                 info->timeout = (info->xmit_fifo_size*HZ*30/269) + 2;
 945         } else if (baud_table[i]) {
 946                 quot = info->baud_base / baud_table[i];
 947                 info->timeout = (info->xmit_fifo_size*HZ*15/baud_table[i]) + 2;
 948         } else {
 949                 quot = 0;
 950                 info->timeout = 0;
 951         }
 952         cli();
 953         mcr = serial_in(info, UART_MCR);
 954         if (quot) {
 955                 serial_out(info, UART_MCR, mcr | UART_MCR_DTR);
 956         } else {
 957                 serial_out(info, UART_MCR, mcr & ~UART_MCR_DTR);
 958                 sti();
 959                 return;
 960         }
 961         sti();
 962         /* byte size and parity */
 963         cval = cflag & (CSIZE | CSTOPB);
 964         cval >>= 4;
 965         if (cflag & PARENB)
 966                 cval |= UART_LCR_PARITY;
 967         if (!(cflag & PARODD))
 968                 cval |= UART_LCR_EPAR;
 969         if (info->type == PORT_16550A) {
 970                 if ((info->baud_base / quot) < 2400)
 971                         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
 972                 else
 973                         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8;
 974         } else
 975                 fcr = 0;
 976         
 977         cli();
 978         serial_outp(info, UART_LCR, cval | UART_LCR_DLAB);      /* set DLAB */
 979         serial_outp(info, UART_DLL, quot & 0xff);       /* LS of divisor */
 980         serial_outp(info, UART_DLM, quot >> 8);         /* MS of divisor */
 981         serial_outp(info, UART_LCR, cval);              /* reset DLAB */
 982         serial_outp(info, UART_FCR, fcr);       /* set fcr */
 983         sti();
 984 }
 985 
 986 /*
 987  * ------------------------------------------------------------
 988  * rs_write() and friends
 989  * ------------------------------------------------------------
 990  */
 991 
 992 /*
 993  * This routine is used by rs_write to restart transmitter interrupts,
 994  * which are disabled after we have a transmitter interrupt which went
 995  * unacknowledged because we had run out of data to transmit.
 996  * 
 997  * Note: this subroutine must be called with the interrupts *off*
 998  */
 999 static inline void restart_port(struct async_struct *info)
     /* [previous][next][first][last][top][bottom][index][help] */
1000 {
1001         struct tty_queue * queue;
1002         int head, tail, count;
1003         
1004         if (!info)
1005                 return;
1006 
1007         if (serial_inp(info, UART_LSR) & UART_LSR_THRE) {
1008                 if (info->x_char) {
1009                         serial_outp(info, UART_TX, info->x_char);
1010                         info->x_char = 0;
1011                 } else {
1012                         queue = &info->tty->write_q;
1013                         head = queue->head;
1014                         tail = queue->tail;
1015                         count = info->xmit_fifo_size;
1016                         while (count--) {
1017                                 if (tail == head)
1018                                         break;
1019                                 serial_outp(info, UART_TX, queue->buf[tail++]);
1020                                 tail &= TTY_BUF_SIZE-1;
1021                         }
1022                         queue->tail = tail;
1023                 }
1024         }
1025 }       
1026 
1027 /*
1028  * This routine gets called when tty_write has put something into
1029  * the write_queue.  
1030  */
1031 void rs_write(struct tty_struct * tty)
     /* [previous][next][first][last][top][bottom][index][help] */
1032 {
1033         struct async_struct *info;
1034 
1035         if (!tty || tty->stopped || tty->hw_stopped)
1036                 return;
1037         info = rs_table + DEV_TO_SL(tty->line);
1038         cli();
1039         if (!info || !info->tty || !(info->flags & ASYNC_INITIALIZED)) {
1040                 sti();
1041                 return;
1042         }
1043         restart_port(info);
1044         info->IER = (UART_IER_MSI | UART_IER_RLSI |
1045                      UART_IER_THRI | UART_IER_RDI);
1046 #ifdef ISR_HACK
1047         serial_out(info, UART_IER, info->IER);
1048 #endif
1049         sti();
1050 }
1051 
1052 /*
1053  * ------------------------------------------------------------
1054  * rs_throttle()
1055  * 
1056  * This routine is called by the upper-layer tty layer to signal that
1057  * incoming characters should be throttled (and that the throttle
1058  * should be released).
1059  * ------------------------------------------------------------
1060  */
1061 static void rs_throttle(struct tty_struct * tty, int status)
     /* [previous][next][first][last][top][bottom][index][help] */
1062 {
1063         struct async_struct *info;
1064         unsigned char mcr;
1065         unsigned long flags;
1066 
1067         save_flags(flags); cli();
1068 #if SERIAL_DEBUG_THROTTLE
1069         printk("throttle tty%d: %d (%d, %d)....\n", DEV_TO_SL(tty->line),
1070                status, LEFT(&tty->read_q), LEFT(&tty->secondary));
1071 #endif
1072         switch (status) {
1073         case TTY_THROTTLE_RQ_FULL:
1074                 info = rs_table + DEV_TO_SL(tty->line);
1075                 if (I_IXOFF(tty)) {
1076                         info->x_char = STOP_CHAR(tty);
1077                 } else {
1078                         mcr = serial_inp(info, UART_MCR);
1079                         mcr &= ~UART_MCR_RTS;
1080                         serial_out(info, UART_MCR, mcr);
1081                 }
1082                 break;
1083         case TTY_THROTTLE_RQ_AVAIL:
1084                 info = rs_table + DEV_TO_SL(tty->line);
1085                 if (I_IXOFF(tty)) {
1086                         if (info->x_char)
1087                                 info->x_char = 0;
1088                         else
1089                                 info->x_char = START_CHAR(tty);
1090                 } else {
1091                         mcr = serial_in(info, UART_MCR);
1092                         mcr |= UART_MCR_RTS;
1093                         serial_out(info, UART_MCR, mcr);
1094                 }
1095                 break;
1096         }
1097         restore_flags(flags);
1098 }
1099 
1100 /*
1101  * ------------------------------------------------------------
1102  * rs_ioctl() and friends
1103  * ------------------------------------------------------------
1104  */
1105 
1106 static int get_serial_info(struct async_struct * info,
     /* [previous][next][first][last][top][bottom][index][help] */
1107                            struct serial_struct * retinfo)
1108 {
1109         struct serial_struct tmp;
1110   
1111         if (!retinfo)
1112                 return -EFAULT;
1113         memset(&tmp, 0, sizeof(tmp));
1114         tmp.type = info->type;
1115         tmp.line = info->line;
1116         tmp.port = info->port;
1117         tmp.irq = info->irq;
1118         tmp.flags = info->flags;
1119         tmp.baud_base = info->baud_base;
1120         tmp.close_delay = info->close_delay;
1121         tmp.custom_divisor = info->custom_divisor;
1122         tmp.hub6 = info->hub6;
1123         memcpy_tofs(retinfo,&tmp,sizeof(*retinfo));
1124         return 0;
1125 }
1126 
1127 static int set_serial_info(struct async_struct * info,
     /* [previous][next][first][last][top][bottom][index][help] */
1128                            struct serial_struct * new_info)
1129 {
1130         struct serial_struct new_serial;
1131         struct async_struct old_info;
1132         unsigned int            i,change_irq,change_port;
1133         int                     retval;
1134         struct                  sigaction sa;
1135 
1136         if (!new_info)
1137                 return -EFAULT;
1138         memcpy_fromfs(&new_serial,new_info,sizeof(new_serial));
1139         old_info = *info;
1140 
1141         change_irq = new_serial.irq != info->irq;
1142         change_port = (new_serial.port != info->port) || (new_serial.hub6 != info->hub6);
1143 
1144         if (!suser()) {
1145                 if (change_irq || change_port ||
1146                     (new_serial.baud_base != info->baud_base) ||
1147                     (new_serial.type != info->type) ||
1148                     (new_serial.close_delay != info->close_delay) ||
1149                     ((new_serial.flags & ~ASYNC_USR_MASK) !=
1150                      (info->flags & ~ASYNC_USR_MASK)))
1151                         return -EPERM;
1152                 info->flags = ((info->flags & ~ASYNC_USR_MASK) |
1153                                (new_serial.flags & ASYNC_USR_MASK));
1154                 info->custom_divisor = new_serial.custom_divisor;
1155                 goto check_and_exit;
1156         }
1157 
1158         if (new_serial.irq == 2)
1159                 new_serial.irq = 9;
1160 
1161         if ((new_serial.irq > 15) || (new_serial.port > 0xffff) ||
1162             (new_serial.type < PORT_UNKNOWN) || (new_serial.type > PORT_MAX)) {
1163                 return -EINVAL;
1164         }
1165 
1166         /* Make sure address is not already in use */
1167         for (i = 0 ; i < NR_PORTS; i++)
1168                 if ((info != &rs_table[i]) &&
1169                     (rs_table[i].port == new_serial.port) && rs_table[i].type)
1170                         return -EADDRINUSE;
1171 
1172         /*
1173          * If necessary, first we try to grab the new IRQ for serial
1174          * interrupts.  (We have to do this early, since we may get an
1175          * error trying to do this.)
1176          */
1177         if (new_serial.port && new_serial.type && new_serial.irq &&
1178             (change_irq || !(info->flags & ASYNC_INITIALIZED))) {
1179                 if (!IRQ_ports[new_serial.irq]) {
1180                         sa.sa_handler = rs_interrupt;
1181                         sa.sa_flags = (SA_INTERRUPT);
1182                         sa.sa_mask = 0;
1183                         sa.sa_restorer = NULL;
1184                         retval = irqaction(new_serial.irq,&sa);
1185                         if (retval)
1186                                 return retval;
1187                 }
1188         }
1189 
1190         if ((change_port || change_irq) && (info->count > 1))
1191                 return -EBUSY;
1192 
1193         /*
1194          * OK, past this point, all the error checking has been done.
1195          * At this point, we start making changes.....
1196          */
1197 
1198         info->baud_base = new_serial.baud_base;
1199         info->flags = ((info->flags & ~ASYNC_FLAGS) |
1200                         (new_serial.flags & ASYNC_FLAGS));
1201         info->custom_divisor = new_serial.custom_divisor;
1202         info->type = new_serial.type;
1203         info->close_delay = new_serial.close_delay;
1204 
1205         if (change_port || change_irq) {
1206                 /*
1207                  * We need to shutdown the serial port at the old
1208                  * port/irq combination.
1209                  */
1210                 shutdown(info, change_irq);
1211                 info->irq = new_serial.irq;
1212                 info->port = new_serial.port;
1213                 info->hub6 = new_serial.hub6;
1214         }
1215         
1216 check_and_exit:
1217         if (!info->port || !info->type)
1218                 return 0;
1219         if (info->flags & ASYNC_INITIALIZED) {
1220                 if (((old_info.flags & ASYNC_SPD_MASK) !=
1221                      (info->flags & ASYNC_SPD_MASK)) ||
1222                     (old_info.custom_divisor != info->custom_divisor))
1223                         change_speed(info->line);
1224         } else
1225                 (void) startup(info, 0);
1226         return 0;
1227 }
1228 
1229 static int get_modem_info(struct async_struct * info, unsigned int *value)
     /* [previous][next][first][last][top][bottom][index][help] */
1230 {
1231         unsigned char control, status;
1232         unsigned int result;
1233 
1234         cli();
1235         control = serial_in(info, UART_MCR);
1236         status = serial_in(info, UART_MSR);
1237         sti();
1238         result =  ((control & UART_MCR_RTS) ? TIOCM_RTS : 0)
1239                 | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0)
1240                 | ((status  & UART_MSR_DCD) ? TIOCM_CAR : 0)
1241                 | ((status  & UART_MSR_RI) ? TIOCM_RNG : 0)
1242                 | ((status  & UART_MSR_DSR) ? TIOCM_DSR : 0)
1243                 | ((status  & UART_MSR_CTS) ? TIOCM_CTS : 0);
1244         put_fs_long(result,(unsigned long *) value);
1245         return 0;
1246 }
1247 
1248 static int set_modem_info(struct async_struct * info, unsigned int cmd,
     /* [previous][next][first][last][top][bottom][index][help] */
1249                           unsigned int *value)
1250 {
1251         unsigned char control;
1252         unsigned int arg = get_fs_long((unsigned long *) value);
1253         
1254         cli();
1255         control = serial_in(info, UART_MCR);
1256         sti();
1257 
1258         switch (cmd) {
1259                 case TIOCMBIS:
1260                         if (arg & TIOCM_RTS)
1261                                 control |= UART_MCR_RTS;
1262                         if (arg & TIOCM_DTR)
1263                                 control |= UART_MCR_DTR;
1264                         break;
1265                 case TIOCMBIC:
1266                         if (arg & TIOCM_RTS)
1267                                 control &= ~UART_MCR_RTS;
1268                         if (arg & TIOCM_DTR)
1269                                 control &= ~UART_MCR_DTR;
1270                         break;
1271                 case TIOCMSET:
1272                         control = (control & ~(UART_MCR_RTS | UART_MCR_DTR))
1273                                 | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0)
1274                                 | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0);
1275                         break;
1276                 default:
1277                         return -EINVAL;
1278         }
1279         cli();
1280         serial_out(info, UART_MCR, control);
1281         sti();
1282         return 0;
1283 }
1284 
1285 static int do_autoconfig(struct async_struct * info)
     /* [previous][next][first][last][top][bottom][index][help] */
1286 {
1287         int                     retval;
1288         
1289         if (!suser())
1290                 return -EPERM;
1291         
1292         if (info->count > 1)
1293                 return -EBUSY;
1294         
1295         shutdown(info, 1);
1296 
1297         cli();
1298         autoconfig(info);
1299         sti();
1300 
1301         retval = startup(info, 1);
1302         if (retval)
1303                 return retval;
1304         return 0;
1305 }
1306 
1307 
1308 /*
1309  * This routine sends a break character out the serial port.
1310  */
1311 static void send_break( struct async_struct * info, int duration)
     /* [previous][next][first][last][top][bottom][index][help] */
1312 {
1313         if (!info->port)
1314                 return;
1315         current->state = TASK_INTERRUPTIBLE;
1316         current->timeout = jiffies + duration;
1317         cli();
1318         serial_out(info, UART_LCR, serial_inp(info, UART_LCR) | UART_LCR_SBC);
1319         schedule();
1320         serial_out(info, UART_LCR, serial_inp(info, UART_LCR) & ~UART_LCR_SBC);
1321         sti();
1322 }
1323 
1324 /*
1325  * This routine returns a bitfield of "wild interrupts".  Basically,
1326  * any unclaimed interrupts which is flapping around.
1327  */
1328 static int check_wild_interrupts(int doprint)
     /* [previous][next][first][last][top][bottom][index][help] */
1329 {
1330         int     i, mask;
1331         int     wild_interrupts = 0;
1332         int     irq_lines;
1333         unsigned long timeout;
1334         unsigned long flags;
1335         
1336         /* Turn on interrupts (they may be off) */
1337         save_flags(flags); sti();
1338 
1339         irq_lines = grab_all_interrupts(0);
1340         
1341         /*
1342          * Delay for 0.1 seconds -- we use a busy loop since this may 
1343          * occur during the bootup sequence
1344          */
1345         timeout = jiffies+10;
1346         while (timeout >= jiffies)
1347                 ;
1348         
1349         rs_triggered = 0;       /* Reset after letting things settle */
1350 
1351         timeout = jiffies+10;
1352         while (timeout >= jiffies)
1353                 ;
1354         
1355         for (i = 0, mask = 1; i < 16; i++, mask <<= 1) {
1356                 if ((rs_triggered & (1 << i)) &&
1357                     (irq_lines & (1 << i))) {
1358                         wild_interrupts |= mask;
1359                         if (doprint)
1360                                 printk("Wild interrupt?  (IRQ %d)\n", i);
1361                 }
1362         }
1363         free_all_interrupts(irq_lines);
1364         restore_flags(flags);
1365         return wild_interrupts;
1366 }
1367 
1368 static int rs_ioctl(struct tty_struct *tty, struct file * file,
     /* [previous][next][first][last][top][bottom][index][help] */
1369                     unsigned int cmd, unsigned long arg)
1370 {
1371         int error, line;
1372         struct async_struct * info;
1373 
1374         line = DEV_TO_SL(tty->line);
1375         if (line < 0 || line >= NR_PORTS)
1376                 return -ENODEV;
1377         info = rs_table + line;
1378         
1379         switch (cmd) {
1380                 case TCSBRK:    /* SVID version: non-zero arg --> no break */
1381                         if (!arg)
1382                                 send_break(info, HZ/4); /* 1/4 second */
1383                         return 0;
1384                 case TCSBRKP:   /* support for POSIX tcsendbreak() */
1385                         send_break(info, arg ? arg*(HZ/10) : HZ/4);
1386                         return 0;
1387                 case TIOCGSOFTCAR:
1388                         error = verify_area(VERIFY_WRITE, (void *) arg,sizeof(long));
1389                         if (error)
1390                                 return error;
1391                         put_fs_long(C_CLOCAL(tty) ? 1 : 0,
1392                                     (unsigned long *) arg);
1393                         return 0;
1394                 case TIOCSSOFTCAR:
1395                         arg = get_fs_long((unsigned long *) arg);
1396                         tty->termios->c_cflag =
1397                                 ((tty->termios->c_cflag & ~CLOCAL) |
1398                                  (arg ? CLOCAL : 0));
1399                         return 0;
1400                 case TIOCMGET:
1401                         error = verify_area(VERIFY_WRITE, (void *) arg,
1402                                 sizeof(unsigned int));
1403                         if (error)
1404                                 return error;
1405                         return get_modem_info(info, (unsigned int *) arg);
1406                 case TIOCMBIS:
1407                 case TIOCMBIC:
1408                 case TIOCMSET:
1409                         return set_modem_info(info, cmd, (unsigned int *) arg);
1410                 case TIOCGSERIAL:
1411                         error = verify_area(VERIFY_WRITE, (void *) arg,
1412                                                 sizeof(struct serial_struct));
1413                         if (error)
1414                                 return error;
1415                         return get_serial_info(info,
1416                                                (struct serial_struct *) arg);
1417                 case TIOCSSERIAL:
1418                         return set_serial_info(info,
1419                                                (struct serial_struct *) arg);
1420                 case TIOCSERCONFIG:
1421                         return do_autoconfig(info);
1422 
1423                 case TIOCSERGWILD:
1424                         error = verify_area(VERIFY_WRITE, (void *) arg,
1425                                             sizeof(int));
1426                         if (error)
1427                                 return error;
1428                         put_fs_long(rs_wild_int_mask, (unsigned long *) arg);
1429                         return 0;
1430 
1431                 case TIOCSERSWILD:
1432                         if (!suser())
1433                                 return -EPERM;
1434                         rs_wild_int_mask = get_fs_long((unsigned long *) arg);
1435                         if (rs_wild_int_mask < 0)
1436                                 rs_wild_int_mask = check_wild_interrupts(0);
1437                         return 0;
1438 
1439                 default:
1440                         return -EINVAL;
1441                 }
1442         return 0;
1443 }
1444 
1445 static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
     /* [previous][next][first][last][top][bottom][index][help] */
1446 {
1447         struct async_struct *info;
1448 
1449         if (tty->termios->c_cflag == old_termios->c_cflag)
1450                 return;
1451 
1452         info = &rs_table[DEV_TO_SL(tty->line)];
1453 
1454         change_speed(DEV_TO_SL(tty->line));
1455         
1456         if ((old_termios->c_cflag & CRTSCTS) &&
1457             !(tty->termios->c_cflag & CRTSCTS)) {
1458                 tty->hw_stopped = 0;
1459                 rs_write(tty);
1460         }
1461 
1462         if (!(old_termios->c_cflag & CLOCAL) &&
1463             (tty->termios->c_cflag & CLOCAL))
1464                 wake_up_interruptible(&info->open_wait);
1465 
1466         if (I_INPCK(tty))
1467                 info->read_status_mask = (UART_LSR_OE | UART_LSR_BI |
1468                                           UART_LSR_FE | UART_LSR_PE);
1469         else
1470                 info->read_status_mask = (UART_LSR_OE | UART_LSR_BI |
1471                                           UART_LSR_FE);
1472 }
1473 
1474 /*
1475  * ------------------------------------------------------------
1476  * rs_close()
1477  * 
1478  * This routine is called when the serial port gets closed.  First, we
1479  * wait for the last remaining data to be sent.  Then, we unlink its
1480  * async structure from the interrupt chain if necessary, and we free
1481  * that IRQ if nothing is left in the chain.
1482  * ------------------------------------------------------------
1483  */
1484 static void rs_close(struct tty_struct *tty, struct file * filp)
     /* [previous][next][first][last][top][bottom][index][help] */
1485 {
1486         struct async_struct * info;
1487         int line;
1488 
1489         if (tty_hung_up_p(filp))
1490                 return;
1491         
1492         line = DEV_TO_SL(tty->line);
1493         if ((line < 0) || (line >= NR_PORTS))
1494                 return;
1495         info = rs_table + line;
1496 #ifdef SERIAL_DEBUG_OPEN
1497         printk("rs_close ttys%d, count = %d\n", info->line, info->count);
1498 #endif
1499         if ((tty->count == 1) && (info->count != 1)) {
1500                 /*
1501                  * Uh, oh.  tty->count is 1, which means that the tty
1502                  * structure will be freed.  Info->count should always
1503                  * be one in these conditions.  If it's greater than
1504                  * one, we've got real problems, since it means the
1505                  * serial port won't be shutdown.
1506                  */
1507                 printk("rs_close: bad serial port count; tty->count is 1, "
1508                        "info->count is %d\n", info->count);
1509                 info->count = 1;
1510         }
1511         if (--info->count < 0) {
1512                 printk("rs_close: bad serial port count for ttys%d: %d\n",
1513                        info->line, info->count);
1514                 info->count = 0;
1515         }
1516         if (info->count)
1517                 return;
1518         info->flags |= ASYNC_CLOSING;
1519         /*
1520          * Save the termios structure, since this port may have
1521          * separate termios for callout and dialin.
1522          */
1523         if (info->flags & ASYNC_NORMAL_ACTIVE)
1524                 info->normal_termios = *tty->termios;
1525         if (info->flags & ASYNC_CALLOUT_ACTIVE)
1526                 info->callout_termios = *tty->termios;
1527         tty->stopped = 0;               /* Force flush to succeed */
1528         tty->hw_stopped = 0;
1529         if (info->flags & ASYNC_INITIALIZED) {
1530                 rs_start(tty);
1531                 wait_until_sent(tty, 6000); /* 60 seconds timeout */
1532         } else
1533                 flush_output(tty);
1534         flush_input(tty);
1535         cli();
1536         /*
1537          * Make sure the UART transmitter has completely drained; this
1538          * is especially important if there is a transmit FIFO!
1539          */
1540         if (!(serial_inp(info, UART_LSR) & UART_LSR_THRE)) {
1541                 rs_start(tty);  /* Make sure THRI interrupt enabled */
1542                 interruptible_sleep_on(&info->xmit_wait);
1543         }
1544         sti();
1545         shutdown(info, 1);
1546         clear_bit(line, rs_event);
1547         info->event = 0;
1548         info->tty = 0;
1549         if (info->blocked_open) {
1550                 if (info->close_delay) {
1551                         tty->count++; /* avoid race condition */
1552                         current->state = TASK_INTERRUPTIBLE;
1553                         current->timeout = jiffies + info->close_delay;
1554                         schedule();
1555                         tty->count--;
1556                 }
1557                 wake_up_interruptible(&info->open_wait);
1558         }
1559         info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
1560                          ASYNC_CLOSING);
1561         wake_up_interruptible(&info->close_wait);
1562 }
1563 
1564 /*
1565  * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
1566  */
1567 void rs_hangup(struct tty_struct *tty)
     /* [previous][next][first][last][top][bottom][index][help] */
1568 {
1569         struct async_struct * info;
1570         int line;
1571 
1572         line = DEV_TO_SL(tty->line);
1573         if ((line < 0) || (line >= NR_PORTS))
1574                 return;
1575         info = rs_table + line;
1576         
1577         shutdown(info, 1);
1578         clear_bit(line, rs_event);
1579         info->event = 0;
1580         info->count = 0;
1581         info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
1582         info->tty = 0;
1583         wake_up_interruptible(&info->open_wait);
1584 }
1585 
1586 /*
1587  * ------------------------------------------------------------
1588  * rs_open() and friends
1589  * ------------------------------------------------------------
1590  */
1591 static int block_til_ready(struct tty_struct *tty, struct file * filp,
     /* [previous][next][first][last][top][bottom][index][help] */
1592                            struct async_struct *info)
1593 {
1594         struct wait_queue wait = { current, NULL };
1595         int             retval;
1596         int             do_clocal = C_CLOCAL(tty);
1597 
1598         /*
1599          * If the device is in the middle of being closed, then block
1600          * until it's done, and then try again.
1601          */
1602         if (info->flags & ASYNC_CLOSING) {
1603                 interruptible_sleep_on(&info->close_wait);
1604 #ifdef SERIAL_DO_RESTART
1605                 if (info->flags & ASYNC_HUP_NOTIFY)
1606                         return -EAGAIN;
1607                 else
1608                         return -ERESTARTSYS;
1609 #else
1610                 return -EAGAIN;
1611 #endif
1612         }
1613 
1614         /*
1615          * If this is a callout device, then just make sure the normal
1616          * device isn't being used.
1617          */
1618         if (MAJOR(filp->f_rdev) == TTYAUX_MAJOR) {
1619                 if (info->flags & ASYNC_NORMAL_ACTIVE)
1620                         return -EBUSY;
1621                 if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
1622                     (info->flags & ASYNC_SESSION_LOCKOUT) &&
1623                     (info->session != current->session))
1624                     return -EBUSY;
1625                 if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
1626                     (info->flags & ASYNC_PGRP_LOCKOUT) &&
1627                     (info->pgrp != current->pgrp))
1628                     return -EBUSY;
1629                 info->flags |= ASYNC_CALLOUT_ACTIVE;
1630                 return 0;
1631         }
1632         
1633         /*
1634          * If non-blocking mode is set, then make the check up front
1635          * and then exit.
1636          */
1637         if (filp->f_flags & O_NONBLOCK) {
1638                 if (info->flags & ASYNC_CALLOUT_ACTIVE)
1639                         return -EBUSY;
1640                 info->flags |= ASYNC_NORMAL_ACTIVE;
1641                 return 0;
1642         }
1643 
1644         /*
1645          * Block waiting for the carrier detect and the line to become
1646          * free (i.e., not in use by the callout).  While we are in
1647          * this loop, info->count is dropped by one, so that
1648          * rs_close() knows when to free things.  We restore it upon
1649          * exit, either normal or abnormal.
1650          */
1651         retval = 0;
1652         add_wait_queue(&info->open_wait, &wait);
1653 #ifdef SERIAL_DEBUG_OPEN
1654         printk("block_til_ready before block: ttys%d, count = %d\n",
1655                info->line, info->count);
1656 #endif
1657         info->count--;
1658         info->blocked_open++;
1659         while (1) {
1660                 cli();
1661                 if (!(info->flags & ASYNC_CALLOUT_ACTIVE))
1662                         serial_out(info, UART_MCR,
1663                                    serial_inp(info, UART_MCR) |
1664                                    (UART_MCR_DTR | UART_MCR_RTS));
1665                 sti();
1666                 current->state = TASK_INTERRUPTIBLE;
1667                 if (tty_hung_up_p(filp) ||
1668                     !(info->flags & ASYNC_INITIALIZED)) {
1669 #ifdef SERIAL_DO_RESTART
1670                         if (info->flags & ASYNC_HUP_NOTIFY)
1671                                 retval = -EAGAIN;
1672                         else
1673                                 retval = -ERESTARTSYS;
1674 #else
1675                         retval = -EAGAIN;
1676 #endif
1677                         break;
1678                 }
1679                 if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
1680                     !(info->flags & ASYNC_CLOSING) &&
1681                     (do_clocal || (serial_in(info, UART_MSR) &
1682                                    UART_MSR_DCD)))
1683                         break;
1684                 if (current->signal & ~current->blocked) {
1685                         retval = -ERESTARTSYS;
1686                         break;
1687                 }
1688 #ifdef SERIAL_DEBUG_OPEN
1689                 printk("block_til_ready blocking: ttys%d, count = %d\n",
1690                        info->line, info->count);
1691 #endif
1692                 schedule();
1693         }
1694         current->state = TASK_RUNNING;
1695         remove_wait_queue(&info->open_wait, &wait);
1696         if (!tty_hung_up_p(filp))
1697                 info->count++;
1698         info->blocked_open--;
1699 #ifdef SERIAL_DEBUG_OPEN
1700         printk("block_til_ready after blocking: ttys%d, count = %d\n",
1701                info->line, info->count);
1702 #endif
1703         if (retval)
1704                 return retval;
1705         info->flags |= ASYNC_NORMAL_ACTIVE;
1706         return 0;
1707 }       
1708 
1709 /*
1710  * This routine is called whenever a serial port is opened.  It
1711  * enables interrupts for a serial port, linking in its async structure into
1712  * the IRQ chain.   It also performs the serial-speicific
1713  * initalization for the tty structure.
1714  */
1715 int rs_open(struct tty_struct *tty, struct file * filp)
     /* [previous][next][first][last][top][bottom][index][help] */
1716 {
1717         struct async_struct     *info;
1718         int                     retval, line;
1719 
1720         line = DEV_TO_SL(tty->line);
1721         if ((line < 0) || (line >= NR_PORTS))
1722                 return -ENODEV;
1723         info = rs_table + line;
1724 #ifdef SERIAL_DEBUG_OPEN
1725         printk("rs_open ttys%d, count = %d\n", info->line, info->count);
1726 #endif
1727         info->count++;
1728         info->tty = tty;
1729         
1730         tty->write = rs_write;
1731         tty->close = rs_close;
1732         tty->ioctl = rs_ioctl;
1733         tty->throttle = rs_throttle;
1734         tty->set_termios = rs_set_termios;
1735         tty->stop = rs_stop;
1736         tty->start = rs_start;
1737         tty->hangup = rs_hangup;
1738         if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
1739                 if (MAJOR(filp->f_rdev) == TTY_MAJOR)
1740                         *tty->termios = info->normal_termios;
1741                 else 
1742                         *tty->termios = info->callout_termios;
1743         }
1744         /*
1745          * Start up serial port
1746          */
1747         retval = startup(info, 1);
1748         if (retval)
1749                 return retval;
1750 
1751         retval = block_til_ready(tty, filp, info);
1752         if (retval) {
1753 #ifdef SERIAL_DEBUG_OPEN
1754                 printk("rs_open returning after block_til_ready with %d\n",
1755                        retval);
1756 #endif
1757                 return retval;
1758         }
1759 
1760         info->session = current->session;
1761         info->pgrp = current->pgrp;
1762 
1763 #ifdef SERIAL_DEBUG_OPEN
1764         printk("rs_open ttys%d successful...", info->line);
1765 #endif
1766         return 0;
1767 }
1768 
1769 /*
1770  * ---------------------------------------------------------------------
1771  * rs_init() and friends
1772  *
1773  * rs_init() is called at boot-time to initialize the serial driver.
1774  * ---------------------------------------------------------------------
1775  */
1776 
1777 /*
1778  * This routine prints out the appropriate serial driver version
1779  * number, and identifies which options were configured into this
1780  * driver.
1781  */
1782 static void show_serial_version(void)
     /* [previous][next][first][last][top][bottom][index][help] */
1783 {
1784         printk("Serial driver version 3.99a with");
1785 #ifdef CONFIG_AST_FOURPORT
1786         printk(" AST_FOURPORT");
1787 #define SERIAL_OPT
1788 #endif
1789 #ifdef CONFIG_ACCENT_ASYNC
1790         printk(" ACCENT_ASYNC");
1791 #define SERIAL_OPT
1792 #endif
1793 #ifdef CONFIG_HUB6
1794         printk(" HUB-6");
1795 #define SERIAL_OPT
1796 #endif
1797 #ifdef CONFIG_AUTO_IRQ
1798         printk (" AUTO_IRQ");
1799 #define SERIAL_OPT
1800 #endif
1801 #ifdef SERIAL_OPT
1802         printk(" enabled\n");
1803 #else
1804         printk(" no serial options enabled\n");
1805 #endif
1806 #undef SERIAL_OPT
1807 }
1808 
1809 /*
1810  * This routine is called by do_auto_irq(); it attempts to determine
1811  * which interrupt a serial port is configured to use.  It is not
1812  * fool-proof, but it works a large part of the time.
1813  */
1814 static int get_auto_irq(struct async_struct *info)
     /* [previous][next][first][last][top][bottom][index][help] */
1815 {
1816         unsigned char save_MCR, save_IER, save_ICP=0;
1817         unsigned short ICP=0, port = info->port;
1818         unsigned long timeout;
1819         
1820         /*
1821          * Enable interrupts and see who answers
1822          */
1823         rs_irq_triggered = 0;
1824         cli();
1825         save_IER = serial_inp(info, UART_IER);
1826         save_MCR = serial_inp(info, UART_MCR);
1827         if (info->flags & ASYNC_FOURPORT)  {
1828                 serial_outp(info, UART_MCR, UART_MCR_DTR | UART_MCR_RTS);
1829                 serial_outp(info, UART_IER, 0x0f);      /* enable all intrs */
1830                 ICP = (port & 0xFE0) | 0x01F;
1831                 save_ICP = inb_p(ICP);
1832                 outb_p(0x80, ICP);
1833                 (void) inb_p(ICP);
1834         } else {
1835                 serial_outp(info, UART_MCR,
1836                             UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
1837                 serial_outp(info, UART_IER, 0x0f);      /* enable all intrs */
1838         }
1839         sti();
1840         /*
1841          * Next, clear the interrupt registers.
1842          */
1843         (void)serial_inp(info, UART_LSR);
1844         (void)serial_inp(info, UART_RX);
1845         (void)serial_inp(info, UART_IIR);
1846         (void)serial_inp(info, UART_MSR);
1847         
1848         timeout = jiffies+2;
1849         while (timeout >= jiffies) {
1850                 if (rs_irq_triggered)
1851                         break;
1852         }
1853         /*
1854          * Now check to see if we got any business, and clean up.
1855          */
1856         cli();
1857         serial_outp(info, UART_IER, save_IER);
1858         serial_outp(info, UART_MCR, save_MCR);
1859         if (info->flags & ASYNC_FOURPORT)
1860                 outb_p(save_ICP, ICP);
1861         sti();
1862         return(rs_irq_triggered);
1863 }
1864 
1865 /*
1866  * Calls get_auto_irq() multiple times, to make sure we don't get
1867  * faked out by random interrupts
1868  */
1869 static int do_auto_irq(struct async_struct * info)
     /* [previous][next][first][last][top][bottom][index][help] */
1870 {
1871         unsigned                port = info->port;
1872         int                     irq_lines = 0;
1873         int                     irq_try_1 = 0, irq_try_2 = 0;
1874         int                     retries;
1875         unsigned long flags;
1876 
1877         if (!port)
1878                 return 0;
1879 
1880         /* Turn on interrupts (they may be off) */
1881         save_flags(flags); sti();
1882 
1883         irq_lines = grab_all_interrupts(rs_wild_int_mask);
1884         
1885         for (retries = 0; retries < 5; retries++) {
1886                 if (!irq_try_1)
1887                         irq_try_1 = get_auto_irq(info);
1888                 if (!irq_try_2)
1889                         irq_try_2 = get_auto_irq(info);
1890                 if (irq_try_1 && irq_try_2) {
1891                         if (irq_try_1 == irq_try_2)
1892                                 break;
1893                         irq_try_1 = irq_try_2 = 0;
1894                 }
1895         }
1896         restore_flags(flags);
1897         free_all_interrupts(irq_lines);
1898         return (irq_try_1 == irq_try_2) ? irq_try_1 : 0;
1899 }
1900 
1901 /*
1902  * This routine is called by rs_init() to initialize a specific serial
1903  * port.  It determines what type of UART ship this serial port is
1904  * using: 8250, 16450, 16550, 16550A.  The important question is
1905  * whether or not this UART is a 16550A or not, since this will
1906  * determine whether or not we can use its FIFO features or not.
1907  */
1908 static void autoconfig(struct async_struct * info)
     /* [previous][next][first][last][top][bottom][index][help] */
1909 {
1910         unsigned char status1, status2, scratch, scratch2;
1911         unsigned port = info->port;
1912         unsigned long flags;
1913 
1914         info->type = PORT_UNKNOWN;
1915         
1916         if (!port)
1917                 return;
1918 
1919         save_flags(flags); cli();
1920         
1921         /*
1922          * Do a simple existence test first; if we fail this, there's
1923          * no point trying anything else.
1924          */
1925         scratch = serial_inp(info, UART_IER);
1926         serial_outp(info, UART_IER, 0);
1927         scratch2 = serial_inp(info, UART_IER);
1928         serial_outp(info, UART_IER, scratch);
1929         if (scratch2) {
1930                 restore_flags(flags);
1931                 return;         /* We failed; there's nothing here */
1932         }
1933 
1934         /* 
1935          * Check to see if a UART is really there.  Certain broken
1936          * internal modems based on the Rockwell chipset fail this
1937          * test, because they apparently don't implement the loopback
1938          * test mode.  So this test is skipped on the COM 1 through
1939          * COM 4 ports.  This *should* be safe, since no board
1940          * manufactucturer would be stupid enough to design a board
1941          * that conflicts with COM 1-4 --- we hope!
1942          */
1943         if (!(info->flags & ASYNC_SKIP_TEST)) {
1944                 scratch = serial_inp(info, UART_MCR);
1945                 serial_outp(info, UART_MCR, UART_MCR_LOOP | scratch);
1946                 scratch2 = serial_inp(info, UART_MSR);
1947                 serial_outp(info, UART_MCR, UART_MCR_LOOP | 0x0A);
1948                 status1 = serial_inp(info, UART_MSR) & 0xF0;
1949                 serial_outp(info, UART_MCR, scratch);
1950                 serial_outp(info, UART_MSR, scratch2);
1951                 if (status1 != 0x90) {
1952                         restore_flags(flags);
1953                         return;
1954                 }
1955         } 
1956         
1957         /*
1958          * If the AUTO_IRQ flag is set, try to do the automatic IRQ
1959          * detection.
1960          */
1961         if (info->flags & ASYNC_AUTO_IRQ)
1962                 info->irq = do_auto_irq(info);
1963                 
1964         serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO);
1965         scratch = serial_in(info, UART_IIR) >> 6;
1966         info->xmit_fifo_size = 1;
1967         switch (scratch) {
1968                 case 0:
1969                         info->type = PORT_16450;
1970                         break;
1971                 case 1:
1972                         info->type = PORT_UNKNOWN;
1973                         break;
1974                 case 2:
1975                         info->type = PORT_16550;
1976                         break;
1977                 case 3:
1978                         info->type = PORT_16550A;
1979                         info->xmit_fifo_size = 16;
1980                         break;
1981         }
1982         if (info->type == PORT_16450) {
1983                 scratch = serial_in(info, UART_SCR);
1984                 serial_outp(info, UART_SCR, 0xa5);
1985                 status1 = serial_in(info, UART_SCR);
1986                 serial_outp(info, UART_SCR, 0x5a);
1987                 status2 = serial_in(info, UART_SCR);
1988                 serial_outp(info, UART_SCR, scratch);
1989 
1990                 if ((status1 != 0xa5) || (status2 != 0x5a))
1991                         info->type = PORT_8250;
1992         }
1993 
1994         /*
1995          * Reset the UART.
1996          */
1997         serial_outp(info, UART_MCR, 0x00);
1998         serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
1999                                      UART_FCR_CLEAR_XMIT));
2000         (void)serial_in(info, UART_RX);
2001         
2002         restore_flags(flags);
2003 }
2004 
2005 /*
2006  * The serial driver boot-time initialization code!
2007  */
2008 long rs_init(long kmem_start)
     /* [previous][next][first][last][top][bottom][index][help] */
2009 {
2010         int i;
2011         struct async_struct * info;
2012         
2013         memset(&rs_event, 0, sizeof(rs_event));
2014         bh_base[SERIAL_BH].routine = do_softint;
2015         timer_table[RS_TIMER].fn = rs_timer;
2016         timer_table[RS_TIMER].expires = 0;
2017         IRQ_active = 0;
2018 #ifdef CONFIG_AUTO_IRQ
2019         rs_wild_int_mask = check_wild_interrupts(1);
2020 #endif
2021 
2022         for (i = 0; i < 16; i++) {
2023                 IRQ_ports[i] = 0;
2024                 IRQ_timeout[i] = 0;
2025         }
2026         
2027         show_serial_version();
2028         for (i = 0, info = rs_table; i < NR_PORTS; i++,info++) {
2029                 info->line = i;
2030                 info->tty = 0;
2031                 info->type = PORT_UNKNOWN;
2032                 info->custom_divisor = 0;
2033                 info->close_delay = 50;
2034                 info->x_char = 0;
2035                 info->event = 0;
2036                 info->count = 0;
2037                 info->blocked_open = 0;
2038                 memset(&info->callout_termios, 0, sizeof(struct termios));
2039                 memset(&info->normal_termios, 0, sizeof(struct termios));
2040                 info->open_wait = 0;
2041                 info->xmit_wait = 0;
2042                 info->close_wait = 0;
2043                 info->next_port = 0;
2044                 info->prev_port = 0;
2045                 if (info->irq == 2)
2046                         info->irq = 9;
2047                 if (!(info->flags & ASYNC_BOOT_AUTOCONF))
2048                         continue;
2049                 autoconfig(info);
2050                 if (info->type == PORT_UNKNOWN)
2051                         continue;
2052                 printk("tty%02d%s at 0x%04x (irq = %d)", info->line, 
2053                        (info->flags & ASYNC_FOURPORT) ? " FourPort" : "",
2054                        info->port, info->irq);
2055                 switch (info->type) {
2056                         case PORT_8250:
2057                                 printk(" is a 8250\n");
2058                                 break;
2059                         case PORT_16450:
2060                                 printk(" is a 16450\n");
2061                                 break;
2062                         case PORT_16550:
2063                                 printk(" is a 16550\n");
2064                                 break;
2065                         case PORT_16550A:
2066                                 printk(" is a 16550A\n");
2067                                 break;
2068                         default:
2069                                 printk("\n");
2070                                 break;
2071                 }
2072         }
2073         return kmem_start;
2074 }
2075 

/* [previous][next][first][last][top][bottom][index][help] */