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