Merge master.kernel.org:/pub/scm/linux/kernel/git/dwmw2/audit-2.6
[linux-2.6] / drivers / serial / mcfserial.c
1 /*
2  * mcfserial.c -- serial driver for ColdFire internal UARTS.
3  *
4  * Copyright (C) 1999-2003 Greg Ungerer <gerg@snapgear.com>
5  * Copyright (c) 2000-2001 Lineo, Inc. <www.lineo.com> 
6  * Copyright (C) 2001-2002 SnapGear Inc. <www.snapgear.com> 
7  *
8  * Based on code from 68332serial.c which was:
9  *
10  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
11  * Copyright (C) 1998 TSHG
12  * Copyright (c) 1999 Rt-Control Inc. <jeff@uclinux.org>
13  *
14  * Changes:
15  * 08/07/2003    Daniele Bellucci <bellucda@tiscali.it>
16  *               some cleanups in mcfrs_write.
17  *
18  */
19  
20 #include <linux/module.h>
21 #include <linux/errno.h>
22 #include <linux/signal.h>
23 #include <linux/sched.h>
24 #include <linux/timer.h>
25 #include <linux/wait.h>
26 #include <linux/interrupt.h>
27 #include <linux/tty.h>
28 #include <linux/tty_flip.h>
29 #include <linux/string.h>
30 #include <linux/fcntl.h>
31 #include <linux/mm.h>
32 #include <linux/kernel.h>
33 #include <linux/serial.h>
34 #include <linux/serialP.h>
35 #include <linux/console.h>
36 #include <linux/init.h>
37 #include <linux/bitops.h>
38 #include <linux/delay.h>
39
40 #include <asm/io.h>
41 #include <asm/irq.h>
42 #include <asm/system.h>
43 #include <asm/semaphore.h>
44 #include <asm/delay.h>
45 #include <asm/coldfire.h>
46 #include <asm/mcfsim.h>
47 #include <asm/mcfuart.h>
48 #include <asm/nettel.h>
49 #include <asm/uaccess.h>
50 #include "mcfserial.h"
51
52 struct timer_list mcfrs_timer_struct;
53
54 /*
55  *      Default console baud rate,  we use this as the default
56  *      for all ports so init can just open /dev/console and
57  *      keep going.  Perhaps one day the cflag settings for the
58  *      console can be used instead.
59  */
60 #if defined(CONFIG_ARNEWSH) || defined(CONFIG_MOTOROLA) || defined(CONFIG_senTec) || defined(CONFIG_SNEHA)
61 #define CONSOLE_BAUD_RATE       19200
62 #define DEFAULT_CBAUD           B19200
63 #endif
64
65 #if defined(CONFIG_HW_FEITH)
66 #define CONSOLE_BAUD_RATE       38400
67 #define DEFAULT_CBAUD           B38400
68 #endif
69
70 #if defined(CONFIG_MOD5272)
71 #define CONSOLE_BAUD_RATE       115200
72 #define DEFAULT_CBAUD           B115200
73 #endif
74
75 #ifndef CONSOLE_BAUD_RATE
76 #define CONSOLE_BAUD_RATE       9600
77 #define DEFAULT_CBAUD           B9600
78 #endif
79
80 int mcfrs_console_inited = 0;
81 int mcfrs_console_port = -1;
82 int mcfrs_console_baud = CONSOLE_BAUD_RATE;
83 int mcfrs_console_cbaud = DEFAULT_CBAUD;
84
85 /*
86  *      Driver data structures.
87  */
88 static struct tty_driver *mcfrs_serial_driver;
89
90 /* number of characters left in xmit buffer before we ask for more */
91 #define WAKEUP_CHARS 256
92
93 /* Debugging...
94  */
95 #undef SERIAL_DEBUG_OPEN
96 #undef SERIAL_DEBUG_FLOW
97
98 #if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x)
99 #define IRQBASE (MCFINT_VECBASE+MCFINT_UART0)
100 #else
101 #define IRQBASE 73
102 #endif
103
104 /*
105  *      Configuration table, UARTs to look for at startup.
106  */
107 static struct mcf_serial mcfrs_table[] = {
108         {  /* ttyS0 */
109                 .magic = 0,
110                 .addr = (volatile unsigned char *) (MCF_MBAR+MCFUART_BASE1),
111                 .irq = IRQBASE,
112                 .flags = ASYNC_BOOT_AUTOCONF,
113         },
114         {  /* ttyS1 */
115                 .magic = 0,
116                 .addr = (volatile unsigned char *) (MCF_MBAR+MCFUART_BASE2),
117                 .irq = IRQBASE+1,
118                 .flags = ASYNC_BOOT_AUTOCONF,
119         },
120 };
121
122
123 #define NR_PORTS        (sizeof(mcfrs_table) / sizeof(struct mcf_serial))
124
125 /*
126  * This is used to figure out the divisor speeds and the timeouts.
127  */
128 static int mcfrs_baud_table[] = {
129         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
130         9600, 19200, 38400, 57600, 115200, 230400, 460800, 0
131 };
132 #define MCFRS_BAUD_TABLE_SIZE \
133                         (sizeof(mcfrs_baud_table)/sizeof(mcfrs_baud_table[0]))
134
135
136 #ifdef CONFIG_MAGIC_SYSRQ
137 /*
138  *      Magic system request keys. Used for debugging...
139  */
140 extern int      magic_sysrq_key(int ch);
141 #endif
142
143
144 /*
145  *      Forware declarations...
146  */
147 static void     mcfrs_change_speed(struct mcf_serial *info);
148 static void     mcfrs_wait_until_sent(struct tty_struct *tty, int timeout);
149
150
151 static inline int serial_paranoia_check(struct mcf_serial *info,
152                                         char *name, const char *routine)
153 {
154 #ifdef SERIAL_PARANOIA_CHECK
155         static const char badmagic[] =
156                 "MCFRS(warning): bad magic number for serial struct %s in %s\n";
157         static const char badinfo[] =
158                 "MCFRS(warning): null mcf_serial for %s in %s\n";
159
160         if (!info) {
161                 printk(badinfo, name, routine);
162                 return 1;
163         }
164         if (info->magic != SERIAL_MAGIC) {
165                 printk(badmagic, name, routine);
166                 return 1;
167         }
168 #endif
169         return 0;
170 }
171
172 /*
173  *      Sets or clears DTR and RTS on the requested line.
174  */
175 static void mcfrs_setsignals(struct mcf_serial *info, int dtr, int rts)
176 {
177         volatile unsigned char  *uartp;
178         unsigned long           flags;
179         
180 #if 0
181         printk("%s(%d): mcfrs_setsignals(info=%x,dtr=%d,rts=%d)\n",
182                 __FILE__, __LINE__, info, dtr, rts);
183 #endif
184
185         local_irq_save(flags);
186         if (dtr >= 0) {
187 #ifdef MCFPP_DTR0
188                 if (info->line)
189                         mcf_setppdata(MCFPP_DTR1, (dtr ? 0 : MCFPP_DTR1));
190                 else
191                         mcf_setppdata(MCFPP_DTR0, (dtr ? 0 : MCFPP_DTR0));
192 #endif
193         }
194         if (rts >= 0) {
195                 uartp = info->addr;
196                 if (rts) {
197                         info->sigs |= TIOCM_RTS;
198                         uartp[MCFUART_UOP1] = MCFUART_UOP_RTS;
199                 } else {
200                         info->sigs &= ~TIOCM_RTS;
201                         uartp[MCFUART_UOP0] = MCFUART_UOP_RTS;
202                 }
203         }
204         local_irq_restore(flags);
205         return;
206 }
207
208 /*
209  *      Gets values of serial signals.
210  */
211 static int mcfrs_getsignals(struct mcf_serial *info)
212 {
213         volatile unsigned char  *uartp;
214         unsigned long           flags;
215         int                     sigs;
216 #if defined(CONFIG_NETtel) && defined(CONFIG_M5307)
217         unsigned short          ppdata;
218 #endif
219
220 #if 0
221         printk("%s(%d): mcfrs_getsignals(info=%x)\n", __FILE__, __LINE__);
222 #endif
223
224         local_irq_save(flags);
225         uartp = info->addr;
226         sigs = (uartp[MCFUART_UIPR] & MCFUART_UIPR_CTS) ? 0 : TIOCM_CTS;
227         sigs |= (info->sigs & TIOCM_RTS);
228
229 #ifdef MCFPP_DCD0
230 {
231         unsigned int ppdata;
232         ppdata = mcf_getppdata();
233         if (info->line == 0) {
234                 sigs |= (ppdata & MCFPP_DCD0) ? 0 : TIOCM_CD;
235                 sigs |= (ppdata & MCFPP_DTR0) ? 0 : TIOCM_DTR;
236         } else if (info->line == 1) {
237                 sigs |= (ppdata & MCFPP_DCD1) ? 0 : TIOCM_CD;
238                 sigs |= (ppdata & MCFPP_DTR1) ? 0 : TIOCM_DTR;
239         }
240 }
241 #endif
242
243         local_irq_restore(flags);
244         return(sigs);
245 }
246
247 /*
248  * ------------------------------------------------------------
249  * mcfrs_stop() and mcfrs_start()
250  *
251  * This routines are called before setting or resetting tty->stopped.
252  * They enable or disable transmitter interrupts, as necessary.
253  * ------------------------------------------------------------
254  */
255 static void mcfrs_stop(struct tty_struct *tty)
256 {
257         volatile unsigned char  *uartp;
258         struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
259         unsigned long           flags;
260
261         if (serial_paranoia_check(info, tty->name, "mcfrs_stop"))
262                 return;
263         
264         local_irq_save(flags);
265         uartp = info->addr;
266         info->imr &= ~MCFUART_UIR_TXREADY;
267         uartp[MCFUART_UIMR] = info->imr;
268         local_irq_restore(flags);
269 }
270
271 static void mcfrs_start(struct tty_struct *tty)
272 {
273         volatile unsigned char  *uartp;
274         struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
275         unsigned long           flags;
276         
277         if (serial_paranoia_check(info, tty->name, "mcfrs_start"))
278                 return;
279
280         local_irq_save(flags);
281         if (info->xmit_cnt && info->xmit_buf) {
282                 uartp = info->addr;
283                 info->imr |= MCFUART_UIR_TXREADY;
284                 uartp[MCFUART_UIMR] = info->imr;
285         }
286         local_irq_restore(flags);
287 }
288
289 /*
290  * ----------------------------------------------------------------------
291  *
292  * Here starts the interrupt handling routines.  All of the following
293  * subroutines are declared as inline and are folded into
294  * mcfrs_interrupt().  They were separated out for readability's sake.
295  *
296  * Note: mcfrs_interrupt() is a "fast" interrupt, which means that it
297  * runs with interrupts turned off.  People who may want to modify
298  * mcfrs_interrupt() should try to keep the interrupt handler as fast as
299  * possible.  After you are done making modifications, it is not a bad
300  * idea to do:
301  * 
302  * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
303  *
304  * and look at the resulting assemble code in serial.s.
305  *
306  *                              - Ted Ts'o (tytso@mit.edu), 7-Mar-93
307  * -----------------------------------------------------------------------
308  */
309
310 static inline void receive_chars(struct mcf_serial *info)
311 {
312         volatile unsigned char  *uartp;
313         struct tty_struct       *tty = info->tty;
314         unsigned char           status, ch;
315
316         if (!tty)
317                 return;
318
319         uartp = info->addr;
320
321         while ((status = uartp[MCFUART_USR]) & MCFUART_USR_RXREADY) {
322
323                 if (tty->flip.count >= TTY_FLIPBUF_SIZE)
324                         break;
325
326                 ch = uartp[MCFUART_URB];
327                 info->stats.rx++;
328
329 #ifdef CONFIG_MAGIC_SYSRQ
330                 if (mcfrs_console_inited && (info->line == mcfrs_console_port)) {
331                         if (magic_sysrq_key(ch))
332                                 continue;
333                 }
334 #endif
335
336                 tty->flip.count++;
337                 if (status & MCFUART_USR_RXERR) {
338                         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETERR;
339                         if (status & MCFUART_USR_RXBREAK) {
340                                 info->stats.rxbreak++;
341                                 *tty->flip.flag_buf_ptr++ = TTY_BREAK;
342                         } else if (status & MCFUART_USR_RXPARITY) {
343                                 info->stats.rxparity++;
344                                 *tty->flip.flag_buf_ptr++ = TTY_PARITY;
345                         } else if (status & MCFUART_USR_RXOVERRUN) {
346                                 info->stats.rxoverrun++;
347                                 *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
348                         } else if (status & MCFUART_USR_RXFRAMING) {
349                                 info->stats.rxframing++;
350                                 *tty->flip.flag_buf_ptr++ = TTY_FRAME;
351                         } else {
352                                 /* This should never happen... */
353                                 *tty->flip.flag_buf_ptr++ = 0;
354                         }
355                 } else {
356                         *tty->flip.flag_buf_ptr++ = 0;
357                 }
358                 *tty->flip.char_buf_ptr++ = ch;
359         }
360
361         schedule_work(&tty->flip.work);
362         return;
363 }
364
365 static inline void transmit_chars(struct mcf_serial *info)
366 {
367         volatile unsigned char  *uartp;
368
369         uartp = info->addr;
370
371         if (info->x_char) {
372                 /* Send special char - probably flow control */
373                 uartp[MCFUART_UTB] = info->x_char;
374                 info->x_char = 0;
375                 info->stats.tx++;
376         }
377
378         if ((info->xmit_cnt <= 0) || info->tty->stopped) {
379                 info->imr &= ~MCFUART_UIR_TXREADY;
380                 uartp[MCFUART_UIMR] = info->imr;
381                 return;
382         }
383
384         while (uartp[MCFUART_USR] & MCFUART_USR_TXREADY) {
385                 uartp[MCFUART_UTB] = info->xmit_buf[info->xmit_tail++];
386                 info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
387                 info->stats.tx++;
388                 if (--info->xmit_cnt <= 0)
389                         break;
390         }
391
392         if (info->xmit_cnt < WAKEUP_CHARS)
393                 schedule_work(&info->tqueue);
394         return;
395 }
396
397 /*
398  * This is the serial driver's generic interrupt routine
399  */
400 irqreturn_t mcfrs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
401 {
402         struct mcf_serial       *info;
403         unsigned char           isr;
404
405         info = &mcfrs_table[(irq - IRQBASE)];
406         isr = info->addr[MCFUART_UISR] & info->imr;
407
408         if (isr & MCFUART_UIR_RXREADY)
409                 receive_chars(info);
410         if (isr & MCFUART_UIR_TXREADY)
411                 transmit_chars(info);
412         return IRQ_HANDLED;
413 }
414
415 /*
416  * -------------------------------------------------------------------
417  * Here ends the serial interrupt routines.
418  * -------------------------------------------------------------------
419  */
420
421 static void mcfrs_offintr(void *private)
422 {
423         struct mcf_serial       *info = (struct mcf_serial *) private;
424         struct tty_struct       *tty;
425         
426         tty = info->tty;
427         if (!tty)
428                 return;
429         tty_wakeup(tty);
430 }
431
432
433 /*
434  *      Change of state on a DCD line.
435  */
436 void mcfrs_modem_change(struct mcf_serial *info, int dcd)
437 {
438         if (info->count == 0)
439                 return;
440
441         if (info->flags & ASYNC_CHECK_CD) {
442                 if (dcd)
443                         wake_up_interruptible(&info->open_wait);
444                 else 
445                         schedule_work(&info->tqueue_hangup);
446         }
447 }
448
449
450 #ifdef MCFPP_DCD0
451
452 unsigned short  mcfrs_ppstatus;
453
454 /*
455  * This subroutine is called when the RS_TIMER goes off. It is used
456  * to monitor the state of the DCD lines - since they have no edge
457  * sensors and interrupt generators.
458  */
459 static void mcfrs_timer(void)
460 {
461         unsigned int    ppstatus, dcdval, i;
462
463         ppstatus = mcf_getppdata() & (MCFPP_DCD0 | MCFPP_DCD1);
464
465         if (ppstatus != mcfrs_ppstatus) {
466                 for (i = 0; (i < 2); i++) {
467                         dcdval = (i ? MCFPP_DCD1 : MCFPP_DCD0);
468                         if ((ppstatus & dcdval) != (mcfrs_ppstatus & dcdval)) {
469                                 mcfrs_modem_change(&mcfrs_table[i],
470                                         ((ppstatus & dcdval) ? 0 : 1));
471                         }
472                 }
473         }
474         mcfrs_ppstatus = ppstatus;
475
476         /* Re-arm timer */
477         mcfrs_timer_struct.expires = jiffies + HZ/25;
478         add_timer(&mcfrs_timer_struct);
479 }
480
481 #endif  /* MCFPP_DCD0 */
482
483
484 /*
485  * This routine is called from the scheduler tqueue when the interrupt
486  * routine has signalled that a hangup has occurred. The path of
487  * hangup processing is:
488  *
489  *      serial interrupt routine -> (scheduler tqueue) ->
490  *      do_serial_hangup() -> tty->hangup() -> mcfrs_hangup()
491  * 
492  */
493 static void do_serial_hangup(void *private)
494 {
495         struct mcf_serial       *info = (struct mcf_serial *) private;
496         struct tty_struct       *tty;
497         
498         tty = info->tty;
499         if (!tty)
500                 return;
501
502         tty_hangup(tty);
503 }
504
505 static int startup(struct mcf_serial * info)
506 {
507         volatile unsigned char  *uartp;
508         unsigned long           flags;
509         
510         if (info->flags & ASYNC_INITIALIZED)
511                 return 0;
512
513         if (!info->xmit_buf) {
514                 info->xmit_buf = (unsigned char *) __get_free_page(GFP_KERNEL);
515                 if (!info->xmit_buf)
516                         return -ENOMEM;
517         }
518
519         local_irq_save(flags);
520
521 #ifdef SERIAL_DEBUG_OPEN
522         printk("starting up ttyS%d (irq %d)...\n", info->line, info->irq);
523 #endif
524
525         /*
526          *      Reset UART, get it into known state...
527          */
528         uartp = info->addr;
529         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETRX;  /* reset RX */
530         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETTX;  /* reset TX */
531         mcfrs_setsignals(info, 1, 1);
532
533         if (info->tty)
534                 clear_bit(TTY_IO_ERROR, &info->tty->flags);
535         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
536
537         /*
538          * and set the speed of the serial port
539          */
540         mcfrs_change_speed(info);
541
542         /*
543          * Lastly enable the UART transmitter and receiver, and
544          * interrupt enables.
545          */
546         info->imr = MCFUART_UIR_RXREADY;
547         uartp[MCFUART_UCR] = MCFUART_UCR_RXENABLE | MCFUART_UCR_TXENABLE;
548         uartp[MCFUART_UIMR] = info->imr;
549
550         info->flags |= ASYNC_INITIALIZED;
551         local_irq_restore(flags);
552         return 0;
553 }
554
555 /*
556  * This routine will shutdown a serial port; interrupts are disabled, and
557  * DTR is dropped if the hangup on close termio flag is on.
558  */
559 static void shutdown(struct mcf_serial * info)
560 {
561         volatile unsigned char  *uartp;
562         unsigned long           flags;
563
564         if (!(info->flags & ASYNC_INITIALIZED))
565                 return;
566
567 #ifdef SERIAL_DEBUG_OPEN
568         printk("Shutting down serial port %d (irq %d)....\n", info->line,
569                info->irq);
570 #endif
571         
572         local_irq_save(flags);
573
574         uartp = info->addr;
575         uartp[MCFUART_UIMR] = 0;  /* mask all interrupts */
576         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETRX;  /* reset RX */
577         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETTX;  /* reset TX */
578
579         if (!info->tty || (info->tty->termios->c_cflag & HUPCL))
580                 mcfrs_setsignals(info, 0, 0);
581
582         if (info->xmit_buf) {
583                 free_page((unsigned long) info->xmit_buf);
584                 info->xmit_buf = 0;
585         }
586
587         if (info->tty)
588                 set_bit(TTY_IO_ERROR, &info->tty->flags);
589         
590         info->flags &= ~ASYNC_INITIALIZED;
591         local_irq_restore(flags);
592 }
593
594
595 /*
596  * This routine is called to set the UART divisor registers to match
597  * the specified baud rate for a serial port.
598  */
599 static void mcfrs_change_speed(struct mcf_serial *info)
600 {
601         volatile unsigned char  *uartp;
602         unsigned int            baudclk, cflag;
603         unsigned long           flags;
604         unsigned char           mr1, mr2;
605         int                     i;
606 #ifdef  CONFIG_M5272
607         unsigned int            fraction;
608 #endif
609
610         if (!info->tty || !info->tty->termios)
611                 return;
612         cflag = info->tty->termios->c_cflag;
613         if (info->addr == 0)
614                 return;
615
616 #if 0
617         printk("%s(%d): mcfrs_change_speed()\n", __FILE__, __LINE__);
618 #endif
619
620         i = cflag & CBAUD;
621         if (i & CBAUDEX) {
622                 i &= ~CBAUDEX;
623                 if (i < 1 || i > 4)
624                         info->tty->termios->c_cflag &= ~CBAUDEX;
625                 else
626                         i += 15;
627         }
628         if (i == 0) {
629                 mcfrs_setsignals(info, 0, -1);
630                 return;
631         }
632
633         /* compute the baudrate clock */
634 #ifdef  CONFIG_M5272
635         /*
636          * For the MCF5272, also compute the baudrate fraction.
637          */
638         baudclk = (MCF_BUSCLK / mcfrs_baud_table[i]) / 32;
639         fraction = MCF_BUSCLK - (baudclk * 32 * mcfrs_baud_table[i]);
640         fraction *= 16;
641         fraction /= (32 * mcfrs_baud_table[i]);
642 #else
643         baudclk = ((MCF_BUSCLK / mcfrs_baud_table[i]) + 16) / 32;
644 #endif
645
646         info->baud = mcfrs_baud_table[i];
647
648         mr1 = MCFUART_MR1_RXIRQRDY | MCFUART_MR1_RXERRCHAR;
649         mr2 = 0;
650
651         switch (cflag & CSIZE) {
652         case CS5:       mr1 |= MCFUART_MR1_CS5; break;
653         case CS6:       mr1 |= MCFUART_MR1_CS6; break;
654         case CS7:       mr1 |= MCFUART_MR1_CS7; break;
655         case CS8:
656         default:        mr1 |= MCFUART_MR1_CS8; break;
657         }
658
659         if (cflag & PARENB) {
660                 if (cflag & CMSPAR) {
661                         if (cflag & PARODD)
662                                 mr1 |= MCFUART_MR1_PARITYMARK;
663                         else
664                                 mr1 |= MCFUART_MR1_PARITYSPACE;
665                 } else {
666                         if (cflag & PARODD)
667                                 mr1 |= MCFUART_MR1_PARITYODD;
668                         else
669                                 mr1 |= MCFUART_MR1_PARITYEVEN;
670                 }
671         } else {
672                 mr1 |= MCFUART_MR1_PARITYNONE;
673         }
674
675         if (cflag & CSTOPB)
676                 mr2 |= MCFUART_MR2_STOP2;
677         else
678                 mr2 |= MCFUART_MR2_STOP1;
679
680         if (cflag & CRTSCTS) {
681                 mr1 |= MCFUART_MR1_RXRTS;
682                 mr2 |= MCFUART_MR2_TXCTS;
683         }
684
685         if (cflag & CLOCAL)
686                 info->flags &= ~ASYNC_CHECK_CD;
687         else
688                 info->flags |= ASYNC_CHECK_CD;
689
690         uartp = info->addr;
691
692         local_irq_save(flags);
693 #if 0
694         printk("%s(%d): mr1=%x mr2=%x baudclk=%x\n", __FILE__, __LINE__,
695                 mr1, mr2, baudclk);
696 #endif
697         /*
698           Note: pg 12-16 of MCF5206e User's Manual states that a
699           software reset should be performed prior to changing
700           UMR1,2, UCSR, UACR, bit 7
701         */
702         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETRX;    /* reset RX */
703         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETTX;    /* reset TX */
704         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETMRPTR; /* reset MR pointer */
705         uartp[MCFUART_UMR] = mr1;
706         uartp[MCFUART_UMR] = mr2;
707         uartp[MCFUART_UBG1] = (baudclk & 0xff00) >> 8;  /* set msb byte */
708         uartp[MCFUART_UBG2] = (baudclk & 0xff);         /* set lsb byte */
709 #ifdef  CONFIG_M5272
710         uartp[MCFUART_UFPD] = (fraction & 0xf);         /* set fraction */
711 #endif
712         uartp[MCFUART_UCSR] = MCFUART_UCSR_RXCLKTIMER | MCFUART_UCSR_TXCLKTIMER;
713         uartp[MCFUART_UCR] = MCFUART_UCR_RXENABLE | MCFUART_UCR_TXENABLE;
714         mcfrs_setsignals(info, 1, -1);
715         local_irq_restore(flags);
716         return;
717 }
718
719 static void mcfrs_flush_chars(struct tty_struct *tty)
720 {
721         volatile unsigned char  *uartp;
722         struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
723         unsigned long           flags;
724
725         if (serial_paranoia_check(info, tty->name, "mcfrs_flush_chars"))
726                 return;
727
728         uartp = (volatile unsigned char *) info->addr;
729
730         /*
731          * re-enable receiver interrupt
732          */
733         local_irq_save(flags);
734         if ((!(info->imr & MCFUART_UIR_RXREADY)) &&
735             (info->flags & ASYNC_INITIALIZED) ) {
736                 info->imr |= MCFUART_UIR_RXREADY;
737                 uartp[MCFUART_UIMR] = info->imr;
738         }
739         local_irq_restore(flags);
740
741         if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
742             !info->xmit_buf)
743                 return;
744
745         /* Enable transmitter */
746         local_irq_save(flags);
747         info->imr |= MCFUART_UIR_TXREADY;
748         uartp[MCFUART_UIMR] = info->imr;
749         local_irq_restore(flags);
750 }
751
752 static int mcfrs_write(struct tty_struct * tty,
753                     const unsigned char *buf, int count)
754 {
755         volatile unsigned char  *uartp;
756         struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
757         unsigned long           flags;
758         int                     c, total = 0;
759
760 #if 0
761         printk("%s(%d): mcfrs_write(tty=%x,buf=%x,count=%d)\n",
762                 __FILE__, __LINE__, (int)tty, (int)buf, count);
763 #endif
764
765         if (serial_paranoia_check(info, tty->name, "mcfrs_write"))
766                 return 0;
767
768         if (!tty || !info->xmit_buf)
769                 return 0;
770         
771         local_save_flags(flags);
772         while (1) {
773                 local_irq_disable();            
774                 c = min(count, (int) min(((int)SERIAL_XMIT_SIZE) - info->xmit_cnt - 1,
775                         ((int)SERIAL_XMIT_SIZE) - info->xmit_head));
776                 local_irq_restore(flags);
777
778                 if (c <= 0)
779                         break;
780
781                 memcpy(info->xmit_buf + info->xmit_head, buf, c);
782
783                 local_irq_disable();
784                 info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
785                 info->xmit_cnt += c;
786                 local_irq_restore(flags);
787
788                 buf += c;
789                 count -= c;
790                 total += c;
791         }
792
793         local_irq_disable();
794         uartp = info->addr;
795         info->imr |= MCFUART_UIR_TXREADY;
796         uartp[MCFUART_UIMR] = info->imr;
797         local_irq_restore(flags);
798
799         return total;
800 }
801
802 static int mcfrs_write_room(struct tty_struct *tty)
803 {
804         struct mcf_serial *info = (struct mcf_serial *)tty->driver_data;
805         int     ret;
806
807         if (serial_paranoia_check(info, tty->name, "mcfrs_write_room"))
808                 return 0;
809         ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
810         if (ret < 0)
811                 ret = 0;
812         return ret;
813 }
814
815 static int mcfrs_chars_in_buffer(struct tty_struct *tty)
816 {
817         struct mcf_serial *info = (struct mcf_serial *)tty->driver_data;
818
819         if (serial_paranoia_check(info, tty->name, "mcfrs_chars_in_buffer"))
820                 return 0;
821         return info->xmit_cnt;
822 }
823
824 static void mcfrs_flush_buffer(struct tty_struct *tty)
825 {
826         struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
827         unsigned long           flags;
828
829         if (serial_paranoia_check(info, tty->name, "mcfrs_flush_buffer"))
830                 return;
831
832         local_irq_save(flags);
833         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
834         local_irq_restore(flags);
835
836         tty_wakeup(tty);
837 }
838
839 /*
840  * ------------------------------------------------------------
841  * mcfrs_throttle()
842  * 
843  * This routine is called by the upper-layer tty layer to signal that
844  * incoming characters should be throttled.
845  * ------------------------------------------------------------
846  */
847 static void mcfrs_throttle(struct tty_struct * tty)
848 {
849         struct mcf_serial *info = (struct mcf_serial *)tty->driver_data;
850 #ifdef SERIAL_DEBUG_THROTTLE
851         char    buf[64];
852         
853         printk("throttle %s: %d....\n", _tty_name(tty, buf),
854                tty->ldisc.chars_in_buffer(tty));
855 #endif
856
857         if (serial_paranoia_check(info, tty->name, "mcfrs_throttle"))
858                 return;
859         
860         if (I_IXOFF(tty))
861                 info->x_char = STOP_CHAR(tty);
862
863         /* Turn off RTS line (do this atomic) */
864 }
865
866 static void mcfrs_unthrottle(struct tty_struct * tty)
867 {
868         struct mcf_serial *info = (struct mcf_serial *)tty->driver_data;
869 #ifdef SERIAL_DEBUG_THROTTLE
870         char    buf[64];
871         
872         printk("unthrottle %s: %d....\n", _tty_name(tty, buf),
873                tty->ldisc.chars_in_buffer(tty));
874 #endif
875
876         if (serial_paranoia_check(info, tty->name, "mcfrs_unthrottle"))
877                 return;
878         
879         if (I_IXOFF(tty)) {
880                 if (info->x_char)
881                         info->x_char = 0;
882                 else
883                         info->x_char = START_CHAR(tty);
884         }
885
886         /* Assert RTS line (do this atomic) */
887 }
888
889 /*
890  * ------------------------------------------------------------
891  * mcfrs_ioctl() and friends
892  * ------------------------------------------------------------
893  */
894
895 static int get_serial_info(struct mcf_serial * info,
896                            struct serial_struct * retinfo)
897 {
898         struct serial_struct tmp;
899   
900         if (!retinfo)
901                 return -EFAULT;
902         memset(&tmp, 0, sizeof(tmp));
903         tmp.type = info->type;
904         tmp.line = info->line;
905         tmp.port = (unsigned int) info->addr;
906         tmp.irq = info->irq;
907         tmp.flags = info->flags;
908         tmp.baud_base = info->baud_base;
909         tmp.close_delay = info->close_delay;
910         tmp.closing_wait = info->closing_wait;
911         tmp.custom_divisor = info->custom_divisor;
912         return copy_to_user(retinfo,&tmp,sizeof(*retinfo)) ? -EFAULT : 0;
913 }
914
915 static int set_serial_info(struct mcf_serial * info,
916                            struct serial_struct * new_info)
917 {
918         struct serial_struct new_serial;
919         struct mcf_serial old_info;
920         int     retval = 0;
921
922         if (!new_info)
923                 return -EFAULT;
924         if (copy_from_user(&new_serial,new_info,sizeof(new_serial)))
925                 return -EFAULT;
926         old_info = *info;
927
928         if (!capable(CAP_SYS_ADMIN)) {
929                 if ((new_serial.baud_base != info->baud_base) ||
930                     (new_serial.type != info->type) ||
931                     (new_serial.close_delay != info->close_delay) ||
932                     ((new_serial.flags & ~ASYNC_USR_MASK) !=
933                      (info->flags & ~ASYNC_USR_MASK)))
934                         return -EPERM;
935                 info->flags = ((info->flags & ~ASYNC_USR_MASK) |
936                                (new_serial.flags & ASYNC_USR_MASK));
937                 info->custom_divisor = new_serial.custom_divisor;
938                 goto check_and_exit;
939         }
940
941         if (info->count > 1)
942                 return -EBUSY;
943
944         /*
945          * OK, past this point, all the error checking has been done.
946          * At this point, we start making changes.....
947          */
948
949         info->baud_base = new_serial.baud_base;
950         info->flags = ((info->flags & ~ASYNC_FLAGS) |
951                         (new_serial.flags & ASYNC_FLAGS));
952         info->type = new_serial.type;
953         info->close_delay = new_serial.close_delay;
954         info->closing_wait = new_serial.closing_wait;
955
956 check_and_exit:
957         retval = startup(info);
958         return retval;
959 }
960
961 /*
962  * get_lsr_info - get line status register info
963  *
964  * Purpose: Let user call ioctl() to get info when the UART physically
965  *          is emptied.  On bus types like RS485, the transmitter must
966  *          release the bus after transmitting. This must be done when
967  *          the transmit shift register is empty, not be done when the
968  *          transmit holding register is empty.  This functionality
969  *          allows an RS485 driver to be written in user space. 
970  */
971 static int get_lsr_info(struct mcf_serial * info, unsigned int *value)
972 {
973         volatile unsigned char  *uartp;
974         unsigned long           flags;
975         unsigned char           status;
976
977         local_irq_save(flags);
978         uartp = info->addr;
979         status = (uartp[MCFUART_USR] & MCFUART_USR_TXEMPTY) ? TIOCSER_TEMT : 0;
980         local_irq_restore(flags);
981
982         return put_user(status,value);
983 }
984
985 /*
986  * This routine sends a break character out the serial port.
987  */
988 static void send_break( struct mcf_serial * info, int duration)
989 {
990         volatile unsigned char  *uartp;
991         unsigned long           flags;
992
993         if (!info->addr)
994                 return;
995         set_current_state(TASK_INTERRUPTIBLE);
996         uartp = info->addr;
997
998         local_irq_save(flags);
999         uartp[MCFUART_UCR] = MCFUART_UCR_CMDBREAKSTART;
1000         schedule_timeout(duration);
1001         uartp[MCFUART_UCR] = MCFUART_UCR_CMDBREAKSTOP;
1002         local_irq_restore(flags);
1003 }
1004
1005 static int mcfrs_tiocmget(struct tty_struct *tty, struct file *file)
1006 {
1007         struct mcf_serial * info = (struct mcf_serial *)tty->driver_data;
1008
1009         if (serial_paranoia_check(info, tty->name, "mcfrs_ioctl"))
1010                 return -ENODEV;
1011         if (tty->flags & (1 << TTY_IO_ERROR))
1012                 return -EIO;
1013
1014         return mcfrs_getsignals(info);
1015 }
1016
1017 static int mcfrs_tiocmset(struct tty_struct *tty, struct file *file,
1018                           unsigned int set, unsigned int clear)
1019 {
1020         struct mcf_serial * info = (struct mcf_serial *)tty->driver_data;
1021         int rts = -1, dtr = -1;
1022
1023         if (serial_paranoia_check(info, tty->name, "mcfrs_ioctl"))
1024                 return -ENODEV;
1025         if (tty->flags & (1 << TTY_IO_ERROR))
1026                 return -EIO;
1027
1028         if (set & TIOCM_RTS)
1029                 rts = 1;
1030         if (set & TIOCM_DTR)
1031                 dtr = 1;
1032         if (clear & TIOCM_RTS)
1033                 rts = 0;
1034         if (clear & TIOCM_DTR)
1035                 dtr = 0;
1036
1037         mcfrs_setsignals(info, dtr, rts);
1038
1039         return 0;
1040 }
1041
1042 static int mcfrs_ioctl(struct tty_struct *tty, struct file * file,
1043                     unsigned int cmd, unsigned long arg)
1044 {
1045         struct mcf_serial * info = (struct mcf_serial *)tty->driver_data;
1046         int retval, error;
1047
1048         if (serial_paranoia_check(info, tty->name, "mcfrs_ioctl"))
1049                 return -ENODEV;
1050
1051         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
1052             (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
1053             (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
1054                 if (tty->flags & (1 << TTY_IO_ERROR))
1055                     return -EIO;
1056         }
1057         
1058         switch (cmd) {
1059                 case TCSBRK:    /* SVID version: non-zero arg --> no break */
1060                         retval = tty_check_change(tty);
1061                         if (retval)
1062                                 return retval;
1063                         tty_wait_until_sent(tty, 0);
1064                         if (!arg)
1065                                 send_break(info, HZ/4); /* 1/4 second */
1066                         return 0;
1067                 case TCSBRKP:   /* support for POSIX tcsendbreak() */
1068                         retval = tty_check_change(tty);
1069                         if (retval)
1070                                 return retval;
1071                         tty_wait_until_sent(tty, 0);
1072                         send_break(info, arg ? arg*(HZ/10) : HZ/4);
1073                         return 0;
1074                 case TIOCGSOFTCAR:
1075                         error = put_user(C_CLOCAL(tty) ? 1 : 0,
1076                                     (unsigned long *) arg);
1077                         if (error)
1078                                 return error;
1079                         return 0;
1080                 case TIOCSSOFTCAR:
1081                         get_user(arg, (unsigned long *) arg);
1082                         tty->termios->c_cflag =
1083                                 ((tty->termios->c_cflag & ~CLOCAL) |
1084                                  (arg ? CLOCAL : 0));
1085                         return 0;
1086                 case TIOCGSERIAL:
1087                         if (access_ok(VERIFY_WRITE, (void *) arg,
1088                                                 sizeof(struct serial_struct)))
1089                                 return get_serial_info(info,
1090                                                (struct serial_struct *) arg);
1091                         return -EFAULT;
1092                 case TIOCSSERIAL:
1093                         return set_serial_info(info,
1094                                                (struct serial_struct *) arg);
1095                 case TIOCSERGETLSR: /* Get line status register */
1096                         if (access_ok(VERIFY_WRITE, (void *) arg,
1097                                                 sizeof(unsigned int)))
1098                                 return get_lsr_info(info, (unsigned int *) arg);
1099                         return -EFAULT;
1100                 case TIOCSERGSTRUCT:
1101                         error = copy_to_user((struct mcf_serial *) arg,
1102                                     info, sizeof(struct mcf_serial));
1103                         if (error)
1104                                 return -EFAULT;
1105                         return 0;
1106                         
1107 #ifdef TIOCSET422
1108                 case TIOCSET422: {
1109                         unsigned int val;
1110                         get_user(val, (unsigned int *) arg);
1111                         mcf_setpa(MCFPP_PA11, (val ? 0 : MCFPP_PA11));
1112                         break;
1113                 }
1114                 case TIOCGET422: {
1115                         unsigned int val;
1116                         val = (mcf_getpa() & MCFPP_PA11) ? 0 : 1;
1117                         put_user(val, (unsigned int *) arg);
1118                         break;
1119                 }
1120 #endif
1121
1122                 default:
1123                         return -ENOIOCTLCMD;
1124                 }
1125         return 0;
1126 }
1127
1128 static void mcfrs_set_termios(struct tty_struct *tty, struct termios *old_termios)
1129 {
1130         struct mcf_serial *info = (struct mcf_serial *)tty->driver_data;
1131
1132         if (tty->termios->c_cflag == old_termios->c_cflag)
1133                 return;
1134
1135         mcfrs_change_speed(info);
1136
1137         if ((old_termios->c_cflag & CRTSCTS) &&
1138             !(tty->termios->c_cflag & CRTSCTS)) {
1139                 tty->hw_stopped = 0;
1140                 mcfrs_setsignals(info, -1, 1);
1141 #if 0
1142                 mcfrs_start(tty);
1143 #endif
1144         }
1145 }
1146
1147 /*
1148  * ------------------------------------------------------------
1149  * mcfrs_close()
1150  * 
1151  * This routine is called when the serial port gets closed.  First, we
1152  * wait for the last remaining data to be sent.  Then, we unlink its
1153  * S structure from the interrupt chain if necessary, and we free
1154  * that IRQ if nothing is left in the chain.
1155  * ------------------------------------------------------------
1156  */
1157 static void mcfrs_close(struct tty_struct *tty, struct file * filp)
1158 {
1159         volatile unsigned char  *uartp;
1160         struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
1161         unsigned long           flags;
1162
1163         if (!info || serial_paranoia_check(info, tty->name, "mcfrs_close"))
1164                 return;
1165         
1166         local_irq_save(flags);
1167         
1168         if (tty_hung_up_p(filp)) {
1169                 local_irq_restore(flags);
1170                 return;
1171         }
1172         
1173 #ifdef SERIAL_DEBUG_OPEN
1174         printk("mcfrs_close ttyS%d, count = %d\n", info->line, info->count);
1175 #endif
1176         if ((tty->count == 1) && (info->count != 1)) {
1177                 /*
1178                  * Uh, oh.  tty->count is 1, which means that the tty
1179                  * structure will be freed.  Info->count should always
1180                  * be one in these conditions.  If it's greater than
1181                  * one, we've got real problems, since it means the
1182                  * serial port won't be shutdown.
1183                  */
1184                 printk("MCFRS: bad serial port count; tty->count is 1, "
1185                        "info->count is %d\n", info->count);
1186                 info->count = 1;
1187         }
1188         if (--info->count < 0) {
1189                 printk("MCFRS: bad serial port count for ttyS%d: %d\n",
1190                        info->line, info->count);
1191                 info->count = 0;
1192         }
1193         if (info->count) {
1194                 local_irq_restore(flags);
1195                 return;
1196         }
1197         info->flags |= ASYNC_CLOSING;
1198
1199         /*
1200          * Now we wait for the transmit buffer to clear; and we notify 
1201          * the line discipline to only process XON/XOFF characters.
1202          */
1203         tty->closing = 1;
1204         if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE)
1205                 tty_wait_until_sent(tty, info->closing_wait);
1206
1207         /*
1208          * At this point we stop accepting input.  To do this, we
1209          * disable the receive line status interrupts, and tell the
1210          * interrupt driver to stop checking the data ready bit in the
1211          * line status register.
1212          */
1213         info->imr &= ~MCFUART_UIR_RXREADY;
1214         uartp = info->addr;
1215         uartp[MCFUART_UIMR] = info->imr;
1216
1217 #if 0
1218         /* FIXME: do we need to keep this enabled for console?? */
1219         if (mcfrs_console_inited && (mcfrs_console_port == info->line)) {
1220                 /* Do not disable the UART */ ;
1221         } else
1222 #endif
1223         shutdown(info);
1224         if (tty->driver->flush_buffer)
1225                 tty->driver->flush_buffer(tty);
1226         tty_ldisc_flush(tty);
1227         
1228         tty->closing = 0;
1229         info->event = 0;
1230         info->tty = 0;
1231 #if 0   
1232         if (tty->ldisc.num != ldiscs[N_TTY].num) {
1233                 if (tty->ldisc.close)
1234                         (tty->ldisc.close)(tty);
1235                 tty->ldisc = ldiscs[N_TTY];
1236                 tty->termios->c_line = N_TTY;
1237                 if (tty->ldisc.open)
1238                         (tty->ldisc.open)(tty);
1239         }
1240 #endif  
1241         if (info->blocked_open) {
1242                 if (info->close_delay) {
1243                         msleep_interruptible(jiffies_to_msecs(info->close_delay));
1244                 }
1245                 wake_up_interruptible(&info->open_wait);
1246         }
1247         info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1248         wake_up_interruptible(&info->close_wait);
1249         local_irq_restore(flags);
1250 }
1251
1252 /*
1253  * mcfrs_wait_until_sent() --- wait until the transmitter is empty
1254  */
1255 static void
1256 mcfrs_wait_until_sent(struct tty_struct *tty, int timeout)
1257 {
1258 #ifdef  CONFIG_M5272
1259 #define MCF5272_FIFO_SIZE       25              /* fifo size + shift reg */
1260
1261         struct mcf_serial * info = (struct mcf_serial *)tty->driver_data;
1262         volatile unsigned char *uartp;
1263         unsigned long orig_jiffies, fifo_time, char_time, fifo_cnt;
1264
1265         if (serial_paranoia_check(info, tty->name, "mcfrs_wait_until_sent"))
1266                 return;
1267
1268         orig_jiffies = jiffies;
1269
1270         /*
1271          * Set the check interval to be 1/5 of the approximate time
1272          * to send the entire fifo, and make it at least 1.  The check
1273          * interval should also be less than the timeout.
1274          *
1275          * Note: we have to use pretty tight timings here to satisfy
1276          * the NIST-PCTS.
1277          */
1278         fifo_time = (MCF5272_FIFO_SIZE * HZ * 10) / info->baud;
1279         char_time = fifo_time / 5;
1280         if (char_time == 0)
1281                 char_time = 1;
1282         if (timeout && timeout < char_time)
1283                 char_time = timeout;
1284
1285         /*
1286          * Clamp the timeout period at 2 * the time to empty the
1287          * fifo.  Just to be safe, set the minimum at .5 seconds.
1288          */
1289         fifo_time *= 2;
1290         if (fifo_time < (HZ/2))
1291                 fifo_time = HZ/2;
1292         if (!timeout || timeout > fifo_time)
1293                 timeout = fifo_time;
1294
1295         /*
1296          * Account for the number of bytes in the UART
1297          * transmitter FIFO plus any byte being shifted out.
1298          */
1299         uartp = (volatile unsigned char *) info->addr;
1300         for (;;) {
1301                 fifo_cnt = (uartp[MCFUART_UTF] & MCFUART_UTF_TXB);
1302                 if ((uartp[MCFUART_USR] & (MCFUART_USR_TXREADY|
1303                                 MCFUART_USR_TXEMPTY)) ==
1304                         MCFUART_USR_TXREADY)
1305                         fifo_cnt++;
1306                 if (fifo_cnt == 0)
1307                         break;
1308                 msleep_interruptible(jiffies_to_msecs(char_time));
1309                 if (signal_pending(current))
1310                         break;
1311                 if (timeout && time_after(jiffies, orig_jiffies + timeout))
1312                         break;
1313         }
1314 #else
1315         /*
1316          * For the other coldfire models, assume all data has been sent
1317          */
1318 #endif
1319 }
1320
1321 /*
1322  * mcfrs_hangup() --- called by tty_hangup() when a hangup is signaled.
1323  */
1324 void mcfrs_hangup(struct tty_struct *tty)
1325 {
1326         struct mcf_serial * info = (struct mcf_serial *)tty->driver_data;
1327         
1328         if (serial_paranoia_check(info, tty->name, "mcfrs_hangup"))
1329                 return;
1330         
1331         mcfrs_flush_buffer(tty);
1332         shutdown(info);
1333         info->event = 0;
1334         info->count = 0;
1335         info->flags &= ~ASYNC_NORMAL_ACTIVE;
1336         info->tty = 0;
1337         wake_up_interruptible(&info->open_wait);
1338 }
1339
1340 /*
1341  * ------------------------------------------------------------
1342  * mcfrs_open() and friends
1343  * ------------------------------------------------------------
1344  */
1345 static int block_til_ready(struct tty_struct *tty, struct file * filp,
1346                            struct mcf_serial *info)
1347 {
1348         DECLARE_WAITQUEUE(wait, current);
1349         int     retval;
1350         int     do_clocal = 0;
1351
1352         /*
1353          * If the device is in the middle of being closed, then block
1354          * until it's done, and then try again.
1355          */
1356         if (info->flags & ASYNC_CLOSING) {
1357                 interruptible_sleep_on(&info->close_wait);
1358 #ifdef SERIAL_DO_RESTART
1359                 if (info->flags & ASYNC_HUP_NOTIFY)
1360                         return -EAGAIN;
1361                 else
1362                         return -ERESTARTSYS;
1363 #else
1364                 return -EAGAIN;
1365 #endif
1366         }
1367         
1368         /*
1369          * If non-blocking mode is set, or the port is not enabled,
1370          * then make the check up front and then exit.
1371          */
1372         if ((filp->f_flags & O_NONBLOCK) ||
1373             (tty->flags & (1 << TTY_IO_ERROR))) {
1374                 info->flags |= ASYNC_NORMAL_ACTIVE;
1375                 return 0;
1376         }
1377
1378         if (tty->termios->c_cflag & CLOCAL)
1379                 do_clocal = 1;
1380
1381         /*
1382          * Block waiting for the carrier detect and the line to become
1383          * free (i.e., not in use by the callout).  While we are in
1384          * this loop, info->count is dropped by one, so that
1385          * mcfrs_close() knows when to free things.  We restore it upon
1386          * exit, either normal or abnormal.
1387          */
1388         retval = 0;
1389         add_wait_queue(&info->open_wait, &wait);
1390 #ifdef SERIAL_DEBUG_OPEN
1391         printk("block_til_ready before block: ttyS%d, count = %d\n",
1392                info->line, info->count);
1393 #endif
1394         info->count--;
1395         info->blocked_open++;
1396         while (1) {
1397                 local_irq_disable();
1398                 mcfrs_setsignals(info, 1, 1);
1399                 local_irq_enable();
1400                 current->state = TASK_INTERRUPTIBLE;
1401                 if (tty_hung_up_p(filp) ||
1402                     !(info->flags & ASYNC_INITIALIZED)) {
1403 #ifdef SERIAL_DO_RESTART
1404                         if (info->flags & ASYNC_HUP_NOTIFY)
1405                                 retval = -EAGAIN;
1406                         else
1407                                 retval = -ERESTARTSYS;  
1408 #else
1409                         retval = -EAGAIN;
1410 #endif
1411                         break;
1412                 }
1413                 if (!(info->flags & ASYNC_CLOSING) &&
1414                     (do_clocal || (mcfrs_getsignals(info) & TIOCM_CD)))
1415                         break;
1416                 if (signal_pending(current)) {
1417                         retval = -ERESTARTSYS;
1418                         break;
1419                 }
1420 #ifdef SERIAL_DEBUG_OPEN
1421                 printk("block_til_ready blocking: ttyS%d, count = %d\n",
1422                        info->line, info->count);
1423 #endif
1424                 schedule();
1425         }
1426         current->state = TASK_RUNNING;
1427         remove_wait_queue(&info->open_wait, &wait);
1428         if (!tty_hung_up_p(filp))
1429                 info->count++;
1430         info->blocked_open--;
1431 #ifdef SERIAL_DEBUG_OPEN
1432         printk("block_til_ready after blocking: ttyS%d, count = %d\n",
1433                info->line, info->count);
1434 #endif
1435         if (retval)
1436                 return retval;
1437         info->flags |= ASYNC_NORMAL_ACTIVE;
1438         return 0;
1439 }       
1440
1441 /*
1442  * This routine is called whenever a serial port is opened. It
1443  * enables interrupts for a serial port, linking in its structure into
1444  * the IRQ chain.   It also performs the serial-specific
1445  * initialization for the tty structure.
1446  */
1447 int mcfrs_open(struct tty_struct *tty, struct file * filp)
1448 {
1449         struct mcf_serial       *info;
1450         int                     retval, line;
1451
1452         line = tty->index;
1453         if ((line < 0) || (line >= NR_PORTS))
1454                 return -ENODEV;
1455         info = mcfrs_table + line;
1456         if (serial_paranoia_check(info, tty->name, "mcfrs_open"))
1457                 return -ENODEV;
1458 #ifdef SERIAL_DEBUG_OPEN
1459         printk("mcfrs_open %s, count = %d\n", tty->name, info->count);
1460 #endif
1461         info->count++;
1462         tty->driver_data = info;
1463         info->tty = tty;
1464
1465         /*
1466          * Start up serial port
1467          */
1468         retval = startup(info);
1469         if (retval)
1470                 return retval;
1471
1472         retval = block_til_ready(tty, filp, info);
1473         if (retval) {
1474 #ifdef SERIAL_DEBUG_OPEN
1475                 printk("mcfrs_open returning after block_til_ready with %d\n",
1476                        retval);
1477 #endif
1478                 return retval;
1479         }
1480
1481 #ifdef SERIAL_DEBUG_OPEN
1482         printk("mcfrs_open %s successful...\n", tty->name);
1483 #endif
1484         return 0;
1485 }
1486
1487 /*
1488  *      Based on the line number set up the internal interrupt stuff.
1489  */
1490 static void mcfrs_irqinit(struct mcf_serial *info)
1491 {
1492 #if defined(CONFIG_M5272)
1493         volatile unsigned long  *icrp;
1494         volatile unsigned long  *portp;
1495         volatile unsigned char  *uartp;
1496
1497         uartp = info->addr;
1498         icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR2);
1499
1500         switch (info->line) {
1501         case 0:
1502                 *icrp = 0xe0000000;
1503                 break;
1504         case 1:
1505                 *icrp = 0x0e000000;
1506                 break;
1507         default:
1508                 printk("MCFRS: don't know how to handle UART %d interrupt?\n",
1509                         info->line);
1510                 return;
1511         }
1512
1513         /* Enable the output lines for the serial ports */
1514         portp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_PBCNT);
1515         *portp = (*portp & ~0x000000ff) | 0x00000055;
1516         portp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_PDCNT);
1517         *portp = (*portp & ~0x000003fc) | 0x000002a8;
1518 #elif defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x)
1519         volatile unsigned char *icrp, *uartp;
1520         volatile unsigned long *imrp;
1521
1522         uartp = info->addr;
1523
1524         icrp = (volatile unsigned char *) (MCF_MBAR + MCFICM_INTC0 +
1525                 MCFINTC_ICR0 + MCFINT_UART0 + info->line);
1526         *icrp = 0x33; /* UART0 with level 6, priority 3 */
1527
1528         imrp = (volatile unsigned long *) (MCF_MBAR + MCFICM_INTC0 +
1529                 MCFINTC_IMRL);
1530         *imrp &= ~((1 << (info->irq - MCFINT_VECBASE)) | 1);
1531 #else
1532         volatile unsigned char  *icrp, *uartp;
1533
1534         switch (info->line) {
1535         case 0:
1536                 icrp = (volatile unsigned char *) (MCF_MBAR + MCFSIM_UART1ICR);
1537                 *icrp = /*MCFSIM_ICR_AUTOVEC |*/ MCFSIM_ICR_LEVEL6 |
1538                         MCFSIM_ICR_PRI1;
1539                 mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART1);
1540                 break;
1541         case 1:
1542                 icrp = (volatile unsigned char *) (MCF_MBAR + MCFSIM_UART2ICR);
1543                 *icrp = /*MCFSIM_ICR_AUTOVEC |*/ MCFSIM_ICR_LEVEL6 |
1544                         MCFSIM_ICR_PRI2;
1545                 mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART2);
1546                 break;
1547         default:
1548                 printk("MCFRS: don't know how to handle UART %d interrupt?\n",
1549                         info->line);
1550                 return;
1551         }
1552
1553         uartp = info->addr;
1554         uartp[MCFUART_UIVR] = info->irq;
1555 #endif
1556
1557         /* Clear mask, so no surprise interrupts. */
1558         uartp[MCFUART_UIMR] = 0;
1559
1560         if (request_irq(info->irq, mcfrs_interrupt, SA_INTERRUPT,
1561             "ColdFire UART", NULL)) {
1562                 printk("MCFRS: Unable to attach ColdFire UART %d interrupt "
1563                         "vector=%d\n", info->line, info->irq);
1564         }
1565
1566         return;
1567 }
1568
1569
1570 char *mcfrs_drivername = "ColdFire internal UART serial driver version 1.00\n";
1571
1572
1573 /*
1574  * Serial stats reporting...
1575  */
1576 int mcfrs_readproc(char *page, char **start, off_t off, int count,
1577                          int *eof, void *data)
1578 {
1579         struct mcf_serial       *info;
1580         char                    str[20];
1581         int                     len, sigs, i;
1582
1583         len = sprintf(page, mcfrs_drivername);
1584         for (i = 0; (i < NR_PORTS); i++) {
1585                 info = &mcfrs_table[i];
1586                 len += sprintf((page + len), "%d: port:%x irq=%d baud:%d ",
1587                         i, (unsigned int) info->addr, info->irq, info->baud);
1588                 if (info->stats.rx || info->stats.tx)
1589                         len += sprintf((page + len), "tx:%d rx:%d ",
1590                         info->stats.tx, info->stats.rx);
1591                 if (info->stats.rxframing)
1592                         len += sprintf((page + len), "fe:%d ",
1593                         info->stats.rxframing);
1594                 if (info->stats.rxparity)
1595                         len += sprintf((page + len), "pe:%d ",
1596                         info->stats.rxparity);
1597                 if (info->stats.rxbreak)
1598                         len += sprintf((page + len), "brk:%d ",
1599                         info->stats.rxbreak);
1600                 if (info->stats.rxoverrun)
1601                         len += sprintf((page + len), "oe:%d ",
1602                         info->stats.rxoverrun);
1603
1604                 str[0] = str[1] = 0;
1605                 if ((sigs = mcfrs_getsignals(info))) {
1606                         if (sigs & TIOCM_RTS)
1607                                 strcat(str, "|RTS");
1608                         if (sigs & TIOCM_CTS)
1609                                 strcat(str, "|CTS");
1610                         if (sigs & TIOCM_DTR)
1611                                 strcat(str, "|DTR");
1612                         if (sigs & TIOCM_CD)
1613                                 strcat(str, "|CD");
1614                 }
1615
1616                 len += sprintf((page + len), "%s\n", &str[1]);
1617         }
1618
1619         return(len);
1620 }
1621
1622
1623 /* Finally, routines used to initialize the serial driver. */
1624
1625 static void show_serial_version(void)
1626 {
1627         printk(mcfrs_drivername);
1628 }
1629
1630 static struct tty_operations mcfrs_ops = {
1631         .open = mcfrs_open,
1632         .close = mcfrs_close,
1633         .write = mcfrs_write,
1634         .flush_chars = mcfrs_flush_chars,
1635         .write_room = mcfrs_write_room,
1636         .chars_in_buffer = mcfrs_chars_in_buffer,
1637         .flush_buffer = mcfrs_flush_buffer,
1638         .ioctl = mcfrs_ioctl,
1639         .throttle = mcfrs_throttle,
1640         .unthrottle = mcfrs_unthrottle,
1641         .set_termios = mcfrs_set_termios,
1642         .stop = mcfrs_stop,
1643         .start = mcfrs_start,
1644         .hangup = mcfrs_hangup,
1645         .read_proc = mcfrs_readproc,
1646         .wait_until_sent = mcfrs_wait_until_sent,
1647         .tiocmget = mcfrs_tiocmget,
1648         .tiocmset = mcfrs_tiocmset,
1649 };
1650
1651 /* mcfrs_init inits the driver */
1652 static int __init
1653 mcfrs_init(void)
1654 {
1655         struct mcf_serial       *info;
1656         unsigned long           flags;
1657         int                     i;
1658
1659         /* Setup base handler, and timer table. */
1660 #ifdef MCFPP_DCD0
1661         init_timer(&mcfrs_timer_struct);
1662         mcfrs_timer_struct.function = mcfrs_timer;
1663         mcfrs_timer_struct.data = 0;
1664         mcfrs_timer_struct.expires = jiffies + HZ/25;
1665         add_timer(&mcfrs_timer_struct);
1666         mcfrs_ppstatus = mcf_getppdata() & (MCFPP_DCD0 | MCFPP_DCD1);
1667 #endif
1668         mcfrs_serial_driver = alloc_tty_driver(NR_PORTS);
1669         if (!mcfrs_serial_driver)
1670                 return -ENOMEM;
1671
1672         show_serial_version();
1673
1674         /* Initialize the tty_driver structure */
1675         mcfrs_serial_driver->owner = THIS_MODULE;
1676         mcfrs_serial_driver->name = "ttyS";
1677         mcfrs_serial_driver->devfs_name = "ttys/";
1678         mcfrs_serial_driver->driver_name = "serial";
1679         mcfrs_serial_driver->major = TTY_MAJOR;
1680         mcfrs_serial_driver->minor_start = 64;
1681         mcfrs_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
1682         mcfrs_serial_driver->subtype = SERIAL_TYPE_NORMAL;
1683         mcfrs_serial_driver->init_termios = tty_std_termios;
1684
1685         mcfrs_serial_driver->init_termios.c_cflag =
1686                 mcfrs_console_cbaud | CS8 | CREAD | HUPCL | CLOCAL;
1687         mcfrs_serial_driver->flags = TTY_DRIVER_REAL_RAW;
1688
1689         tty_set_operations(mcfrs_serial_driver, &mcfrs_ops);
1690
1691         if (tty_register_driver(mcfrs_serial_driver)) {
1692                 printk("MCFRS: Couldn't register serial driver\n");
1693                 put_tty_driver(mcfrs_serial_driver);
1694                 return(-EBUSY);
1695         }
1696
1697         local_irq_save(flags);
1698
1699         /*
1700          *      Configure all the attached serial ports.
1701          */
1702         for (i = 0, info = mcfrs_table; (i < NR_PORTS); i++, info++) {
1703                 info->magic = SERIAL_MAGIC;
1704                 info->line = i;
1705                 info->tty = 0;
1706                 info->custom_divisor = 16;
1707                 info->close_delay = 50;
1708                 info->closing_wait = 3000;
1709                 info->x_char = 0;
1710                 info->event = 0;
1711                 info->count = 0;
1712                 info->blocked_open = 0;
1713                 INIT_WORK(&info->tqueue, mcfrs_offintr, info);
1714                 INIT_WORK(&info->tqueue_hangup, do_serial_hangup, info);
1715                 init_waitqueue_head(&info->open_wait);
1716                 init_waitqueue_head(&info->close_wait);
1717
1718                 info->imr = 0;
1719                 mcfrs_setsignals(info, 0, 0);
1720                 mcfrs_irqinit(info);
1721
1722                 printk("ttyS%d at 0x%04x (irq = %d)", info->line,
1723                         (unsigned int) info->addr, info->irq);
1724                 printk(" is a builtin ColdFire UART\n");
1725         }
1726
1727         local_irq_restore(flags);
1728         return 0;
1729 }
1730
1731 module_init(mcfrs_init);
1732
1733 /****************************************************************************/
1734 /*                          Serial Console                                  */
1735 /****************************************************************************/
1736
1737 /*
1738  *      Quick and dirty UART initialization, for console output.
1739  */
1740
1741 void mcfrs_init_console(void)
1742 {
1743         volatile unsigned char  *uartp;
1744         unsigned int            clk;
1745
1746         /*
1747          *      Reset UART, get it into known state...
1748          */
1749         uartp = (volatile unsigned char *) (MCF_MBAR +
1750                 (mcfrs_console_port ? MCFUART_BASE2 : MCFUART_BASE1));
1751
1752         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETRX;  /* reset RX */
1753         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETTX;  /* reset TX */
1754         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETMRPTR;  /* reset MR pointer */
1755
1756         /*
1757          * Set port for defined baud , 8 data bits, 1 stop bit, no parity.
1758          */
1759         uartp[MCFUART_UMR] = MCFUART_MR1_PARITYNONE | MCFUART_MR1_CS8;
1760         uartp[MCFUART_UMR] = MCFUART_MR2_STOP1;
1761
1762         clk = ((MCF_BUSCLK / mcfrs_console_baud) + 16) / 32; /* set baud */
1763         uartp[MCFUART_UBG1] = (clk & 0xff00) >> 8;  /* set msb baud */
1764         uartp[MCFUART_UBG2] = (clk & 0xff);  /* set lsb baud */
1765
1766         uartp[MCFUART_UCSR] = MCFUART_UCSR_RXCLKTIMER | MCFUART_UCSR_TXCLKTIMER;
1767         uartp[MCFUART_UCR] = MCFUART_UCR_RXENABLE | MCFUART_UCR_TXENABLE;
1768
1769         mcfrs_console_inited++;
1770         return;
1771 }
1772
1773
1774 /*
1775  *      Setup for console. Argument comes from the boot command line.
1776  */
1777
1778 int mcfrs_console_setup(struct console *cp, char *arg)
1779 {
1780         int             i, n = CONSOLE_BAUD_RATE;
1781
1782         if (!cp)
1783                 return(-1);
1784
1785         if (!strncmp(cp->name, "ttyS", 4))
1786                 mcfrs_console_port = cp->index;
1787         else if (!strncmp(cp->name, "cua", 3))
1788                 mcfrs_console_port = cp->index;
1789         else
1790                 return(-1);
1791
1792         if (arg)
1793                 n = simple_strtoul(arg,NULL,0);
1794         for (i = 0; i < MCFRS_BAUD_TABLE_SIZE; i++)
1795                 if (mcfrs_baud_table[i] == n)
1796                         break;
1797         if (i < MCFRS_BAUD_TABLE_SIZE) {
1798                 mcfrs_console_baud = n;
1799                 mcfrs_console_cbaud = 0;
1800                 if (i > 15) {
1801                         mcfrs_console_cbaud |= CBAUDEX;
1802                         i -= 15;
1803                 }
1804                 mcfrs_console_cbaud |= i;
1805         }
1806         mcfrs_init_console(); /* make sure baud rate changes */
1807         return(0);
1808 }
1809
1810
1811 static struct tty_driver *mcfrs_console_device(struct console *c, int *index)
1812 {
1813         *index = c->index;
1814         return mcfrs_serial_driver;
1815 }
1816
1817
1818 /*
1819  *      Output a single character, using UART polled mode.
1820  *      This is used for console output.
1821  */
1822
1823 void mcfrs_put_char(char ch)
1824 {
1825         volatile unsigned char  *uartp;
1826         unsigned long           flags;
1827         int                     i;
1828
1829         uartp = (volatile unsigned char *) (MCF_MBAR +
1830                 (mcfrs_console_port ? MCFUART_BASE2 : MCFUART_BASE1));
1831
1832         local_irq_save(flags);
1833         for (i = 0; (i < 0x10000); i++) {
1834                 if (uartp[MCFUART_USR] & MCFUART_USR_TXREADY)
1835                         break;
1836         }
1837         if (i < 0x10000) {
1838                 uartp[MCFUART_UTB] = ch;
1839                 for (i = 0; (i < 0x10000); i++)
1840                         if (uartp[MCFUART_USR] & MCFUART_USR_TXEMPTY)
1841                                 break;
1842         }
1843         if (i >= 0x10000)
1844                 mcfrs_init_console(); /* try and get it back */
1845         local_irq_restore(flags);
1846
1847         return;
1848 }
1849
1850
1851 /*
1852  * rs_console_write is registered for printk output.
1853  */
1854
1855 void mcfrs_console_write(struct console *cp, const char *p, unsigned len)
1856 {
1857         if (!mcfrs_console_inited)
1858                 mcfrs_init_console();
1859         while (len-- > 0) {
1860                 if (*p == '\n')
1861                         mcfrs_put_char('\r');
1862                 mcfrs_put_char(*p++);
1863         }
1864 }
1865
1866 /*
1867  * declare our consoles
1868  */
1869
1870 struct console mcfrs_console = {
1871         .name           = "ttyS",
1872         .write          = mcfrs_console_write,
1873         .device         = mcfrs_console_device,
1874         .setup          = mcfrs_console_setup,
1875         .flags          = CON_PRINTBUFFER,
1876         .index          = -1,
1877 };
1878
1879 static int __init mcfrs_console_init(void)
1880 {
1881         register_console(&mcfrs_console);
1882         return 0;
1883 }
1884
1885 console_initcall(mcfrs_console_init);
1886
1887 /****************************************************************************/