drivers/char/serial167.c

   1 /*
   2  * linux/drivers/char/serial167.c
   3  *
   4  * Driver for MVME166/7 board serial ports, which are via a CD2401.
   5  * Based very much on cyclades.c.
   6  *
   7  * MVME166/7 work by Richard Hirst [richard@sleepie.demon.co.uk]
   8  *
   9  * ==============================================================
  10  *
  11  * static char rcsid[] =
  12  * "$Revision: 1.36.1.4 $$Date: 1995/03/29 06:14:14 $";
  13  *
  14  *  linux/kernel/cyclades.c
  15  *
  16  * Maintained by Marcio Saito (cyclades@netcom.com) and
  17  * Randolph Bentson (bentson@grieg.seaslug.org)
  18  *
  19  * Much of the design and some of the code came from serial.c
  20  * which was copyright (C) 1991, 1992  Linus Torvalds.  It was
  21  * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
  22  * and then fixed as suggested by Michael K. Johnson 12/12/92.
  23  *
  24  * This version does not support shared irq's.
  25  *
  26  * $Log: cyclades.c,v $
  27  * Revision 1.36.1.4  1995/03/29  06:14:14  bentson
  28  * disambiguate between Cyclom-16Y and Cyclom-32Ye;
  29  *
  30  * Changes:
  31  *
  32  * 200 lines of changes record removed - RGH 11-10-95, starting work on
  33  * converting this to drive serial ports on mvme166 (cd2401).
  34  *
  35  * Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 2000/08/25
  36  * - get rid of verify_area
  37  * - use get_user to access memory from userspace in set_threshold,
  38  *   set_default_threshold and set_timeout
  39  * - don't use the panic function in serial167_init
  40  * - do resource release on failure on serial167_init
  41  * - include missing restore_flags in mvme167_serial_console_setup
  42  *
  43  * Kars de Jong <jongk@linux-m68k.org> - 2004/09/06
  44  * - replace bottom half handler with task queue handler
  45  */
  46
  47 #include <linux/errno.h>
  48 #include <linux/signal.h>
  49 #include <linux/sched.h>
  50 #include <linux/timer.h>
  51 #include <linux/tty.h>
  52 #include <linux/interrupt.h>
  53 #include <linux/serial.h>
  54 #include <linux/serialP.h>
  55 #include <linux/smp_lock.h>
  56 #include <linux/string.h>
  57 #include <linux/fcntl.h>
  58 #include <linux/ptrace.h>
  59 #include <linux/serial167.h>
  60 #include <linux/delay.h>
  61 #include <linux/major.h>
  62 #include <linux/mm.h>
  63 #include <linux/console.h>
  64 #include <linux/module.h>
  65 #include <linux/bitops.h>
  66 #include <linux/tty_flip.h>
  67 #include <linux/gfp.h>
  68
  69 #include <asm/system.h>
  70 #include <asm/io.h>
  71 #include <asm/mvme16xhw.h>
  72 #include <asm/bootinfo.h>
  73 #include <asm/setup.h>
  74
  75 #include <linux/types.h>
  76 #include <linux/kernel.h>
  77
  78 #include <asm/uaccess.h>
  79 #include <linux/init.h>
  80
  81 #define SERIAL_PARANOIA_CHECK
  82 #undef  SERIAL_DEBUG_OPEN
  83 #undef  SERIAL_DEBUG_THROTTLE
  84 #undef  SERIAL_DEBUG_OTHER
  85 #undef  SERIAL_DEBUG_IO
  86 #undef  SERIAL_DEBUG_COUNT
  87 #undef  SERIAL_DEBUG_DTR
  88 #undef  CYCLOM_16Y_HACK
  89 #define  CYCLOM_ENABLE_MONITORING
  90
  91 #define WAKEUP_CHARS 256
  92
  93 #define STD_COM_FLAGS (0)
  94
  95 static struct tty_driver *cy_serial_driver;
  96 extern int serial_console;
  97 static struct cyclades_port *serial_console_info = NULL;
  98 static unsigned int serial_console_cflag = 0;
  99 u_char initial_console_speed;
 100
 101 /* Base address of cd2401 chip on mvme166/7 */
 102
 103 #define BASE_ADDR (0xfff45000)
 104 #define pcc2chip        ((volatile u_char *)0xfff42000)
 105 #define PccSCCMICR      0x1d
 106 #define PccSCCTICR      0x1e
 107 #define PccSCCRICR      0x1f
 108 #define PccTPIACKR      0x25
 109 #define PccRPIACKR      0x27
 110 #define PccIMLR         0x3f
 111
 112 /* This is the per-port data structure */
 113 struct cyclades_port cy_port[] = {
 114         /* CARD#  */
 115         {-1},                   /* ttyS0 */
 116         {-1},                   /* ttyS1 */
 117         {-1},                   /* ttyS2 */
 118         {-1},                   /* ttyS3 */
 119 };
 120
 121 #define NR_PORTS        ARRAY_SIZE(cy_port)
 122
 123 /*
 124  * This is used to look up the divisor speeds and the timeouts
 125  * We're normally limited to 15 distinct baud rates.  The extra
 126  * are accessed via settings in info->flags.
 127  *         0,     1,     2,     3,     4,     5,     6,     7,     8,     9,
 128  *        10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
 129  *                                                  HI            VHI
 130  */
 131 static int baud_table[] = {
 132         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
 133         1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
 134         0
 135 };
 136
 137 #if 0
 138 static char baud_co[] = {       /* 25 MHz clock option table */
 139         /* value =>    00    01   02    03    04 */
 140         /* divide by    8    32   128   512  2048 */
 141         0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
 142         0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 143 };
 144
 145 static char baud_bpr[] = {      /* 25 MHz baud rate period table */
 146         0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
 147         0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
 148 };
 149 #endif
 150
 151 /* I think 166 brd clocks 2401 at 20MHz.... */
 152
 153 /* These values are written directly to tcor, and >> 5 for writing to rcor */
 154 static u_char baud_co[] = {     /* 20 MHz clock option table */
 155         0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x60, 0x60, 0x40,
 156         0x40, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 157 };
 158
 159 /* These values written directly to tbpr/rbpr */
 160 static u_char baud_bpr[] = {    /* 20 MHz baud rate period table */
 161         0x00, 0xc0, 0x80, 0x58, 0x6c, 0x40, 0xc0, 0x81, 0x40, 0x81,
 162         0x57, 0x40, 0x81, 0x40, 0x81, 0x40, 0x2b, 0x20, 0x15, 0x10
 163 };
 164
 165 static u_char baud_cor4[] = {   /* receive threshold */
 166         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
 167         0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07
 168 };
 169
 170 static void shutdown(struct cyclades_port *);
 171 static int startup(struct cyclades_port *);
 172 static void cy_throttle(struct tty_struct *);
 173 static void cy_unthrottle(struct tty_struct *);
 174 static void config_setup(struct cyclades_port *);
 175 #ifdef CYCLOM_SHOW_STATUS
 176 static void show_status(int);
 177 #endif
 178
 179 /*
 180  * I have my own version of udelay(), as it is needed when initialising
 181  * the chip, before the delay loop has been calibrated.  Should probably
 182  * reference one of the vmechip2 or pccchip2 counter for an accurate
 183  * delay, but this wild guess will do for now.
 184  */
 185
 186 void my_udelay(long us)
 187 {
 188         u_char x;
 189         volatile u_char *p = &x;
 190         int i;
 191
 192         while (us--)
 193                 for (i = 100; i; i--)
 194                         x |= *p;
 195 }
 196
 197 static inline int serial_paranoia_check(struct cyclades_port *info, char *name,
 198                 const char *routine)
 199 {
 200 #ifdef SERIAL_PARANOIA_CHECK
 201         if (!info) {
 202                 printk("Warning: null cyclades_port for (%s) in %s\n", name,
 203                                 routine);
 204                 return 1;
 205         }
 206
 207         if (info < &cy_port[0] || info >= &cy_port[NR_PORTS]) {
 208                 printk("Warning: cyclades_port out of range for (%s) in %s\n",
 209                                 name, routine);
 210                 return 1;
 211         }
 212
 213         if (info->magic != CYCLADES_MAGIC) {
 214                 printk("Warning: bad magic number for serial struct (%s) in "
 215                                 "%s\n", name, routine);
 216                 return 1;
 217         }
 218 #endif
 219         return 0;
 220 }                               /* serial_paranoia_check */
 221
 222 #if 0
 223 /* The following diagnostic routines allow the driver to spew
 224    information on the screen, even (especially!) during interrupts.
 225  */
 226 void SP(char *data)
 227 {
 228         unsigned long flags;
 229         local_irq_save(flags);
 230         printk(KERN_EMERG "%s", data);
 231         local_irq_restore(flags);
 232 }
 233
 234 char scrn[2];
 235 void CP(char data)
 236 {
 237         unsigned long flags;
 238         local_irq_save(flags);
 239         scrn[0] = data;
 240         printk(KERN_EMERG "%c", scrn);
 241         local_irq_restore(flags);
 242 }                               /* CP */
 243
 244 void CP1(int data)
 245 {
 246         (data < 10) ? CP(data + '0') : CP(data + 'A' - 10);
 247 }                               /* CP1 */
 248 void CP2(int data)
 249 {
 250         CP1((data >> 4) & 0x0f);
 251         CP1(data & 0x0f);
 252 }                               /* CP2 */
 253 void CP4(int data)
 254 {
 255         CP2((data >> 8) & 0xff);
 256         CP2(data & 0xff);
 257 }                               /* CP4 */
 258 void CP8(long data)
 259 {
 260         CP4((data >> 16) & 0xffff);
 261         CP4(data & 0xffff);
 262 }                               /* CP8 */
 263 #endif
 264
 265 /* This routine waits up to 1000 micro-seconds for the previous
 266    command to the Cirrus chip to complete and then issues the
 267    new command.  An error is returned if the previous command
 268    didn't finish within the time limit.
 269  */
 270 u_short write_cy_cmd(volatile u_char * base_addr, u_char cmd)
 271 {
 272         unsigned long flags;
 273         volatile int i;
 274
 275         local_irq_save(flags);
 276         /* Check to see that the previous command has completed */
 277         for (i = 0; i < 100; i++) {
 278                 if (base_addr[CyCCR] == 0) {
 279                         break;
 280                 }
 281                 my_udelay(10L);
 282         }
 283         /* if the CCR never cleared, the previous command
 284            didn't finish within the "reasonable time" */
 285         if (i == 10) {
 286                 local_irq_restore(flags);
 287                 return (-1);
 288         }
 289
 290         /* Issue the new command */
 291         base_addr[CyCCR] = cmd;
 292         local_irq_restore(flags);
 293         return (0);
 294 }                               /* write_cy_cmd */
 295
 296 /* cy_start and cy_stop provide software output flow control as a
 297    function of XON/XOFF, software CTS, and other such stuff. */
 298
 299 static void cy_stop(struct tty_struct *tty)
 300 {
 301         struct cyclades_port *info = tty->driver_data;
 302         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 303         int channel;
 304         unsigned long flags;
 305
 306 #ifdef SERIAL_DEBUG_OTHER
 307         printk("cy_stop %s\n", tty->name);      /* */
 308 #endif
 309
 310         if (serial_paranoia_check(info, tty->name, "cy_stop"))
 311                 return;
 312
 313         channel = info->line;
 314
 315         local_irq_save(flags);
 316         base_addr[CyCAR] = (u_char) (channel);  /* index channel */
 317         base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 318         local_irq_restore(flags);
 319 }                               /* cy_stop */
 320
 321 static void cy_start(struct tty_struct *tty)
 322 {
 323         struct cyclades_port *info = tty->driver_data;
 324         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 325         int channel;
 326         unsigned long flags;
 327
 328 #ifdef SERIAL_DEBUG_OTHER
 329         printk("cy_start %s\n", tty->name);     /* */
 330 #endif
 331
 332         if (serial_paranoia_check(info, tty->name, "cy_start"))
 333                 return;
 334
 335         channel = info->line;
 336
 337         local_irq_save(flags);
 338         base_addr[CyCAR] = (u_char) (channel);
 339         base_addr[CyIER] |= CyTxMpty;
 340         local_irq_restore(flags);
 341 }                               /* cy_start */
 342
 343 /* The real interrupt service routines are called
 344    whenever the card wants its hand held--chars
 345    received, out buffer empty, modem change, etc.
 346  */
 347 static irqreturn_t cd2401_rxerr_interrupt(int irq, void *dev_id)
 348 {
 349         struct tty_struct *tty;
 350         struct cyclades_port *info;
 351         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 352         unsigned char err, rfoc;
 353         int channel;
 354         char data;
 355
 356         /* determine the channel and change to that context */
 357         channel = (u_short) (base_addr[CyLICR] >> 2);
 358         info = &cy_port[channel];
 359         info->last_active = jiffies;
 360
 361         if ((err = base_addr[CyRISR]) & CyTIMEOUT) {
 362                 /* This is a receive timeout interrupt, ignore it */
 363                 base_addr[CyREOIR] = CyNOTRANS;
 364                 return IRQ_HANDLED;
 365         }
 366
 367         /* Read a byte of data if there is any - assume the error
 368          * is associated with this character */
 369
 370         if ((rfoc = base_addr[CyRFOC]) != 0)
 371                 data = base_addr[CyRDR];
 372         else
 373                 data = 0;
 374
 375         /* if there is nowhere to put the data, discard it */
 376         if (info->tty == 0) {
 377                 base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
 378                 return IRQ_HANDLED;
 379         } else {                /* there is an open port for this data */
 380                 tty = info->tty;
 381                 if (err & info->ignore_status_mask) {
 382                         base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
 383                         return IRQ_HANDLED;
 384                 }
 385                 if (tty_buffer_request_room(tty, 1) != 0) {
 386                         if (err & info->read_status_mask) {
 387                                 if (err & CyBREAK) {
 388                                         tty_insert_flip_char(tty, data,
 389                                                              TTY_BREAK);
 390                                         if (info->flags & ASYNC_SAK) {
 391                                                 do_SAK(tty);
 392                                         }
 393                                 } else if (err & CyFRAME) {
 394                                         tty_insert_flip_char(tty, data,
 395                                                              TTY_FRAME);
 396                                 } else if (err & CyPARITY) {
 397                                         tty_insert_flip_char(tty, data,
 398                                                              TTY_PARITY);
 399                                 } else if (err & CyOVERRUN) {
 400                                         tty_insert_flip_char(tty, 0,
 401                                                              TTY_OVERRUN);
 402                                         /*
 403                                            If the flip buffer itself is
 404                                            overflowing, we still lose
 405                                            the next incoming character.
 406                                          */
 407                                         if (tty_buffer_request_room(tty, 1) !=
 408                                             0) {
 409                                                 tty_insert_flip_char(tty, data,
 410                                                                      TTY_FRAME);
 411                                         }
 412                                         /* These two conditions may imply */
 413                                         /* a normal read should be done. */
 414                                         /* else if(data & CyTIMEOUT) */
 415                                         /* else if(data & CySPECHAR) */
 416                                 } else {
 417                                         tty_insert_flip_char(tty, 0,
 418                                                              TTY_NORMAL);
 419                                 }
 420                         } else {
 421                                 tty_insert_flip_char(tty, data, TTY_NORMAL);
 422                         }
 423                 } else {
 424                         /* there was a software buffer overrun
 425                            and nothing could be done about it!!! */
 426                 }
 427         }
 428         tty_schedule_flip(tty);
 429         /* end of service */
 430         base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
 431         return IRQ_HANDLED;
 432 }                               /* cy_rxerr_interrupt */
 433
 434 static irqreturn_t cd2401_modem_interrupt(int irq, void *dev_id)
 435 {
 436         struct cyclades_port *info;
 437         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 438         int channel;
 439         int mdm_change;
 440         int mdm_status;
 441
 442         /* determine the channel and change to that context */
 443         channel = (u_short) (base_addr[CyLICR] >> 2);
 444         info = &cy_port[channel];
 445         info->last_active = jiffies;
 446
 447         mdm_change = base_addr[CyMISR];
 448         mdm_status = base_addr[CyMSVR1];
 449
 450         if (info->tty == 0) {   /* nowhere to put the data, ignore it */
 451                 ;
 452         } else {
 453                 if ((mdm_change & CyDCD)
 454                     && (info->flags & ASYNC_CHECK_CD)) {
 455                         if (mdm_status & CyDCD) {
 456 /* CP('!'); */
 457                                 wake_up_interruptible(&info->open_wait);
 458                         } else {
 459 /* CP('@'); */
 460                                 tty_hangup(info->tty);
 461                                 wake_up_interruptible(&info->open_wait);
 462                                 info->flags &= ~ASYNC_NORMAL_ACTIVE;
 463                         }
 464                 }
 465                 if ((mdm_change & CyCTS)
 466                     && (info->flags & ASYNC_CTS_FLOW)) {
 467                         if (info->tty->stopped) {
 468                                 if (mdm_status & CyCTS) {
 469                                         /* !!! cy_start isn't used because... */
 470                                         info->tty->stopped = 0;
 471                                         base_addr[CyIER] |= CyTxMpty;
 472                                         tty_wakeup(info->tty);
 473                                 }
 474                         } else {
 475                                 if (!(mdm_status & CyCTS)) {
 476                                         /* !!! cy_stop isn't used because... */
 477                                         info->tty->stopped = 1;
 478                                         base_addr[CyIER] &=
 479                                             ~(CyTxMpty | CyTxRdy);
 480                                 }
 481                         }
 482                 }
 483                 if (mdm_status & CyDSR) {
 484                 }
 485         }
 486         base_addr[CyMEOIR] = 0;
 487         return IRQ_HANDLED;
 488 }                               /* cy_modem_interrupt */
 489
 490 static irqreturn_t cd2401_tx_interrupt(int irq, void *dev_id)
 491 {
 492         struct cyclades_port *info;
 493         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 494         int channel;
 495         int char_count, saved_cnt;
 496         int outch;
 497
 498         /* determine the channel and change to that context */
 499         channel = (u_short) (base_addr[CyLICR] >> 2);
 500
 501         /* validate the port number (as configured and open) */
 502         if ((channel < 0) || (NR_PORTS <= channel)) {
 503                 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 504                 base_addr[CyTEOIR] = CyNOTRANS;
 505                 return IRQ_HANDLED;
 506         }
 507         info = &cy_port[channel];
 508         info->last_active = jiffies;
 509         if (info->tty == 0) {
 510                 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 511                 base_addr[CyTEOIR] = CyNOTRANS;
 512                 return IRQ_HANDLED;
 513         }
 514
 515         /* load the on-chip space available for outbound data */
 516         saved_cnt = char_count = base_addr[CyTFTC];
 517
 518         if (info->x_char) {     /* send special char */
 519                 outch = info->x_char;
 520                 base_addr[CyTDR] = outch;
 521                 char_count--;
 522                 info->x_char = 0;
 523         }
 524
 525         if (info->x_break) {
 526                 /*  The Cirrus chip requires the "Embedded Transmit
 527                    Commands" of start break, delay, and end break
 528                    sequences to be sent.  The duration of the
 529                    break is given in TICs, which runs at HZ
 530                    (typically 100) and the PPR runs at 200 Hz,
 531                    so the delay is duration * 200/HZ, and thus a
 532                    break can run from 1/100 sec to about 5/4 sec.
 533                    Need to check these values - RGH 141095.
 534                  */
 535                 base_addr[CyTDR] = 0;   /* start break */
 536                 base_addr[CyTDR] = 0x81;
 537                 base_addr[CyTDR] = 0;   /* delay a bit */
 538                 base_addr[CyTDR] = 0x82;
 539                 base_addr[CyTDR] = info->x_break * 200 / HZ;
 540                 base_addr[CyTDR] = 0;   /* terminate break */
 541                 base_addr[CyTDR] = 0x83;
 542                 char_count -= 7;
 543                 info->x_break = 0;
 544         }
 545
 546         while (char_count > 0) {
 547                 if (!info->xmit_cnt) {
 548                         base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 549                         break;
 550                 }
 551                 if (info->xmit_buf == 0) {
 552                         base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 553                         break;
 554                 }
 555                 if (info->tty->stopped || info->tty->hw_stopped) {
 556                         base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 557                         break;
 558                 }
 559                 /* Because the Embedded Transmit Commands have been
 560                    enabled, we must check to see if the escape
 561                    character, NULL, is being sent.  If it is, we
 562                    must ensure that there is room for it to be
 563                    doubled in the output stream.  Therefore we
 564                    no longer advance the pointer when the character
 565                    is fetched, but rather wait until after the check
 566                    for a NULL output character. (This is necessary
 567                    because there may not be room for the two chars
 568                    needed to send a NULL.
 569                  */
 570                 outch = info->xmit_buf[info->xmit_tail];
 571                 if (outch) {
 572                         info->xmit_cnt--;
 573                         info->xmit_tail = (info->xmit_tail + 1)
 574                             & (PAGE_SIZE - 1);
 575                         base_addr[CyTDR] = outch;
 576                         char_count--;
 577                 } else {
 578                         if (char_count > 1) {
 579                                 info->xmit_cnt--;
 580                                 info->xmit_tail = (info->xmit_tail + 1)
 581                                     & (PAGE_SIZE - 1);
 582                                 base_addr[CyTDR] = outch;
 583                                 base_addr[CyTDR] = 0;
 584                                 char_count--;
 585                                 char_count--;
 586                         } else {
 587                                 break;
 588                         }
 589                 }
 590         }
 591
 592         if (info->xmit_cnt < WAKEUP_CHARS)
 593                 tty_wakeup(info->tty);
 594
 595         base_addr[CyTEOIR] = (char_count != saved_cnt) ? 0 : CyNOTRANS;
 596         return IRQ_HANDLED;
 597 }                               /* cy_tx_interrupt */
 598
 599 static irqreturn_t cd2401_rx_interrupt(int irq, void *dev_id)
 600 {
 601         struct tty_struct *tty;
 602         struct cyclades_port *info;
 603         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 604         int channel;
 605         char data;
 606         int char_count;
 607         int save_cnt;
 608
 609         /* determine the channel and change to that context */
 610         channel = (u_short) (base_addr[CyLICR] >> 2);
 611         info = &cy_port[channel];
 612         info->last_active = jiffies;
 613         save_cnt = char_count = base_addr[CyRFOC];
 614
 615                 /* if there is nowhere to put the data, discard it */
 616         if (info->tty == 0) {
 617                 while (char_count--) {
 618                         data = base_addr[CyRDR];
 619                 }
 620         } else {                /* there is an open port for this data */
 621                 tty = info->tty;
 622                 /* load # characters available from the chip */
 623
 624 #ifdef CYCLOM_ENABLE_MONITORING
 625                 ++info->mon.int_count;
 626                 info->mon.char_count += char_count;
 627                 if (char_count > info->mon.char_max)
 628                         info->mon.char_max = char_count;
 629                 info->mon.char_last = char_count;
 630 #endif
 631                 while (char_count--) {
 632                         data = base_addr[CyRDR];
 633                         tty_insert_flip_char(tty, data, TTY_NORMAL);
 634 #ifdef CYCLOM_16Y_HACK
 635                         udelay(10L);
 636 #endif
 637                 }
 638                 tty_schedule_flip(tty);
 639         }
 640         /* end of service */
 641         base_addr[CyREOIR] = save_cnt ? 0 : CyNOTRANS;
 642         return IRQ_HANDLED;
 643 }                               /* cy_rx_interrupt */
 644
 645 /* This is called whenever a port becomes active;
 646    interrupts are enabled and DTR & RTS are turned on.
 647  */
 648 static int startup(struct cyclades_port *info)
 649 {
 650         unsigned long flags;
 651         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 652         int channel;
 653
 654         if (info->flags & ASYNC_INITIALIZED) {
 655                 return 0;
 656         }
 657
 658         if (!info->type) {
 659                 if (info->tty) {
 660                         set_bit(TTY_IO_ERROR, &info->tty->flags);
 661                 }
 662                 return 0;
 663         }
 664         if (!info->xmit_buf) {
 665                 info->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
 666                 if (!info->xmit_buf) {
 667                         return -ENOMEM;
 668                 }
 669         }
 670
 671         config_setup(info);
 672
 673         channel = info->line;
 674
 675 #ifdef SERIAL_DEBUG_OPEN
 676         printk("startup channel %d\n", channel);
 677 #endif
 678
 679         local_irq_save(flags);
 680         base_addr[CyCAR] = (u_char) channel;
 681         write_cy_cmd(base_addr, CyENB_RCVR | CyENB_XMTR);
 682
 683         base_addr[CyCAR] = (u_char) channel;    /* !!! Is this needed? */
 684         base_addr[CyMSVR1] = CyRTS;
 685 /* CP('S');CP('1'); */
 686         base_addr[CyMSVR2] = CyDTR;
 687
 688 #ifdef SERIAL_DEBUG_DTR
 689         printk("cyc: %d: raising DTR\n", __LINE__);
 690         printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
 691                base_addr[CyMSVR2]);
 692 #endif
 693
 694         base_addr[CyIER] |= CyRxData;
 695         info->flags |= ASYNC_INITIALIZED;
 696
 697         if (info->tty) {
 698                 clear_bit(TTY_IO_ERROR, &info->tty->flags);
 699         }
 700         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
 701
 702         local_irq_restore(flags);
 703
 704 #ifdef SERIAL_DEBUG_OPEN
 705         printk(" done\n");
 706 #endif
 707         return 0;
 708 }                               /* startup */
 709
 710 void start_xmit(struct cyclades_port *info)
 711 {
 712         unsigned long flags;
 713         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
 714         int channel;
 715
 716         channel = info->line;
 717         local_irq_save(flags);
 718         base_addr[CyCAR] = channel;
 719         base_addr[CyIER] |= CyTxMpty;
 720         local_irq_restore(flags);
 721 }                               /* start_xmit */
 722
 723 /*
 724  * This routine shuts down a serial port; interrupts are disabled,
 725  * and DTR is dropped if the hangup on close termio flag is on.
 726  */
 727 static void shutdown(struct cyclades_port *info)
 728 {
 729         unsigned long flags;
 730         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
 731         int channel;
 732
 733         if (!(info->flags & ASYNC_INITIALIZED)) {
 734 /* CP('$'); */
 735                 return;
 736         }
 737
 738         channel = info->line;
 739
 740 #ifdef SERIAL_DEBUG_OPEN
 741         printk("shutdown channel %d\n", channel);
 742 #endif
 743
 744         /* !!! REALLY MUST WAIT FOR LAST CHARACTER TO BE
 745            SENT BEFORE DROPPING THE LINE !!!  (Perhaps
 746            set some flag that is read when XMTY happens.)
 747            Other choices are to delay some fixed interval
 748            or schedule some later processing.
 749          */
 750         local_irq_save(flags);
 751         if (info->xmit_buf) {
 752                 free_page((unsigned long)info->xmit_buf);
 753                 info->xmit_buf = NULL;
 754         }
 755
 756         base_addr[CyCAR] = (u_char) channel;
 757         if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
 758                 base_addr[CyMSVR1] = 0;
 759 /* CP('C');CP('1'); */
 760                 base_addr[CyMSVR2] = 0;
 761 #ifdef SERIAL_DEBUG_DTR
 762                 printk("cyc: %d: dropping DTR\n", __LINE__);
 763                 printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
 764                        base_addr[CyMSVR2]);
 765 #endif
 766         }
 767         write_cy_cmd(base_addr, CyDIS_RCVR);
 768         /* it may be appropriate to clear _XMIT at
 769            some later date (after testing)!!! */
 770
 771         if (info->tty) {
 772                 set_bit(TTY_IO_ERROR, &info->tty->flags);
 773         }
 774         info->flags &= ~ASYNC_INITIALIZED;
 775         local_irq_restore(flags);
 776
 777 #ifdef SERIAL_DEBUG_OPEN
 778         printk(" done\n");
 779 #endif
 780 }                               /* shutdown */
 781
 782 /*
 783  * This routine finds or computes the various line characteristics.
 784  */
 785 static void config_setup(struct cyclades_port *info)
 786 {
 787         unsigned long flags;
 788         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
 789         int channel;
 790         unsigned cflag;
 791         int i;
 792         unsigned char ti, need_init_chan = 0;
 793
 794         if (!info->tty || !info->tty->termios) {
 795                 return;
 796         }
 797         if (info->line == -1) {
 798                 return;
 799         }
 800         cflag = info->tty->termios->c_cflag;
 801
 802         /* baud rate */
 803         i = cflag & CBAUD;
 804 #ifdef CBAUDEX
 805 /* Starting with kernel 1.1.65, there is direct support for
 806    higher baud rates.  The following code supports those
 807    changes.  The conditional aspect allows this driver to be
 808    used for earlier as well as later kernel versions.  (The
 809    mapping is slightly different from serial.c because there
 810    is still the possibility of supporting 75 kbit/sec with
 811    the Cyclades board.)
 812  */
 813         if (i & CBAUDEX) {
 814                 if (i == B57600)
 815                         i = 16;
 816                 else if (i == B115200)
 817                         i = 18;
 818 #ifdef B78600
 819                 else if (i == B78600)
 820                         i = 17;
 821 #endif
 822                 else
 823                         info->tty->termios->c_cflag &= ~CBAUDEX;
 824         }
 825 #endif
 826         if (i == 15) {
 827                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
 828                         i += 1;
 829                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
 830                         i += 3;
 831         }
 832         /* Don't ever change the speed of the console port.  It will
 833          * run at the speed specified in bootinfo, or at 19.2K */
 834         /* Actually, it should run at whatever speed 166Bug was using */
 835         /* Note info->timeout isn't used at present */
 836         if (info != serial_console_info) {
 837                 info->tbpr = baud_bpr[i];       /* Tx BPR */
 838                 info->tco = baud_co[i]; /* Tx CO */
 839                 info->rbpr = baud_bpr[i];       /* Rx BPR */
 840                 info->rco = baud_co[i] >> 5;    /* Rx CO */
 841                 if (baud_table[i] == 134) {
 842                         info->timeout =
 843                             (info->xmit_fifo_size * HZ * 30 / 269) + 2;
 844                         /* get it right for 134.5 baud */
 845                 } else if (baud_table[i]) {
 846                         info->timeout =
 847                             (info->xmit_fifo_size * HZ * 15 / baud_table[i]) +
 848                             2;
 849                         /* this needs to be propagated into the card info */
 850                 } else {
 851                         info->timeout = 0;
 852                 }
 853         }
 854         /* By tradition (is it a standard?) a baud rate of zero
 855            implies the line should be/has been closed.  A bit
 856            later in this routine such a test is performed. */
 857
 858         /* byte size and parity */
 859         info->cor7 = 0;
 860         info->cor6 = 0;
 861         info->cor5 = 0;
 862         info->cor4 = (info->default_threshold ? info->default_threshold : baud_cor4[i]);        /* receive threshold */
 863         /* Following two lines added 101295, RGH. */
 864         /* It is obviously wrong to access CyCORx, and not info->corx here,
 865          * try and remember to fix it later! */
 866         channel = info->line;
 867         base_addr[CyCAR] = (u_char) channel;
 868         if (C_CLOCAL(info->tty)) {
 869                 if (base_addr[CyIER] & CyMdmCh)
 870                         base_addr[CyIER] &= ~CyMdmCh;   /* without modem intr */
 871                 /* ignore 1->0 modem transitions */
 872                 if (base_addr[CyCOR4] & (CyDSR | CyCTS | CyDCD))
 873                         base_addr[CyCOR4] &= ~(CyDSR | CyCTS | CyDCD);
 874                 /* ignore 0->1 modem transitions */
 875                 if (base_addr[CyCOR5] & (CyDSR | CyCTS | CyDCD))
 876                         base_addr[CyCOR5] &= ~(CyDSR | CyCTS | CyDCD);
 877         } else {
 878                 if ((base_addr[CyIER] & CyMdmCh) != CyMdmCh)
 879                         base_addr[CyIER] |= CyMdmCh;    /* with modem intr */
 880                 /* act on 1->0 modem transitions */
 881                 if ((base_addr[CyCOR4] & (CyDSR | CyCTS | CyDCD)) !=
 882                     (CyDSR | CyCTS | CyDCD))
 883                         base_addr[CyCOR4] |= CyDSR | CyCTS | CyDCD;
 884                 /* act on 0->1 modem transitions */
 885                 if ((base_addr[CyCOR5] & (CyDSR | CyCTS | CyDCD)) !=
 886                     (CyDSR | CyCTS | CyDCD))
 887                         base_addr[CyCOR5] |= CyDSR | CyCTS | CyDCD;
 888         }
 889         info->cor3 = (cflag & CSTOPB) ? Cy_2_STOP : Cy_1_STOP;
 890         info->cor2 = CyETC;
 891         switch (cflag & CSIZE) {
 892         case CS5:
 893                 info->cor1 = Cy_5_BITS;
 894                 break;
 895         case CS6:
 896                 info->cor1 = Cy_6_BITS;
 897                 break;
 898         case CS7:
 899                 info->cor1 = Cy_7_BITS;
 900                 break;
 901         case CS8:
 902                 info->cor1 = Cy_8_BITS;
 903                 break;
 904         }
 905         if (cflag & PARENB) {
 906                 if (cflag & PARODD) {
 907                         info->cor1 |= CyPARITY_O;
 908                 } else {
 909                         info->cor1 |= CyPARITY_E;
 910                 }
 911         } else {
 912                 info->cor1 |= CyPARITY_NONE;
 913         }
 914
 915         /* CTS flow control flag */
 916 #if 0
 917         /* Don't complcate matters for now! RGH 141095 */
 918         if (cflag & CRTSCTS) {
 919                 info->flags |= ASYNC_CTS_FLOW;
 920                 info->cor2 |= CyCtsAE;
 921         } else {
 922                 info->flags &= ~ASYNC_CTS_FLOW;
 923                 info->cor2 &= ~CyCtsAE;
 924         }
 925 #endif
 926         if (cflag & CLOCAL)
 927                 info->flags &= ~ASYNC_CHECK_CD;
 928         else
 929                 info->flags |= ASYNC_CHECK_CD;
 930
 931      /***********************************************
 932         The hardware option, CyRtsAO, presents RTS when
 933         the chip has characters to send.  Since most modems
 934         use RTS as reverse (inbound) flow control, this
 935         option is not used.  If inbound flow control is
 936         necessary, DTR can be programmed to provide the
 937         appropriate signals for use with a non-standard
 938         cable.  Contact Marcio Saito for details.
 939      ***********************************************/
 940
 941         channel = info->line;
 942
 943         local_irq_save(flags);
 944         base_addr[CyCAR] = (u_char) channel;
 945
 946         /* CyCMR set once only in mvme167_init_serial() */
 947         if (base_addr[CyLICR] != channel << 2)
 948                 base_addr[CyLICR] = channel << 2;
 949         if (base_addr[CyLIVR] != 0x5c)
 950                 base_addr[CyLIVR] = 0x5c;
 951
 952         /* tx and rx baud rate */
 953
 954         if (base_addr[CyCOR1] != info->cor1)
 955                 need_init_chan = 1;
 956         if (base_addr[CyTCOR] != info->tco)
 957                 base_addr[CyTCOR] = info->tco;
 958         if (base_addr[CyTBPR] != info->tbpr)
 959                 base_addr[CyTBPR] = info->tbpr;
 960         if (base_addr[CyRCOR] != info->rco)
 961                 base_addr[CyRCOR] = info->rco;
 962         if (base_addr[CyRBPR] != info->rbpr)
 963                 base_addr[CyRBPR] = info->rbpr;
 964
 965         /* set line characteristics  according configuration */
 966
 967         if (base_addr[CySCHR1] != START_CHAR(info->tty))
 968                 base_addr[CySCHR1] = START_CHAR(info->tty);
 969         if (base_addr[CySCHR2] != STOP_CHAR(info->tty))
 970                 base_addr[CySCHR2] = STOP_CHAR(info->tty);
 971         if (base_addr[CySCRL] != START_CHAR(info->tty))
 972                 base_addr[CySCRL] = START_CHAR(info->tty);
 973         if (base_addr[CySCRH] != START_CHAR(info->tty))
 974                 base_addr[CySCRH] = START_CHAR(info->tty);
 975         if (base_addr[CyCOR1] != info->cor1)
 976                 base_addr[CyCOR1] = info->cor1;
 977         if (base_addr[CyCOR2] != info->cor2)
 978                 base_addr[CyCOR2] = info->cor2;
 979         if (base_addr[CyCOR3] != info->cor3)
 980                 base_addr[CyCOR3] = info->cor3;
 981         if (base_addr[CyCOR4] != info->cor4)
 982                 base_addr[CyCOR4] = info->cor4;
 983         if (base_addr[CyCOR5] != info->cor5)
 984                 base_addr[CyCOR5] = info->cor5;
 985         if (base_addr[CyCOR6] != info->cor6)
 986                 base_addr[CyCOR6] = info->cor6;
 987         if (base_addr[CyCOR7] != info->cor7)
 988                 base_addr[CyCOR7] = info->cor7;
 989
 990         if (need_init_chan)
 991                 write_cy_cmd(base_addr, CyINIT_CHAN);
 992
 993         base_addr[CyCAR] = (u_char) channel;    /* !!! Is this needed? */
 994
 995         /* 2ms default rx timeout */
 996         ti = info->default_timeout ? info->default_timeout : 0x02;
 997         if (base_addr[CyRTPRL] != ti)
 998                 base_addr[CyRTPRL] = ti;
 999         if (base_addr[CyRTPRH] != 0)
1000                 base_addr[CyRTPRH] = 0;
1001
1002         /* Set up RTS here also ????? RGH 141095 */
1003         if (i == 0) {           /* baud rate is zero, turn off line */
1004                 if ((base_addr[CyMSVR2] & CyDTR) == CyDTR)
1005                         base_addr[CyMSVR2] = 0;
1006 #ifdef SERIAL_DEBUG_DTR
1007                 printk("cyc: %d: dropping DTR\n", __LINE__);
1008                 printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1009                        base_addr[CyMSVR2]);
1010 #endif
1011         } else {
1012                 if ((base_addr[CyMSVR2] & CyDTR) != CyDTR)
1013                         base_addr[CyMSVR2] = CyDTR;
1014 #ifdef SERIAL_DEBUG_DTR
1015                 printk("cyc: %d: raising DTR\n", __LINE__);
1016                 printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1017                        base_addr[CyMSVR2]);
1018 #endif
1019         }
1020
1021         if (info->tty) {
1022                 clear_bit(TTY_IO_ERROR, &info->tty->flags);
1023         }
1024
1025         local_irq_restore(flags);
1026
1027 }                               /* config_setup */
1028
1029 static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1030 {
1031         struct cyclades_port *info = tty->driver_data;
1032         unsigned long flags;
1033
1034 #ifdef SERIAL_DEBUG_IO
1035         printk("cy_put_char %s(0x%02x)\n", tty->name, ch);
1036 #endif
1037
1038         if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1039                 return 0;
1040
1041         if (!info->xmit_buf)
1042                 return 0;
1043
1044         local_irq_save(flags);
1045         if (info->xmit_cnt >= PAGE_SIZE - 1) {
1046                 local_irq_restore(flags);
1047                 return 0;
1048         }
1049
1050         info->xmit_buf[info->xmit_head++] = ch;
1051         info->xmit_head &= PAGE_SIZE - 1;
1052         info->xmit_cnt++;
1053         local_irq_restore(flags);
1054         return 1;
1055 }                               /* cy_put_char */
1056
1057 static void cy_flush_chars(struct tty_struct *tty)
1058 {
1059         struct cyclades_port *info = tty->driver_data;
1060         unsigned long flags;
1061         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1062         int channel;
1063
1064 #ifdef SERIAL_DEBUG_IO
1065         printk("cy_flush_chars %s\n", tty->name);       /* */
1066 #endif
1067
1068         if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1069                 return;
1070
1071         if (info->xmit_cnt <= 0 || tty->stopped
1072             || tty->hw_stopped || !info->xmit_buf)
1073                 return;
1074
1075         channel = info->line;
1076
1077         local_irq_save(flags);
1078         base_addr[CyCAR] = channel;
1079         base_addr[CyIER] |= CyTxMpty;
1080         local_irq_restore(flags);
1081 }                               /* cy_flush_chars */
1082
1083 /* This routine gets called when tty_write has put something into
1084     the write_queue.  If the port is not already transmitting stuff,
1085     start it off by enabling interrupts.  The interrupt service
1086     routine will then ensure that the characters are sent.  If the
1087     port is already active, there is no need to kick it.
1088  */
1089 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1090 {
1091         struct cyclades_port *info = tty->driver_data;
1092         unsigned long flags;
1093         int c, total = 0;
1094
1095 #ifdef SERIAL_DEBUG_IO
1096         printk("cy_write %s\n", tty->name);     /* */
1097 #endif
1098
1099         if (serial_paranoia_check(info, tty->name, "cy_write")) {
1100                 return 0;
1101         }
1102
1103         if (!info->xmit_buf) {
1104                 return 0;
1105         }
1106
1107         while (1) {
1108                 local_irq_save(flags);
1109                 c = min_t(int, count, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
1110                                           SERIAL_XMIT_SIZE - info->xmit_head));
1111                 if (c <= 0) {
1112                         local_irq_restore(flags);
1113                         break;
1114                 }
1115
1116                 memcpy(info->xmit_buf + info->xmit_head, buf, c);
1117                 info->xmit_head =
1118                     (info->xmit_head + c) & (SERIAL_XMIT_SIZE - 1);
1119                 info->xmit_cnt += c;
1120                 local_irq_restore(flags);
1121
1122                 buf += c;
1123                 count -= c;
1124                 total += c;
1125         }
1126
1127         if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
1128                 start_xmit(info);
1129         }
1130         return total;
1131 }                               /* cy_write */
1132
1133 static int cy_write_room(struct tty_struct *tty)
1134 {
1135         struct cyclades_port *info = tty->driver_data;
1136         int ret;
1137
1138 #ifdef SERIAL_DEBUG_IO
1139         printk("cy_write_room %s\n", tty->name);        /* */
1140 #endif
1141
1142         if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1143                 return 0;
1144         ret = PAGE_SIZE - info->xmit_cnt - 1;
1145         if (ret < 0)
1146                 ret = 0;
1147         return ret;
1148 }                               /* cy_write_room */
1149
1150 static int cy_chars_in_buffer(struct tty_struct *tty)
1151 {
1152         struct cyclades_port *info = tty->driver_data;
1153
1154 #ifdef SERIAL_DEBUG_IO
1155         printk("cy_chars_in_buffer %s %d\n", tty->name, info->xmit_cnt);        /* */
1156 #endif
1157
1158         if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1159                 return 0;
1160
1161         return info->xmit_cnt;
1162 }                               /* cy_chars_in_buffer */
1163
1164 static void cy_flush_buffer(struct tty_struct *tty)
1165 {
1166         struct cyclades_port *info = tty->driver_data;
1167         unsigned long flags;
1168
1169 #ifdef SERIAL_DEBUG_IO
1170         printk("cy_flush_buffer %s\n", tty->name);      /* */
1171 #endif
1172
1173         if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1174                 return;
1175         local_irq_save(flags);
1176         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1177         local_irq_restore(flags);
1178         tty_wakeup(tty);
1179 }                               /* cy_flush_buffer */
1180
1181 /* This routine is called by the upper-layer tty layer to signal
1182    that incoming characters should be throttled or that the
1183    throttle should be released.
1184  */
1185 static void cy_throttle(struct tty_struct *tty)
1186 {
1187         struct cyclades_port *info = tty->driver_data;
1188         unsigned long flags;
1189         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1190         int channel;
1191
1192 #ifdef SERIAL_DEBUG_THROTTLE
1193         char buf[64];
1194
1195         printk("throttle %s: %d....\n", tty_name(tty, buf),
1196                tty->ldisc.chars_in_buffer(tty));
1197         printk("cy_throttle %s\n", tty->name);
1198 #endif
1199
1200         if (serial_paranoia_check(info, tty->name, "cy_nthrottle")) {
1201                 return;
1202         }
1203
1204         if (I_IXOFF(tty)) {
1205                 info->x_char = STOP_CHAR(tty);
1206                 /* Should use the "Send Special Character" feature!!! */
1207         }
1208
1209         channel = info->line;
1210
1211         local_irq_save(flags);
1212         base_addr[CyCAR] = (u_char) channel;
1213         base_addr[CyMSVR1] = 0;
1214         local_irq_restore(flags);
1215 }                               /* cy_throttle */
1216
1217 static void cy_unthrottle(struct tty_struct *tty)
1218 {
1219         struct cyclades_port *info = tty->driver_data;
1220         unsigned long flags;
1221         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1222         int channel;
1223
1224 #ifdef SERIAL_DEBUG_THROTTLE
1225         char buf[64];
1226
1227         printk("throttle %s: %d....\n", tty_name(tty, buf),
1228                tty->ldisc.chars_in_buffer(tty));
1229         printk("cy_unthrottle %s\n", tty->name);
1230 #endif
1231
1232         if (serial_paranoia_check(info, tty->name, "cy_nthrottle")) {
1233                 return;
1234         }
1235
1236         if (I_IXOFF(tty)) {
1237                 info->x_char = START_CHAR(tty);
1238                 /* Should use the "Send Special Character" feature!!! */
1239         }
1240
1241         channel = info->line;
1242
1243         local_irq_save(flags);
1244         base_addr[CyCAR] = (u_char) channel;
1245         base_addr[CyMSVR1] = CyRTS;
1246         local_irq_restore(flags);
1247 }                               /* cy_unthrottle */
1248
1249 static int
1250 get_serial_info(struct cyclades_port *info,
1251                 struct serial_struct __user * retinfo)
1252 {
1253         struct serial_struct tmp;
1254
1255 /* CP('g'); */
1256         if (!retinfo)
1257                 return -EFAULT;
1258         memset(&tmp, 0, sizeof(tmp));
1259         tmp.type = info->type;
1260         tmp.line = info->line;
1261         tmp.port = info->line;
1262         tmp.irq = 0;
1263         tmp.flags = info->flags;
1264         tmp.baud_base = 0;      /*!!! */
1265         tmp.close_delay = info->close_delay;
1266         tmp.custom_divisor = 0; /*!!! */
1267         tmp.hub6 = 0;           /*!!! */
1268         return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
1269 }                               /* get_serial_info */
1270
1271 static int
1272 set_serial_info(struct cyclades_port *info,
1273                 struct serial_struct __user * new_info)
1274 {
1275         struct serial_struct new_serial;
1276         struct cyclades_port old_info;
1277
1278 /* CP('s'); */
1279         if (!new_info)
1280                 return -EFAULT;
1281         if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
1282                 return -EFAULT;
1283         old_info = *info;
1284
1285         if (!capable(CAP_SYS_ADMIN)) {
1286                 if ((new_serial.close_delay != info->close_delay) ||
1287                     ((new_serial.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK) !=
1288                      (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK)))
1289                         return -EPERM;
1290                 info->flags = ((info->flags & ~ASYNC_USR_MASK) |
1291                                (new_serial.flags & ASYNC_USR_MASK));
1292                 goto check_and_exit;
1293         }
1294
1295         /*
1296          * OK, past this point, all the error checking has been done.
1297          * At this point, we start making changes.....
1298          */
1299
1300         info->flags = ((info->flags & ~ASYNC_FLAGS) |
1301                        (new_serial.flags & ASYNC_FLAGS));
1302         info->close_delay = new_serial.close_delay;
1303
1304 check_and_exit:
1305         if (info->flags & ASYNC_INITIALIZED) {
1306                 config_setup(info);
1307                 return 0;
1308         }
1309         return startup(info);
1310 }                               /* set_serial_info */
1311
1312 static int cy_tiocmget(struct tty_struct *tty, struct file *file)
1313 {
1314         struct cyclades_port *info = tty->driver_data;
1315         int channel;
1316         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1317         unsigned long flags;
1318         unsigned char status;
1319
1320         channel = info->line;
1321
1322         local_irq_save(flags);
1323         base_addr[CyCAR] = (u_char) channel;
1324         status = base_addr[CyMSVR1] | base_addr[CyMSVR2];
1325         local_irq_restore(flags);
1326
1327         return ((status & CyRTS) ? TIOCM_RTS : 0)
1328             | ((status & CyDTR) ? TIOCM_DTR : 0)
1329             | ((status & CyDCD) ? TIOCM_CAR : 0)
1330             | ((status & CyDSR) ? TIOCM_DSR : 0)
1331             | ((status & CyCTS) ? TIOCM_CTS : 0);
1332 }                               /* cy_tiocmget */
1333
1334 static int
1335 cy_tiocmset(struct tty_struct *tty, struct file *file,
1336             unsigned int set, unsigned int clear)
1337 {
1338         struct cyclades_port *info = tty->driver_data;
1339         int channel;
1340         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1341         unsigned long flags;
1342
1343         channel = info->line;
1344
1345         if (set & TIOCM_RTS) {
1346                 local_irq_save(flags);
1347                 base_addr[CyCAR] = (u_char) channel;
1348                 base_addr[CyMSVR1] = CyRTS;
1349                 local_irq_restore(flags);
1350         }
1351         if (set & TIOCM_DTR) {
1352                 local_irq_save(flags);
1353                 base_addr[CyCAR] = (u_char) channel;
1354 /* CP('S');CP('2'); */
1355                 base_addr[CyMSVR2] = CyDTR;
1356 #ifdef SERIAL_DEBUG_DTR
1357                 printk("cyc: %d: raising DTR\n", __LINE__);
1358                 printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1359                        base_addr[CyMSVR2]);
1360 #endif
1361                 local_irq_restore(flags);
1362         }
1363
1364         if (clear & TIOCM_RTS) {
1365                 local_irq_save(flags);
1366                 base_addr[CyCAR] = (u_char) channel;
1367                 base_addr[CyMSVR1] = 0;
1368                 local_irq_restore(flags);
1369         }
1370         if (clear & TIOCM_DTR) {
1371                 local_irq_save(flags);
1372                 base_addr[CyCAR] = (u_char) channel;
1373 /* CP('C');CP('2'); */
1374                 base_addr[CyMSVR2] = 0;
1375 #ifdef SERIAL_DEBUG_DTR
1376                 printk("cyc: %d: dropping DTR\n", __LINE__);
1377                 printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1378                        base_addr[CyMSVR2]);
1379 #endif
1380                 local_irq_restore(flags);
1381         }
1382
1383         return 0;
1384 }                               /* set_modem_info */
1385
1386 static void send_break(struct cyclades_port *info, int duration)
1387 {                               /* Let the transmit ISR take care of this (since it
1388                                    requires stuffing characters into the output stream).
1389                                  */
1390         info->x_break = duration;
1391         if (!info->xmit_cnt) {
1392                 start_xmit(info);
1393         }
1394 }                               /* send_break */
1395
1396 static int
1397 get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
1398 {
1399
1400         if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
1401                 return -EFAULT;
1402         info->mon.int_count = 0;
1403         info->mon.char_count = 0;
1404         info->mon.char_max = 0;
1405         info->mon.char_last = 0;
1406         return 0;
1407 }
1408
1409 static int set_threshold(struct cyclades_port *info, unsigned long __user * arg)
1410 {
1411         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1412         unsigned long value;
1413         int channel;
1414
1415         if (get_user(value, arg))
1416                 return -EFAULT;
1417
1418         channel = info->line;
1419         info->cor4 &= ~CyREC_FIFO;
1420         info->cor4 |= value & CyREC_FIFO;
1421         base_addr[CyCOR4] = info->cor4;
1422         return 0;
1423 }
1424
1425 static int
1426 get_threshold(struct cyclades_port *info, unsigned long __user * value)
1427 {
1428         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1429         int channel;
1430         unsigned long tmp;
1431
1432         channel = info->line;
1433
1434         tmp = base_addr[CyCOR4] & CyREC_FIFO;
1435         return put_user(tmp, value);
1436 }
1437
1438 static int
1439 set_default_threshold(struct cyclades_port *info, unsigned long __user * arg)
1440 {
1441         unsigned long value;
1442
1443         if (get_user(value, arg))
1444                 return -EFAULT;
1445
1446         info->default_threshold = value & 0x0f;
1447         return 0;
1448 }
1449
1450 static int
1451 get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
1452 {
1453         return put_user(info->default_threshold, value);
1454 }
1455
1456 static int set_timeout(struct cyclades_port *info, unsigned long __user * arg)
1457 {
1458         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1459         int channel;
1460         unsigned long value;
1461
1462         if (get_user(value, arg))
1463                 return -EFAULT;
1464
1465         channel = info->line;
1466
1467         base_addr[CyRTPRL] = value & 0xff;
1468         base_addr[CyRTPRH] = (value >> 8) & 0xff;
1469         return 0;
1470 }
1471
1472 static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
1473 {
1474         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1475         int channel;
1476         unsigned long tmp;
1477
1478         channel = info->line;
1479
1480         tmp = base_addr[CyRTPRL];
1481         return put_user(tmp, value);
1482 }
1483
1484 static int set_default_timeout(struct cyclades_port *info, unsigned long value)
1485 {
1486         info->default_timeout = value & 0xff;
1487         return 0;
1488 }
1489
1490 static int
1491 get_default_timeout(struct cyclades_port *info, unsigned long __user * value)
1492 {
1493         return put_user(info->default_timeout, value);
1494 }
1495
1496 static int
1497 cy_ioctl(struct tty_struct *tty, struct file *file,
1498          unsigned int cmd, unsigned long arg)
1499 {
1500         struct cyclades_port *info = tty->driver_data;
1501         int ret_val = 0;
1502         void __user *argp = (void __user *)arg;
1503
1504 #ifdef SERIAL_DEBUG_OTHER
1505         printk("cy_ioctl %s, cmd = %x arg = %lx\n", tty->name, cmd, arg);       /* */
1506 #endif
1507
1508         tty_lock();
1509
1510         switch (cmd) {
1511         case CYGETMON:
1512                 ret_val = get_mon_info(info, argp);
1513                 break;
1514         case CYGETTHRESH:
1515                 ret_val = get_threshold(info, argp);
1516                 break;
1517         case CYSETTHRESH:
1518                 ret_val = set_threshold(info, argp);
1519                 break;
1520         case CYGETDEFTHRESH:
1521                 ret_val = get_default_threshold(info, argp);
1522                 break;
1523         case CYSETDEFTHRESH:
1524                 ret_val = set_default_threshold(info, argp);
1525                 break;
1526         case CYGETTIMEOUT:
1527                 ret_val = get_timeout(info, argp);
1528                 break;
1529         case CYSETTIMEOUT:
1530                 ret_val = set_timeout(info, argp);
1531                 break;
1532         case CYGETDEFTIMEOUT:
1533                 ret_val = get_default_timeout(info, argp);
1534                 break;
1535         case CYSETDEFTIMEOUT:
1536                 ret_val = set_default_timeout(info, (unsigned long)arg);
1537                 break;
1538         case TCSBRK:            /* SVID version: non-zero arg --> no break */
1539                 ret_val = tty_check_change(tty);
1540                 if (ret_val)
1541                         break;
1542                 tty_wait_until_sent(tty, 0);
1543                 if (!arg)
1544                         send_break(info, HZ / 4);       /* 1/4 second */
1545                 break;
1546         case TCSBRKP:           /* support for POSIX tcsendbreak() */
1547                 ret_val = tty_check_change(tty);
1548                 if (ret_val)
1549                         break;
1550                 tty_wait_until_sent(tty, 0);
1551                 send_break(info, arg ? arg * (HZ / 10) : HZ / 4);
1552                 break;
1553
1554 /* The following commands are incompletely implemented!!! */
1555         case TIOCGSERIAL:
1556                 ret_val = get_serial_info(info, argp);
1557                 break;
1558         case TIOCSSERIAL:
1559                 ret_val = set_serial_info(info, argp);
1560                 break;
1561         default:
1562                 ret_val = -ENOIOCTLCMD;
1563         }
1564         tty_unlock();
1565
1566 #ifdef SERIAL_DEBUG_OTHER
1567         printk("cy_ioctl done\n");
1568 #endif
1569
1570         return ret_val;
1571 }                               /* cy_ioctl */
1572
1573 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
1574 {
1575         struct cyclades_port *info = tty->driver_data;
1576
1577 #ifdef SERIAL_DEBUG_OTHER
1578         printk("cy_set_termios %s\n", tty->name);
1579 #endif
1580
1581         if (tty->termios->c_cflag == old_termios->c_cflag)
1582                 return;
1583         config_setup(info);
1584
1585         if ((old_termios->c_cflag & CRTSCTS) &&
1586             !(tty->termios->c_cflag & CRTSCTS)) {
1587                 tty->stopped = 0;
1588                 cy_start(tty);
1589         }
1590 #ifdef tytso_patch_94Nov25_1726
1591         if (!(old_termios->c_cflag & CLOCAL) &&
1592             (tty->termios->c_cflag & CLOCAL))
1593                 wake_up_interruptible(&info->open_wait);
1594 #endif
1595 }                               /* cy_set_termios */
1596
1597 static void cy_close(struct tty_struct *tty, struct file *filp)
1598 {
1599         struct cyclades_port *info = tty->driver_data;
1600
1601 /* CP('C'); */
1602 #ifdef SERIAL_DEBUG_OTHER
1603         printk("cy_close %s\n", tty->name);
1604 #endif
1605
1606         if (!info || serial_paranoia_check(info, tty->name, "cy_close")) {
1607                 return;
1608         }
1609 #ifdef SERIAL_DEBUG_OPEN
1610         printk("cy_close %s, count = %d\n", tty->name, info->count);
1611 #endif
1612
1613         if ((tty->count == 1) && (info->count != 1)) {
1614                 /*
1615                  * Uh, oh.  tty->count is 1, which means that the tty
1616                  * structure will be freed.  Info->count should always
1617                  * be one in these conditions.  If it's greater than
1618                  * one, we've got real problems, since it means the
1619                  * serial port won't be shutdown.
1620                  */
1621                 printk("cy_close: bad serial port count; tty->count is 1, "
1622                        "info->count is %d\n", info->count);
1623                 info->count = 1;
1624         }
1625 #ifdef SERIAL_DEBUG_COUNT
1626         printk("cyc: %d: decrementing count to %d\n", __LINE__,
1627                info->count - 1);
1628 #endif
1629         if (--info->count < 0) {
1630                 printk("cy_close: bad serial port count for ttys%d: %d\n",
1631                        info->line, info->count);
1632 #ifdef SERIAL_DEBUG_COUNT
1633                 printk("cyc: %d: setting count to 0\n", __LINE__);
1634 #endif
1635                 info->count = 0;
1636         }
1637         if (info->count)
1638                 return;
1639         info->flags |= ASYNC_CLOSING;
1640         if (info->flags & ASYNC_INITIALIZED)
1641                 tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
1642         shutdown(info);
1643         cy_flush_buffer(tty);
1644         tty_ldisc_flush(tty);
1645         info->tty = NULL;
1646         if (info->blocked_open) {
1647                 if (info->close_delay) {
1648                         msleep_interruptible(jiffies_to_msecs
1649                                              (info->close_delay));
1650                 }
1651                 wake_up_interruptible(&info->open_wait);
1652         }
1653         info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1654         wake_up_interruptible(&info->close_wait);
1655
1656 #ifdef SERIAL_DEBUG_OTHER
1657         printk("cy_close done\n");
1658 #endif
1659 }                               /* cy_close */
1660
1661 /*
1662  * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
1663  */
1664 void cy_hangup(struct tty_struct *tty)
1665 {
1666         struct cyclades_port *info = tty->driver_data;
1667
1668 #ifdef SERIAL_DEBUG_OTHER
1669         printk("cy_hangup %s\n", tty->name);    /* */
1670 #endif
1671
1672         if (serial_paranoia_check(info, tty->name, "cy_hangup"))
1673                 return;
1674
1675         shutdown(info);
1676 #if 0
1677         info->event = 0;
1678         info->count = 0;
1679 #ifdef SERIAL_DEBUG_COUNT
1680         printk("cyc: %d: setting count to 0\n", __LINE__);
1681 #endif
1682         info->tty = 0;
1683 #endif
1684         info->flags &= ~ASYNC_NORMAL_ACTIVE;
1685         wake_up_interruptible(&info->open_wait);
1686 }                               /* cy_hangup */
1687
1688 /*
1689  * ------------------------------------------------------------
1690  * cy_open() and friends
1691  * ------------------------------------------------------------
1692  */
1693
1694 static int
1695 block_til_ready(struct tty_struct *tty, struct file *filp,
1696                 struct cyclades_port *info)
1697 {
1698         DECLARE_WAITQUEUE(wait, current);
1699         unsigned long flags;
1700         int channel;
1701         int retval;
1702         volatile u_char *base_addr = (u_char *) BASE_ADDR;
1703
1704         /*
1705          * If the device is in the middle of being closed, then block
1706          * until it's done, and then try again.
1707          */
1708         if (info->flags & ASYNC_CLOSING) {
1709                 interruptible_sleep_on(&info->close_wait);
1710                 if (info->flags & ASYNC_HUP_NOTIFY) {
1711                         return -EAGAIN;
1712                 } else {
1713                         return -ERESTARTSYS;
1714                 }
1715         }
1716
1717         /*
1718          * If non-blocking mode is set, then make the check up front
1719          * and then exit.
1720          */
1721         if (filp->f_flags & O_NONBLOCK) {
1722                 info->flags |= ASYNC_NORMAL_ACTIVE;
1723                 return 0;
1724         }
1725
1726         /*
1727          * Block waiting for the carrier detect and the line to become
1728          * free (i.e., not in use by the callout).  While we are in
1729          * this loop, info->count is dropped by one, so that
1730          * cy_close() knows when to free things.  We restore it upon
1731          * exit, either normal or abnormal.
1732          */
1733         retval = 0;
1734         add_wait_queue(&info->open_wait, &wait);
1735 #ifdef SERIAL_DEBUG_OPEN
1736         printk("block_til_ready before block: %s, count = %d\n",
1737                tty->name, info->count);
1738         /**/
1739 #endif
1740             info->count--;
1741 #ifdef SERIAL_DEBUG_COUNT
1742         printk("cyc: %d: decrementing count to %d\n", __LINE__, info->count);
1743 #endif
1744         info->blocked_open++;
1745
1746         channel = info->line;
1747
1748         while (1) {
1749                 local_irq_save(flags);
1750                 base_addr[CyCAR] = (u_char) channel;
1751                 base_addr[CyMSVR1] = CyRTS;
1752 /* CP('S');CP('4'); */
1753                 base_addr[CyMSVR2] = CyDTR;
1754 #ifdef SERIAL_DEBUG_DTR
1755                 printk("cyc: %d: raising DTR\n", __LINE__);
1756                 printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1757                        base_addr[CyMSVR2]);
1758 #endif
1759                 local_irq_restore(flags);
1760                 set_current_state(TASK_INTERRUPTIBLE);
1761                 if (tty_hung_up_p(filp)
1762                     || !(info->flags & ASYNC_INITIALIZED)) {
1763                         if (info->flags & ASYNC_HUP_NOTIFY) {
1764                                 retval = -EAGAIN;
1765                         } else {
1766                                 retval = -ERESTARTSYS;
1767                         }
1768                         break;
1769                 }
1770                 local_irq_save(flags);
1771                 base_addr[CyCAR] = (u_char) channel;
1772 /* CP('L');CP1(1 && C_CLOCAL(tty)); CP1(1 && (base_addr[CyMSVR1] & CyDCD) ); */
1773                 if (!(info->flags & ASYNC_CLOSING)
1774                     && (C_CLOCAL(tty)
1775                         || (base_addr[CyMSVR1] & CyDCD))) {
1776                         local_irq_restore(flags);
1777                         break;
1778                 }
1779                 local_irq_restore(flags);
1780                 if (signal_pending(current)) {
1781                         retval = -ERESTARTSYS;
1782                         break;
1783                 }
1784 #ifdef SERIAL_DEBUG_OPEN
1785                 printk("block_til_ready blocking: %s, count = %d\n",
1786                        tty->name, info->count);
1787                 /**/
1788 #endif
1789                 tty_unlock();
1790                 schedule();
1791                 tty_lock();
1792         }
1793         __set_current_state(TASK_RUNNING);
1794         remove_wait_queue(&info->open_wait, &wait);
1795         if (!tty_hung_up_p(filp)) {
1796                 info->count++;
1797 #ifdef SERIAL_DEBUG_COUNT
1798                 printk("cyc: %d: incrementing count to %d\n", __LINE__,
1799                        info->count);
1800 #endif
1801         }
1802         info->blocked_open--;
1803 #ifdef SERIAL_DEBUG_OPEN
1804         printk("block_til_ready after blocking: %s, count = %d\n",
1805                tty->name, info->count);
1806         /**/
1807 #endif
1808             if (retval)
1809                 return retval;
1810         info->flags |= ASYNC_NORMAL_ACTIVE;
1811         return 0;
1812 }                               /* block_til_ready */
1813
1814 /*
1815  * This routine is called whenever a serial port is opened.  It
1816  * performs the serial-specific initialization for the tty structure.
1817  */
1818 int cy_open(struct tty_struct *tty, struct file *filp)
1819 {
1820         struct cyclades_port *info;
1821         int retval, line;
1822
1823 /* CP('O'); */
1824         line = tty->index;
1825         if ((line < 0) || (NR_PORTS <= line)) {
1826                 return -ENODEV;
1827         }
1828         info = &cy_port[line];
1829         if (info->line < 0) {
1830                 return -ENODEV;
1831         }
1832 #ifdef SERIAL_DEBUG_OTHER
1833         printk("cy_open %s\n", tty->name);      /* */
1834 #endif
1835         if (serial_paranoia_check(info, tty->name, "cy_open")) {
1836                 return -ENODEV;
1837         }
1838 #ifdef SERIAL_DEBUG_OPEN
1839         printk("cy_open %s, count = %d\n", tty->name, info->count);
1840         /**/
1841 #endif
1842             info->count++;
1843 #ifdef SERIAL_DEBUG_COUNT
1844         printk("cyc: %d: incrementing count to %d\n", __LINE__, info->count);
1845 #endif
1846         tty->driver_data = info;
1847         info->tty = tty;
1848
1849         /*
1850          * Start up serial port
1851          */
1852         retval = startup(info);
1853         if (retval) {
1854                 return retval;
1855         }
1856
1857         retval = block_til_ready(tty, filp, info);
1858         if (retval) {
1859 #ifdef SERIAL_DEBUG_OPEN
1860                 printk("cy_open returning after block_til_ready with %d\n",
1861                        retval);
1862 #endif
1863                 return retval;
1864         }
1865 #ifdef SERIAL_DEBUG_OPEN
1866         printk("cy_open done\n");
1867         /**/
1868 #endif
1869             return 0;
1870 }                               /* cy_open */
1871
1872 /*
1873  * ---------------------------------------------------------------------
1874  * serial167_init() and friends
1875  *
1876  * serial167_init() is called at boot-time to initialize the serial driver.
1877  * ---------------------------------------------------------------------
1878  */
1879
1880 /*
1881  * This routine prints out the appropriate serial driver version
1882  * number, and identifies which options were configured into this
1883  * driver.
1884  */
1885 static void show_version(void)
1886 {
1887         printk("MVME166/167 cd2401 driver\n");
1888 }                               /* show_version */
1889
1890 /* initialize chips on card -- return number of valid
1891    chips (which is number of ports/4) */
1892
1893 /*
1894  * This initialises the hardware to a reasonable state.  It should
1895  * probe the chip first so as to copy 166-Bug setup as a default for
1896  * port 0.  It initialises CMR to CyASYNC; that is never done again, so
1897  * as to limit the number of CyINIT_CHAN commands in normal running.
1898  *
1899  * ... I wonder what I should do if this fails ...
1900  */
1901
1902 void mvme167_serial_console_setup(int cflag)
1903 {
1904         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1905         int ch;
1906         u_char spd;
1907         u_char rcor, rbpr, badspeed = 0;
1908         unsigned long flags;
1909
1910         local_irq_save(flags);
1911
1912         /*
1913          * First probe channel zero of the chip, to see what speed has
1914          * been selected.
1915          */
1916
1917         base_addr[CyCAR] = 0;
1918
1919         rcor = base_addr[CyRCOR] << 5;
1920         rbpr = base_addr[CyRBPR];
1921
1922         for (spd = 0; spd < sizeof(baud_bpr); spd++)
1923                 if (rbpr == baud_bpr[spd] && rcor == baud_co[spd])
1924                         break;
1925         if (spd >= sizeof(baud_bpr)) {
1926                 spd = 14;       /* 19200 */
1927                 badspeed = 1;   /* Failed to identify speed */
1928         }
1929         initial_console_speed = spd;
1930
1931         /* OK, we have chosen a speed, now reset and reinitialise */
1932
1933         my_udelay(20000L);      /* Allow time for any active o/p to complete */
1934         if (base_addr[CyCCR] != 0x00) {
1935                 local_irq_restore(flags);
1936                 /* printk(" chip is never idle (CCR != 0)\n"); */
1937                 return;
1938         }
1939
1940         base_addr[CyCCR] = CyCHIP_RESET;        /* Reset the chip */
1941         my_udelay(1000L);
1942
1943         if (base_addr[CyGFRCR] == 0x00) {
1944                 local_irq_restore(flags);
1945                 /* printk(" chip is not responding (GFRCR stayed 0)\n"); */
1946                 return;
1947         }
1948
1949         /*
1950          * System clock is 20Mhz, divided by 2048, so divide by 10 for a 1.0ms
1951          * tick
1952          */
1953
1954         base_addr[CyTPR] = 10;
1955
1956         base_addr[CyPILR1] = 0x01;      /* Interrupt level for modem change */
1957         base_addr[CyPILR2] = 0x02;      /* Interrupt level for tx ints */
1958         base_addr[CyPILR3] = 0x03;      /* Interrupt level for rx ints */
1959
1960         /*
1961          * Attempt to set up all channels to something reasonable, and
1962          * bang out a INIT_CHAN command.  We should then be able to limit
1963          * the amount of fiddling we have to do in normal running.
1964          */
1965
1966         for (ch = 3; ch >= 0; ch--) {
1967                 base_addr[CyCAR] = (u_char) ch;
1968                 base_addr[CyIER] = 0;
1969                 base_addr[CyCMR] = CyASYNC;
1970                 base_addr[CyLICR] = (u_char) ch << 2;
1971                 base_addr[CyLIVR] = 0x5c;
1972                 base_addr[CyTCOR] = baud_co[spd];
1973                 base_addr[CyTBPR] = baud_bpr[spd];
1974                 base_addr[CyRCOR] = baud_co[spd] >> 5;
1975                 base_addr[CyRBPR] = baud_bpr[spd];
1976                 base_addr[CySCHR1] = 'Q' & 0x1f;
1977                 base_addr[CySCHR2] = 'X' & 0x1f;
1978                 base_addr[CySCRL] = 0;
1979                 base_addr[CySCRH] = 0;
1980                 base_addr[CyCOR1] = Cy_8_BITS | CyPARITY_NONE;
1981                 base_addr[CyCOR2] = 0;
1982                 base_addr[CyCOR3] = Cy_1_STOP;
1983                 base_addr[CyCOR4] = baud_cor4[spd];
1984                 base_addr[CyCOR5] = 0;
1985                 base_addr[CyCOR6] = 0;
1986                 base_addr[CyCOR7] = 0;
1987                 base_addr[CyRTPRL] = 2;
1988                 base_addr[CyRTPRH] = 0;
1989                 base_addr[CyMSVR1] = 0;
1990                 base_addr[CyMSVR2] = 0;
1991                 write_cy_cmd(base_addr, CyINIT_CHAN | CyDIS_RCVR | CyDIS_XMTR);
1992         }
1993
1994         /*
1995          * Now do specials for channel zero....
1996          */
1997
1998         base_addr[CyMSVR1] = CyRTS;
1999         base_addr[CyMSVR2] = CyDTR;
2000         base_addr[CyIER] = CyRxData;
2001         write_cy_cmd(base_addr, CyENB_RCVR | CyENB_XMTR);
2002
2003         local_irq_restore(flags);
2004
2005         my_udelay(20000L);      /* Let it all settle down */
2006
2007         printk("CD2401 initialised,  chip is rev 0x%02x\n", base_addr[CyGFRCR]);
2008         if (badspeed)
2009                 printk
2010                     ("  WARNING:  Failed to identify line speed, rcor=%02x,rbpr=%02x\n",
2011                      rcor >> 5, rbpr);
2012 }                               /* serial_console_init */
2013
2014 static const struct tty_operations cy_ops = {
2015         .open = cy_open,
2016         .close = cy_close,
2017         .write = cy_write,
2018         .put_char = cy_put_char,
2019         .flush_chars = cy_flush_chars,
2020         .write_room = cy_write_room,
2021         .chars_in_buffer = cy_chars_in_buffer,
2022         .flush_buffer = cy_flush_buffer,
2023         .ioctl = cy_ioctl,
2024         .throttle = cy_throttle,
2025         .unthrottle = cy_unthrottle,
2026         .set_termios = cy_set_termios,
2027         .stop = cy_stop,
2028         .start = cy_start,
2029         .hangup = cy_hangup,
2030         .tiocmget = cy_tiocmget,
2031         .tiocmset = cy_tiocmset,
2032 };
2033
2034 /* The serial driver boot-time initialization code!
2035     Hardware I/O ports are mapped to character special devices on a
2036     first found, first allocated manner.  That is, this code searches
2037     for Cyclom cards in the system.  As each is found, it is probed
2038     to discover how many chips (and thus how many ports) are present.
2039     These ports are mapped to the tty ports 64 and upward in monotonic
2040     fashion.  If an 8-port card is replaced with a 16-port card, the
2041     port mapping on a following card will shift.
2042
2043     This approach is different from what is used in the other serial
2044     device driver because the Cyclom is more properly a multiplexer,
2045     not just an aggregation of serial ports on one card.
2046
2047     If there are more cards with more ports than have been statically
2048     allocated above, a warning is printed and the extra ports are ignored.
2049  */
2050 static int __init serial167_init(void)
2051 {
2052         struct cyclades_port *info;
2053         int ret = 0;
2054         int good_ports = 0;
2055         int port_num = 0;
2056         int index;
2057         int DefSpeed;
2058 #ifdef notyet
2059         struct sigaction sa;
2060 #endif
2061
2062         if (!(mvme16x_config & MVME16x_CONFIG_GOT_CD2401))
2063                 return 0;
2064
2065         cy_serial_driver = alloc_tty_driver(NR_PORTS);
2066         if (!cy_serial_driver)
2067                 return -ENOMEM;
2068
2069 #if 0
2070         scrn[1] = '\0';
2071 #endif
2072
2073         show_version();
2074
2075         /* Has "console=0,9600n8" been used in bootinfo to change speed? */
2076         if (serial_console_cflag)
2077                 DefSpeed = serial_console_cflag & 0017;
2078         else {
2079                 DefSpeed = initial_console_speed;
2080                 serial_console_info = &cy_port[0];
2081                 serial_console_cflag = DefSpeed | CS8;
2082 #if 0
2083                 serial_console = 64;    /*callout_driver.minor_start */
2084 #endif
2085         }
2086
2087         /* Initialize the tty_driver structure */
2088
2089         cy_serial_driver->owner = THIS_MODULE;
2090         cy_serial_driver->name = "ttyS";
2091         cy_serial_driver->major = TTY_MAJOR;
2092         cy_serial_driver->minor_start = 64;
2093         cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
2094         cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
2095         cy_serial_driver->init_termios = tty_std_termios;
2096         cy_serial_driver->init_termios.c_cflag =
2097             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2098         cy_serial_driver->flags = TTY_DRIVER_REAL_RAW;
2099         tty_set_operations(cy_serial_driver, &cy_ops);
2100
2101         ret = tty_register_driver(cy_serial_driver);
2102         if (ret) {
2103                 printk(KERN_ERR "Couldn't register MVME166/7 serial driver\n");
2104                 put_tty_driver(cy_serial_driver);
2105                 return ret;
2106         }
2107
2108         port_num = 0;
2109         info = cy_port;
2110         for (index = 0; index < 1; index++) {
2111
2112                 good_ports = 4;
2113
2114                 if (port_num < NR_PORTS) {
2115                         while (good_ports-- && port_num < NR_PORTS) {
2116                 /*** initialize port ***/
2117                                 info->magic = CYCLADES_MAGIC;
2118                                 info->type = PORT_CIRRUS;
2119                                 info->card = index;
2120                                 info->line = port_num;
2121                                 info->flags = STD_COM_FLAGS;
2122                                 info->tty = NULL;
2123                                 info->xmit_fifo_size = 12;
2124                                 info->cor1 = CyPARITY_NONE | Cy_8_BITS;
2125                                 info->cor2 = CyETC;
2126                                 info->cor3 = Cy_1_STOP;
2127                                 info->cor4 = 0x08;      /* _very_ small receive threshold */
2128                                 info->cor5 = 0;
2129                                 info->cor6 = 0;
2130                                 info->cor7 = 0;
2131                                 info->tbpr = baud_bpr[DefSpeed];        /* Tx BPR */
2132                                 info->tco = baud_co[DefSpeed];  /* Tx CO */
2133                                 info->rbpr = baud_bpr[DefSpeed];        /* Rx BPR */
2134                                 info->rco = baud_co[DefSpeed] >> 5;     /* Rx CO */
2135                                 info->close_delay = 0;
2136                                 info->x_char = 0;
2137                                 info->count = 0;
2138 #ifdef SERIAL_DEBUG_COUNT
2139                                 printk("cyc: %d: setting count to 0\n",
2140                                        __LINE__);
2141 #endif
2142                                 info->blocked_open = 0;
2143                                 info->default_threshold = 0;
2144                                 info->default_timeout = 0;
2145                                 init_waitqueue_head(&info->open_wait);
2146                                 init_waitqueue_head(&info->close_wait);
2147                                 /* info->session */
2148                                 /* info->pgrp */
2149 /*** !!!!!!!! this may expose new bugs !!!!!!!!! *********/
2150                                 info->read_status_mask =
2151                                     CyTIMEOUT | CySPECHAR | CyBREAK | CyPARITY |
2152                                     CyFRAME | CyOVERRUN;
2153                                 /* info->timeout */
2154
2155                                 printk("ttyS%d ", info->line);
2156                                 port_num++;
2157                                 info++;
2158                                 if (!(port_num & 7)) {
2159                                         printk("\n               ");
2160                                 }
2161                         }
2162                 }
2163                 printk("\n");
2164         }
2165         while (port_num < NR_PORTS) {
2166                 info->line = -1;
2167                 port_num++;
2168                 info++;
2169         }
2170
2171         ret = request_irq(MVME167_IRQ_SER_ERR, cd2401_rxerr_interrupt, 0,
2172                           "cd2401_errors", cd2401_rxerr_interrupt);
2173         if (ret) {
2174                 printk(KERN_ERR "Could't get cd2401_errors IRQ");
2175                 goto cleanup_serial_driver;
2176         }
2177
2178         ret = request_irq(MVME167_IRQ_SER_MODEM, cd2401_modem_interrupt, 0,
2179                           "cd2401_modem", cd2401_modem_interrupt);
2180         if (ret) {
2181                 printk(KERN_ERR "Could't get cd2401_modem IRQ");
2182                 goto cleanup_irq_cd2401_errors;
2183         }
2184
2185         ret = request_irq(MVME167_IRQ_SER_TX, cd2401_tx_interrupt, 0,
2186                           "cd2401_txints", cd2401_tx_interrupt);
2187         if (ret) {
2188                 printk(KERN_ERR "Could't get cd2401_txints IRQ");
2189                 goto cleanup_irq_cd2401_modem;
2190         }
2191
2192         ret = request_irq(MVME167_IRQ_SER_RX, cd2401_rx_interrupt, 0,
2193                           "cd2401_rxints", cd2401_rx_interrupt);
2194         if (ret) {
2195                 printk(KERN_ERR "Could't get cd2401_rxints IRQ");
2196                 goto cleanup_irq_cd2401_txints;
2197         }
2198
2199         /* Now we have registered the interrupt handlers, allow the interrupts */
2200
2201         pcc2chip[PccSCCMICR] = 0x15;    /* Serial ints are level 5 */
2202         pcc2chip[PccSCCTICR] = 0x15;
2203         pcc2chip[PccSCCRICR] = 0x15;
2204
2205         pcc2chip[PccIMLR] = 3;  /* Allow PCC2 ints above 3!? */
2206
2207         return 0;
2208 cleanup_irq_cd2401_txints:
2209         free_irq(MVME167_IRQ_SER_TX, cd2401_tx_interrupt);
2210 cleanup_irq_cd2401_modem:
2211         free_irq(MVME167_IRQ_SER_MODEM, cd2401_modem_interrupt);
2212 cleanup_irq_cd2401_errors:
2213         free_irq(MVME167_IRQ_SER_ERR, cd2401_rxerr_interrupt);
2214 cleanup_serial_driver:
2215         if (tty_unregister_driver(cy_serial_driver))
2216                 printk(KERN_ERR
2217                        "Couldn't unregister MVME166/7 serial driver\n");
2218         put_tty_driver(cy_serial_driver);
2219         return ret;
2220 }                               /* serial167_init */
2221
2222 module_init(serial167_init);
2223
2224 #ifdef CYCLOM_SHOW_STATUS
2225 static void show_status(int line_num)
2226 {
2227         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2228         int channel;
2229         struct cyclades_port *info;
2230         unsigned long flags;
2231
2232         info = &cy_port[line_num];
2233         channel = info->line;
2234         printk("  channel %d\n", channel);
2235         /**/ printk(" cy_port\n");
2236         printk("  card line flags = %d %d %x\n",
2237                info->card, info->line, info->flags);
2238         printk
2239             ("  *tty read_status_mask timeout xmit_fifo_size = %lx %x %x %x\n",
2240              (long)info->tty, info->read_status_mask, info->timeout,
2241              info->xmit_fifo_size);
2242         printk("  cor1,cor2,cor3,cor4,cor5,cor6,cor7 = %x %x %x %x %x %x %x\n",
2243                info->cor1, info->cor2, info->cor3, info->cor4, info->cor5,
2244                info->cor6, info->cor7);
2245         printk("  tbpr,tco,rbpr,rco = %d %d %d %d\n", info->tbpr, info->tco,
2246                info->rbpr, info->rco);
2247         printk("  close_delay event count = %d %d %d\n", info->close_delay,
2248                info->event, info->count);
2249         printk("  x_char blocked_open = %x %x\n", info->x_char,
2250                info->blocked_open);
2251         printk("  open_wait = %lx %lx %lx\n", (long)info->open_wait);
2252
2253         local_irq_save(flags);
2254
2255 /* Global Registers */
2256
2257         printk(" CyGFRCR %x\n", base_addr[CyGFRCR]);
2258         printk(" CyCAR %x\n", base_addr[CyCAR]);
2259         printk(" CyRISR %x\n", base_addr[CyRISR]);
2260         printk(" CyTISR %x\n", base_addr[CyTISR]);
2261         printk(" CyMISR %x\n", base_addr[CyMISR]);
2262         printk(" CyRIR %x\n", base_addr[CyRIR]);
2263         printk(" CyTIR %x\n", base_addr[CyTIR]);
2264         printk(" CyMIR %x\n", base_addr[CyMIR]);
2265         printk(" CyTPR %x\n", base_addr[CyTPR]);
2266
2267         base_addr[CyCAR] = (u_char) channel;
2268
2269 /* Virtual Registers */
2270
2271 #if 0
2272         printk(" CyRIVR %x\n", base_addr[CyRIVR]);
2273         printk(" CyTIVR %x\n", base_addr[CyTIVR]);
2274         printk(" CyMIVR %x\n", base_addr[CyMIVR]);
2275         printk(" CyMISR %x\n", base_addr[CyMISR]);
2276 #endif
2277
2278 /* Channel Registers */
2279
2280         printk(" CyCCR %x\n", base_addr[CyCCR]);
2281         printk(" CyIER %x\n", base_addr[CyIER]);
2282         printk(" CyCOR1 %x\n", base_addr[CyCOR1]);
2283         printk(" CyCOR2 %x\n", base_addr[CyCOR2]);
2284         printk(" CyCOR3 %x\n", base_addr[CyCOR3]);
2285         printk(" CyCOR4 %x\n", base_addr[CyCOR4]);
2286         printk(" CyCOR5 %x\n", base_addr[CyCOR5]);
2287 #if 0
2288         printk(" CyCCSR %x\n", base_addr[CyCCSR]);
2289         printk(" CyRDCR %x\n", base_addr[CyRDCR]);
2290 #endif
2291         printk(" CySCHR1 %x\n", base_addr[CySCHR1]);
2292         printk(" CySCHR2 %x\n", base_addr[CySCHR2]);
2293 #if 0
2294         printk(" CySCHR3 %x\n", base_addr[CySCHR3]);
2295         printk(" CySCHR4 %x\n", base_addr[CySCHR4]);
2296         printk(" CySCRL %x\n", base_addr[CySCRL]);
2297         printk(" CySCRH %x\n", base_addr[CySCRH]);
2298         printk(" CyLNC %x\n", base_addr[CyLNC]);
2299         printk(" CyMCOR1 %x\n", base_addr[CyMCOR1]);
2300         printk(" CyMCOR2 %x\n", base_addr[CyMCOR2]);
2301 #endif
2302         printk(" CyRTPRL %x\n", base_addr[CyRTPRL]);
2303         printk(" CyRTPRH %x\n", base_addr[CyRTPRH]);
2304         printk(" CyMSVR1 %x\n", base_addr[CyMSVR1]);
2305         printk(" CyMSVR2 %x\n", base_addr[CyMSVR2]);
2306         printk(" CyRBPR %x\n", base_addr[CyRBPR]);
2307         printk(" CyRCOR %x\n", base_addr[CyRCOR]);
2308         printk(" CyTBPR %x\n", base_addr[CyTBPR]);
2309         printk(" CyTCOR %x\n", base_addr[CyTCOR]);
2310
2311         local_irq_restore(flags);
2312 }                               /* show_status */
2313 #endif
2314
2315 #if 0
2316 /* Dummy routine in mvme16x/config.c for now */
2317
2318 /* Serial console setup. Called from linux/init/main.c */
2319
2320 void console_setup(char *str, int *ints)
2321 {
2322         char *s;
2323         int baud, bits, parity;
2324         int cflag = 0;
2325
2326         /* Sanity check. */
2327         if (ints[0] > 3 || ints[1] > 3)
2328                 return;
2329
2330         /* Get baud, bits and parity */
2331         baud = 2400;
2332         bits = 8;
2333         parity = 'n';
2334         if (ints[2])
2335                 baud = ints[2];
2336         if ((s = strchr(str, ','))) {
2337                 do {
2338                         s++;
2339                 } while (*s >= '0' && *s <= '9');
2340                 if (*s)
2341                         parity = *s++;
2342                 if (*s)
2343                         bits = *s - '0';
2344         }
2345
2346         /* Now construct a cflag setting. */
2347         switch (baud) {
2348         case 1200:
2349                 cflag |= B1200;
2350                 break;
2351         case 9600:
2352                 cflag |= B9600;
2353                 break;
2354         case 19200:
2355                 cflag |= B19200;
2356                 break;
2357         case 38400:
2358                 cflag |= B38400;
2359                 break;
2360         case 2400:
2361         default:
2362                 cflag |= B2400;
2363                 break;
2364         }
2365         switch (bits) {
2366         case 7:
2367                 cflag |= CS7;
2368                 break;
2369         default:
2370         case 8:
2371                 cflag |= CS8;
2372                 break;
2373         }
2374         switch (parity) {
2375         case 'o':
2376         case 'O':
2377                 cflag |= PARODD;
2378                 break;
2379         case 'e':
2380         case 'E':
2381                 cflag |= PARENB;
2382                 break;
2383         }
2384
2385         serial_console_info = &cy_port[ints[1]];
2386         serial_console_cflag = cflag;
2387         serial_console = ints[1] + 64;  /*callout_driver.minor_start */
2388 }
2389 #endif
2390
2391 /*
2392  * The following is probably out of date for 2.1.x serial console stuff.
2393  *
2394  * The console is registered early on from arch/m68k/kernel/setup.c, and
2395  * it therefore relies on the chip being setup correctly by 166-Bug.  This
2396  * seems reasonable, as the serial port has been used to invoke the system
2397  * boot.  It also means that this function must not rely on any data
2398  * initialisation performed by serial167_init() etc.
2399  *
2400  * Of course, once the console has been registered, we had better ensure
2401  * that serial167_init() doesn't leave the chip non-functional.
2402  *
2403  * The console must be locked when we get here.
2404  */
2405
2406 void serial167_console_write(struct console *co, const char *str,
2407                              unsigned count)
2408 {
2409         volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2410         unsigned long flags;
2411         volatile u_char sink;
2412         u_char ier;
2413         int port;
2414         u_char do_lf = 0;
2415         int i = 0;
2416
2417         local_irq_save(flags);
2418
2419         /* Ensure transmitter is enabled! */
2420
2421         port = 0;
2422         base_addr[CyCAR] = (u_char) port;
2423         while (base_addr[CyCCR])
2424                 ;
2425         base_addr[CyCCR] = CyENB_XMTR;
2426
2427         ier = base_addr[CyIER];
2428         base_addr[CyIER] = CyTxMpty;
2429
2430         while (1) {
2431                 if (pcc2chip[PccSCCTICR] & 0x20) {
2432                         /* We have a Tx int. Acknowledge it */
2433                         sink = pcc2chip[PccTPIACKR];
2434                         if ((base_addr[CyLICR] >> 2) == port) {
2435                                 if (i == count) {
2436                                         /* Last char of string is now output */
2437                                         base_addr[CyTEOIR] = CyNOTRANS;
2438                                         break;
2439                                 }
2440                                 if (do_lf) {
2441                                         base_addr[CyTDR] = '\n';
2442                                         str++;
2443                                         i++;
2444                                         do_lf = 0;
2445                                 } else if (*str == '\n') {
2446                                         base_addr[CyTDR] = '\r';
2447                                         do_lf = 1;
2448                                 } else {
2449                                         base_addr[CyTDR] = *str++;
2450                                         i++;
2451                                 }
2452                                 base_addr[CyTEOIR] = 0;
2453                         } else
2454                                 base_addr[CyTEOIR] = CyNOTRANS;
2455                 }
2456         }
2457
2458         base_addr[CyIER] = ier;
2459
2460         local_irq_restore(flags);
2461 }
2462
2463 static struct tty_driver *serial167_console_device(struct console *c,
2464                                                    int *index)
2465 {
2466         *index = c->index;
2467         return cy_serial_driver;
2468 }
2469
2470 static struct console sercons = {
2471         .name = "ttyS",
2472         .write = serial167_console_write,
2473         .device = serial167_console_device,
2474         .flags = CON_PRINTBUFFER,
2475         .index = -1,
2476 };
2477
2478 static int __init serial167_console_init(void)
2479 {
2480         if (vme_brdtype == VME_TYPE_MVME166 ||
2481             vme_brdtype == VME_TYPE_MVME167 ||
2482             vme_brdtype == VME_TYPE_MVME177) {
2483                 mvme167_serial_console_setup(0);
2484                 register_console(&sercons);
2485         }
2486         return 0;
2487 }
2488
2489 console_initcall(serial167_console_init);
2490
2491 MODULE_LICENSE("GPL");