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