drivers/char/serial167.c

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