452370af95def5a352dd4753107ce3fd4154fb93
[linux-2.6.git] / drivers / char / serial167.c
1 /*
2  * linux/drivers/char/serial167.c
3  *
4  * Driver for MVME166/7 board serial ports, which are via a CD2401.
5  * Based very much on cyclades.c.
6  *
7  * MVME166/7 work by Richard Hirst [richard@sleepie.demon.co.uk]
8  *
9  * ==============================================================
10  *
11  * static char rcsid[] =
12  * "$Revision: 1.36.1.4 $$Date: 1995/03/29 06:14:14 $";
13  *
14  *  linux/kernel/cyclades.c
15  *
16  * Maintained by Marcio Saito (cyclades@netcom.com) and
17  * Randolph Bentson (bentson@grieg.seaslug.org)
18  *
19  * Much of the design and some of the code came from serial.c
20  * which was copyright (C) 1991, 1992  Linus Torvalds.  It was
21  * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
22  * and then fixed as suggested by Michael K. Johnson 12/12/92.
23  *
24  * This version does not support shared irq's.
25  *
26  * $Log: cyclades.c,v $
27  * Revision 1.36.1.4  1995/03/29  06:14:14  bentson
28  * disambiguate between Cyclom-16Y and Cyclom-32Ye;
29  *
30  * Changes:
31  *
32  * 200 lines of changes record removed - RGH 11-10-95, starting work on
33  * converting this to drive serial ports on mvme166 (cd2401).
34  *
35  * Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 2000/08/25
36  * - get rid of verify_area
37  * - use get_user to access memory from userspace in set_threshold,
38  *   set_default_threshold and set_timeout
39  * - don't use the panic function in serial167_init
40  * - do resource release on failure on serial167_init
41  * - include missing restore_flags in mvme167_serial_console_setup
42  *
43  * Kars de Jong <jongk@linux-m68k.org> - 2004/09/06
44  * - replace bottom half handler with task queue handler
45  */
46
47 #include <linux/errno.h>
48 #include <linux/signal.h>
49 #include <linux/sched.h>
50 #include <linux/timer.h>
51 #include <linux/tty.h>
52 #include <linux/interrupt.h>
53 #include <linux/serial.h>
54 #include <linux/serialP.h>
55 #include <linux/smp_lock.h>
56 #include <linux/string.h>
57 #include <linux/fcntl.h>
58 #include <linux/ptrace.h>
59 #include <linux/serial167.h>
60 #include <linux/delay.h>
61 #include <linux/major.h>
62 #include <linux/mm.h>
63 #include <linux/console.h>
64 #include <linux/module.h>
65 #include <linux/bitops.h>
66 #include <linux/tty_flip.h>
67
68 #include <asm/system.h>
69 #include <asm/io.h>
70 #include <asm/mvme16xhw.h>
71 #include <asm/bootinfo.h>
72 #include <asm/setup.h>
73
74 #include <linux/types.h>
75 #include <linux/kernel.h>
76
77 #include <asm/uaccess.h>
78 #include <linux/init.h>
79
80 #define SERIAL_PARANOIA_CHECK
81 #undef  SERIAL_DEBUG_OPEN
82 #undef  SERIAL_DEBUG_THROTTLE
83 #undef  SERIAL_DEBUG_OTHER
84 #undef  SERIAL_DEBUG_IO
85 #undef  SERIAL_DEBUG_COUNT
86 #undef  SERIAL_DEBUG_DTR
87 #undef  CYCLOM_16Y_HACK
88 #define  CYCLOM_ENABLE_MONITORING
89
90 #define WAKEUP_CHARS 256
91
92 #define STD_COM_FLAGS (0)
93
94 static struct tty_driver *cy_serial_driver;
95 extern int serial_console;
96 static struct cyclades_port *serial_console_info = NULL;
97 static unsigned int serial_console_cflag = 0;
98 u_char initial_console_speed;
99
100 /* Base address of cd2401 chip on mvme166/7 */
101
102 #define BASE_ADDR (0xfff45000)
103 #define pcc2chip        ((volatile u_char *)0xfff42000)
104 #define PccSCCMICR      0x1d
105 #define PccSCCTICR      0x1e
106 #define PccSCCRICR      0x1f
107 #define PccTPIACKR      0x25
108 #define PccRPIACKR      0x27
109 #define PccIMLR         0x3f
110
111 /* This is the per-port data structure */
112 struct cyclades_port cy_port[] = {
113         /* CARD#  */
114         {-1},                   /* ttyS0 */
115         {-1},                   /* ttyS1 */
116         {-1},                   /* ttyS2 */
117         {-1},                   /* ttyS3 */
118 };
119
120 #define NR_PORTS        ARRAY_SIZE(cy_port)
121
122 /*
123  * This is used to look up the divisor speeds and the timeouts
124  * We're normally limited to 15 distinct baud rates.  The extra
125  * are accessed via settings in info->flags.
126  *         0,     1,     2,     3,     4,     5,     6,     7,     8,     9,
127  *        10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
128  *                                                  HI            VHI
129  */
130 static int baud_table[] = {
131         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
132         1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
133         0
134 };
135
136 #if 0
137 static char baud_co[] = {       /* 25 MHz clock option table */
138         /* value =>    00    01   02    03    04 */
139         /* divide by    8    32   128   512  2048 */
140         0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
141         0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
142 };
143
144 static char baud_bpr[] = {      /* 25 MHz baud rate period table */
145         0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
146         0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
147 };
148 #endif
149
150 /* I think 166 brd clocks 2401 at 20MHz.... */
151
152 /* These values are written directly to tcor, and >> 5 for writing to rcor */
153 static u_char baud_co[] = {     /* 20 MHz clock option table */
154         0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x60, 0x60, 0x40,
155         0x40, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
156 };
157
158 /* These values written directly to tbpr/rbpr */
159 static u_char baud_bpr[] = {    /* 20 MHz baud rate period table */
160         0x00, 0xc0, 0x80, 0x58, 0x6c, 0x40, 0xc0, 0x81, 0x40, 0x81,
161         0x57, 0x40, 0x81, 0x40, 0x81, 0x40, 0x2b, 0x20, 0x15, 0x10
162 };
163
164 static u_char baud_cor4[] = {   /* receive threshold */
165         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
166         0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07
167 };
168
169 static void shutdown(struct cyclades_port *);
170 static int startup(struct cyclades_port *);
171 static void cy_throttle(struct tty_struct *);
172 static void cy_unthrottle(struct tty_struct *);
173 static void config_setup(struct cyclades_port *);
174 #ifdef CYCLOM_SHOW_STATUS
175 static void show_status(int);
176 #endif
177
178 #ifdef CONFIG_REMOTE_DEBUG
179 static void debug_setup(void);
180 void queueDebugChar(int c);
181 int getDebugChar(void);
182
183 #define DEBUG_PORT      1
184 #define DEBUG_LEN       256
185
186 typedef struct {
187         int in;
188         int out;
189         unsigned char buf[DEBUG_LEN];
190 } debugq;
191
192 debugq debugiq;
193 #endif
194
195 /*
196  * I have my own version of udelay(), as it is needed when initialising
197  * the chip, before the delay loop has been calibrated.  Should probably
198  * reference one of the vmechip2 or pccchip2 counter for an accurate
199  * delay, but this wild guess will do for now.
200  */
201
202 void my_udelay(long us)
203 {
204         u_char x;
205         volatile u_char *p = &x;
206         int i;
207
208         while (us--)
209                 for (i = 100; i; i--)
210                         x |= *p;
211 }
212
213 static inline int serial_paranoia_check(struct cyclades_port *info, char *name,
214                 const char *routine)
215 {
216 #ifdef SERIAL_PARANOIA_CHECK
217         if (!info) {
218                 printk("Warning: null cyclades_port for (%s) in %s\n", name,
219                                 routine);
220                 return 1;
221         }
222
223         if (info < &cy_port[0] || info >= &cy_port[NR_PORTS]) {
224                 printk("Warning: cyclades_port out of range for (%s) in %s\n",
225                                 name, routine);
226                 return 1;
227         }
228
229         if (info->magic != CYCLADES_MAGIC) {
230                 printk("Warning: bad magic number for serial struct (%s) in "
231                                 "%s\n", name, routine);
232                 return 1;
233         }
234 #endif
235         return 0;
236 }                               /* serial_paranoia_check */
237
238 #if 0
239 /* The following diagnostic routines allow the driver to spew
240    information on the screen, even (especially!) during interrupts.
241  */
242 void SP(char *data)
243 {
244         unsigned long flags;
245         local_irq_save(flags);
246         printk(KERN_EMERG "%s", data);
247         local_irq_restore(flags);
248 }
249
250 char scrn[2];
251 void CP(char data)
252 {
253         unsigned long flags;
254         local_irq_save(flags);
255         scrn[0] = data;
256         printk(KERN_EMERG "%c", scrn);
257         local_irq_restore(flags);
258 }                               /* CP */
259
260 void CP1(int data)
261 {
262         (data < 10) ? CP(data + '0') : CP(data + 'A' - 10);
263 }                               /* CP1 */
264 void CP2(int data)
265 {
266         CP1((data >> 4) & 0x0f);
267         CP1(data & 0x0f);
268 }                               /* CP2 */
269 void CP4(int data)
270 {
271         CP2((data >> 8) & 0xff);
272         CP2(data & 0xff);
273 }                               /* CP4 */
274 void CP8(long data)
275 {
276         CP4((data >> 16) & 0xffff);
277         CP4(data & 0xffff);
278 }                               /* CP8 */
279 #endif
280
281 /* This routine waits up to 1000 micro-seconds for the previous
282    command to the Cirrus chip to complete and then issues the
283    new command.  An error is returned if the previous command
284    didn't finish within the time limit.
285  */
286 u_short write_cy_cmd(volatile u_char * base_addr, u_char cmd)
287 {
288         unsigned long flags;
289         volatile int i;
290
291         local_irq_save(flags);
292         /* Check to see that the previous command has completed */
293         for (i = 0; i < 100; i++) {
294                 if (base_addr[CyCCR] == 0) {
295                         break;
296                 }
297                 my_udelay(10L);
298         }
299         /* if the CCR never cleared, the previous command
300            didn't finish within the "reasonable time" */
301         if (i == 10) {
302                 local_irq_restore(flags);
303                 return (-1);
304         }
305
306         /* Issue the new command */
307         base_addr[CyCCR] = cmd;
308         local_irq_restore(flags);
309         return (0);
310 }                               /* write_cy_cmd */
311
312 /* cy_start and cy_stop provide software output flow control as a
313    function of XON/XOFF, software CTS, and other such stuff. */
314
315 static void cy_stop(struct tty_struct *tty)
316 {
317         struct cyclades_port *info = tty->driver_data;
318         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
319         int channel;
320         unsigned long flags;
321
322 #ifdef SERIAL_DEBUG_OTHER
323         printk("cy_stop %s\n", tty->name);      /* */
324 #endif
325
326         if (serial_paranoia_check(info, tty->name, "cy_stop"))
327                 return;
328
329         channel = info->line;
330
331         local_irq_save(flags);
332         base_addr[CyCAR] = (u_char) (channel);  /* index channel */
333         base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
334         local_irq_restore(flags);
335 }                               /* cy_stop */
336
337 static void cy_start(struct tty_struct *tty)
338 {
339         struct cyclades_port *info = tty->driver_data;
340         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
341         int channel;
342         unsigned long flags;
343
344 #ifdef SERIAL_DEBUG_OTHER
345         printk("cy_start %s\n", tty->name);     /* */
346 #endif
347
348         if (serial_paranoia_check(info, tty->name, "cy_start"))
349                 return;
350
351         channel = info->line;
352
353         local_irq_save(flags);
354         base_addr[CyCAR] = (u_char) (channel);
355         base_addr[CyIER] |= CyTxMpty;
356         local_irq_restore(flags);
357 }                               /* cy_start */
358
359 /* The real interrupt service routines are called
360    whenever the card wants its hand held--chars
361    received, out buffer empty, modem change, etc.
362  */
363 static irqreturn_t cd2401_rxerr_interrupt(int irq, void *dev_id)
364 {
365         struct tty_struct *tty;
366         struct cyclades_port *info;
367         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
368         unsigned char err, rfoc;
369         int channel;
370         char data;
371
372         /* determine the channel and change to that context */
373         channel = (u_short) (base_addr[CyLICR] >> 2);
374         info = &cy_port[channel];
375         info->last_active = jiffies;
376
377         if ((err = base_addr[CyRISR]) & CyTIMEOUT) {
378                 /* This is a receive timeout interrupt, ignore it */
379                 base_addr[CyREOIR] = CyNOTRANS;
380                 return IRQ_HANDLED;
381         }
382
383         /* Read a byte of data if there is any - assume the error
384          * is associated with this character */
385
386         if ((rfoc = base_addr[CyRFOC]) != 0)
387                 data = base_addr[CyRDR];
388         else
389                 data = 0;
390
391         /* if there is nowhere to put the data, discard it */
392         if (info->tty == 0) {
393                 base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
394                 return IRQ_HANDLED;
395         } else {                /* there is an open port for this data */
396                 tty = info->tty;
397                 if (err & info->ignore_status_mask) {
398                         base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
399                         return IRQ_HANDLED;
400                 }
401                 if (tty_buffer_request_room(tty, 1) != 0) {
402                         if (err & info->read_status_mask) {
403                                 if (err & CyBREAK) {
404                                         tty_insert_flip_char(tty, data,
405                                                              TTY_BREAK);
406                                         if (info->flags & ASYNC_SAK) {
407                                                 do_SAK(tty);
408                                         }
409                                 } else if (err & CyFRAME) {
410                                         tty_insert_flip_char(tty, data,
411                                                              TTY_FRAME);
412                                 } else if (err & CyPARITY) {
413                                         tty_insert_flip_char(tty, data,
414                                                              TTY_PARITY);
415                                 } else if (err & CyOVERRUN) {
416                                         tty_insert_flip_char(tty, 0,
417                                                              TTY_OVERRUN);
418                                         /*
419                                            If the flip buffer itself is
420                                            overflowing, we still lose
421                                            the next incoming character.
422                                          */
423                                         if (tty_buffer_request_room(tty, 1) !=
424                                             0) {
425                                                 tty_insert_flip_char(tty, data,
426                                                                      TTY_FRAME);
427                                         }
428                                         /* These two conditions may imply */
429                                         /* a normal read should be done. */
430                                         /* else if(data & CyTIMEOUT) */
431                                         /* else if(data & CySPECHAR) */
432                                 } else {
433                                         tty_insert_flip_char(tty, 0,
434                                                              TTY_NORMAL);
435                                 }
436                         } else {
437                                 tty_insert_flip_char(tty, data, TTY_NORMAL);
438                         }
439                 } else {
440                         /* there was a software buffer overrun
441                            and nothing could be done about it!!! */
442                 }
443         }
444         tty_schedule_flip(tty);
445         /* end of service */
446         base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
447         return IRQ_HANDLED;
448 }                               /* cy_rxerr_interrupt */
449
450 static irqreturn_t cd2401_modem_interrupt(int irq, void *dev_id)
451 {
452         struct cyclades_port *info;
453         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
454         int channel;
455         int mdm_change;
456         int mdm_status;
457
458         /* determine the channel and change to that context */
459         channel = (u_short) (base_addr[CyLICR] >> 2);
460         info = &cy_port[channel];
461         info->last_active = jiffies;
462
463         mdm_change = base_addr[CyMISR];
464         mdm_status = base_addr[CyMSVR1];
465
466         if (info->tty == 0) {   /* nowhere to put the data, ignore it */
467                 ;
468         } else {
469                 if ((mdm_change & CyDCD)
470                     && (info->flags & ASYNC_CHECK_CD)) {
471                         if (mdm_status & CyDCD) {
472 /* CP('!'); */
473                                 wake_up_interruptible(&info->open_wait);
474                         } else {
475 /* CP('@'); */
476                                 tty_hangup(info->tty);
477                                 wake_up_interruptible(&info->open_wait);
478                                 info->flags &= ~ASYNC_NORMAL_ACTIVE;
479                         }
480                 }
481                 if ((mdm_change & CyCTS)
482                     && (info->flags & ASYNC_CTS_FLOW)) {
483                         if (info->tty->stopped) {
484                                 if (mdm_status & CyCTS) {
485                                         /* !!! cy_start isn't used because... */
486                                         info->tty->stopped = 0;
487                                         base_addr[CyIER] |= CyTxMpty;
488                                         tty_wakeup(info->tty);
489                                 }
490                         } else {
491                                 if (!(mdm_status & CyCTS)) {
492                                         /* !!! cy_stop isn't used because... */
493                                         info->tty->stopped = 1;
494                                         base_addr[CyIER] &=
495                                             ~(CyTxMpty | CyTxRdy);
496                                 }
497                         }
498                 }
499                 if (mdm_status & CyDSR) {
500                 }
501         }
502         base_addr[CyMEOIR] = 0;
503         return IRQ_HANDLED;
504 }                               /* cy_modem_interrupt */
505
506 static irqreturn_t cd2401_tx_interrupt(int irq, void *dev_id)
507 {
508         struct cyclades_port *info;
509         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
510         int channel;
511         int char_count, saved_cnt;
512         int outch;
513
514         /* determine the channel and change to that context */
515         channel = (u_short) (base_addr[CyLICR] >> 2);
516
517 #ifdef CONFIG_REMOTE_DEBUG
518         if (channel == DEBUG_PORT) {
519                 panic("TxInt on debug port!!!");
520         }
521 #endif
522         /* validate the port number (as configured and open) */
523         if ((channel < 0) || (NR_PORTS <= channel)) {
524                 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
525                 base_addr[CyTEOIR] = CyNOTRANS;
526                 return IRQ_HANDLED;
527         }
528         info = &cy_port[channel];
529         info->last_active = jiffies;
530         if (info->tty == 0) {
531                 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
532                 base_addr[CyTEOIR] = CyNOTRANS;
533                 return IRQ_HANDLED;
534         }
535
536         /* load the on-chip space available for outbound data */
537         saved_cnt = char_count = base_addr[CyTFTC];
538
539         if (info->x_char) {     /* send special char */
540                 outch = info->x_char;
541                 base_addr[CyTDR] = outch;
542                 char_count--;
543                 info->x_char = 0;
544         }
545
546         if (info->x_break) {
547                 /*  The Cirrus chip requires the "Embedded Transmit
548                    Commands" of start break, delay, and end break
549                    sequences to be sent.  The duration of the
550                    break is given in TICs, which runs at HZ
551                    (typically 100) and the PPR runs at 200 Hz,
552                    so the delay is duration * 200/HZ, and thus a
553                    break can run from 1/100 sec to about 5/4 sec.
554                    Need to check these values - RGH 141095.
555                  */
556                 base_addr[CyTDR] = 0;   /* start break */
557                 base_addr[CyTDR] = 0x81;
558                 base_addr[CyTDR] = 0;   /* delay a bit */
559                 base_addr[CyTDR] = 0x82;
560                 base_addr[CyTDR] = info->x_break * 200 / HZ;
561                 base_addr[CyTDR] = 0;   /* terminate break */
562                 base_addr[CyTDR] = 0x83;
563                 char_count -= 7;
564                 info->x_break = 0;
565         }
566
567         while (char_count > 0) {
568                 if (!info->xmit_cnt) {
569                         base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
570                         break;
571                 }
572                 if (info->xmit_buf == 0) {
573                         base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
574                         break;
575                 }
576                 if (info->tty->stopped || info->tty->hw_stopped) {
577                         base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
578                         break;
579                 }
580                 /* Because the Embedded Transmit Commands have been
581                    enabled, we must check to see if the escape
582                    character, NULL, is being sent.  If it is, we
583                    must ensure that there is room for it to be
584                    doubled in the output stream.  Therefore we
585                    no longer advance the pointer when the character
586                    is fetched, but rather wait until after the check
587                    for a NULL output character. (This is necessary
588                    because there may not be room for the two chars
589                    needed to send a NULL.
590                  */
591                 outch = info->xmit_buf[info->xmit_tail];
592                 if (outch) {
593                         info->xmit_cnt--;
594                         info->xmit_tail = (info->xmit_tail + 1)
595                             & (PAGE_SIZE - 1);
596                         base_addr[CyTDR] = outch;
597                         char_count--;
598                 } else {
599                         if (char_count > 1) {
600                                 info->xmit_cnt--;
601                                 info->xmit_tail = (info->xmit_tail + 1)
602                                     & (PAGE_SIZE - 1);
603                                 base_addr[CyTDR] = outch;
604                                 base_addr[CyTDR] = 0;
605                                 char_count--;
606                                 char_count--;
607                         } else {
608                                 break;
609                         }
610                 }
611         }
612
613         if (info->xmit_cnt < WAKEUP_CHARS)
614                 tty_wakeup(info->tty);
615
616         base_addr[CyTEOIR] = (char_count != saved_cnt) ? 0 : CyNOTRANS;
617         return IRQ_HANDLED;
618 }                               /* cy_tx_interrupt */
619
620 static irqreturn_t cd2401_rx_interrupt(int irq, void *dev_id)
621 {
622         struct tty_struct *tty;
623         struct cyclades_port *info;
624         volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
625         int channel;
626         char data;
627         int char_count;
628         int save_cnt;
629         int len;
630
631         /* determine the channel and change to that context */
632         channel = (u_short) (base_addr[CyLICR] >> 2);
633         info = &cy_port[channel];
634         info->last_active = jiffies;
635         save_cnt = char_count = base_addr[CyRFOC];
636
637 #ifdef CONFIG_REMOTE_DEBUG
638         if (channel == DEBUG_PORT) {
639                 while (char_count--) {
640                         data = base_addr[CyRDR];
641                         queueDebugChar(data);
642                 }
643         } else
644 #endif
645                 /* if there is nowhere to put the data, discard it */
646         if (info->tty == 0) {
647                 while (char_count--) {
648                         data = base_addr[CyRDR];
649                 }
650         } else {                /* there is an open port for this data */
651                 tty = info->tty;
652                 /* load # characters available from the chip */
653
654 #ifdef CYCLOM_ENABLE_MONITORING
655                 ++info->mon.int_count;
656                 info->mon.char_count += char_count;
657                 if (char_count > info->mon.char_max)
658                         info->mon.char_max = char_count;
659                 info->mon.char_last = char_count;
660 #endif
661                 len = tty_buffer_request_room(tty, char_count);
662                 while (len--) {
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 ammount 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");