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