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