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