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