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