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