git.oblomov.eu Git - linux-2.6/blob - drivers/serial/crisv10.c

   1 /* $Id: serial.c,v 1.25 2004/09/29 10:33:49 starvik Exp $
   2  *
   3  * Serial port driver for the ETRAX 100LX chip
   4  *
   5  *    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003  Axis Communications AB
   6  *
   7  *    Many, many authors. Based once upon a time on serial.c for 16x50.
   8  *
   9  * $Log: serial.c,v $
  10  * Revision 1.25  2004/09/29 10:33:49  starvik
  11  * Resolved a dealock when printing debug from kernel.
  12  *
  13  * Revision 1.24  2004/08/27 23:25:59  johana
  14  * rs_set_termios() must call change_speed() if c_iflag has changed or
  15  * automatic XOFF handling will be enabled and transmitter will stop
  16  * if 0x13 is received.
  17  *
  18  * Revision 1.23  2004/08/24 06:57:13  starvik
  19  * More whitespace cleanup
  20  *
  21  * Revision 1.22  2004/08/24 06:12:20  starvik
  22  * Whitespace cleanup
  23  *
  24  * Revision 1.20  2004/05/24 12:00:20  starvik
  25  * Big merge of stuff from Linux 2.4 (e.g. manual mode for the serial port).
  26  *
  27  * Revision 1.19  2004/05/17 13:12:15  starvik
  28  * Kernel console hook
  29  * Big merge from Linux 2.4 still pending.
  30  *
  31  * Revision 1.18  2003/10/28 07:18:30  starvik
  32  * Compiles with debug info
  33  *
  34  * Revision 1.17  2003/07/04 08:27:37  starvik
  35  * Merge of Linux 2.5.74
  36  *
  37  * Revision 1.16  2003/06/13 10:05:19  johana
  38  * Help the user to avoid trouble by:
  39  * Forcing mixed mode for status/control lines if not all pins are used.
  40  *
  41  * Revision 1.15  2003/06/13 09:43:01  johana
  42  * Merged in the following changes from os/linux/arch/cris/drivers/serial.c
  43  * + some minor changes to reduce diff.
  44  *
  45  * Revision 1.49  2003/05/30 11:31:54  johana
  46  * Merged in change-branch--serial9bit that adds CMSPAR support for sticky
  47  * parity (mark/space)
  48  *
  49  * Revision 1.48  2003/05/30 11:03:57  johana
  50  * Implemented rs_send_xchar() by disabling the DMA and writing manually.
  51  * Added e100_disable_txdma_channel() and e100_enable_txdma_channel().
  52  * Fixed rs_throttle() and rs_unthrottle() to properly call rs_send_xchar
  53  * instead of setting info->x_char and check the CRTSCTS flag before
  54  * controlling the rts pin.
  55  *
  56  * Revision 1.14  2003/04/09 08:12:44  pkj
  57  * Corrected typo changes made upstream.
  58  *
  59  * Revision 1.13  2003/04/09 05:20:47  starvik
  60  * Merge of Linux 2.5.67
  61  *
  62  * Revision 1.11  2003/01/22 06:48:37  starvik
  63  * Fixed warnings issued by GCC 3.2.1
  64  *
  65  * Revision 1.9  2002/12/13 09:07:47  starvik
  66  * Alert user that RX_TIMEOUT_TICKS==0 doesn't work
  67  *
  68  * Revision 1.8  2002/12/11 13:13:57  starvik
  69  * Added arch/ to v10 specific includes
  70  * Added fix from Linux 2.4 in serial.c (flush_to_flip_buffer)
  71  *
  72  * Revision 1.7  2002/12/06 07:13:57  starvik
  73  * Corrected work queue stuff
  74  * Removed CONFIG_ETRAX_SERIAL_FLUSH_DMA_FAST
  75  *
  76  * Revision 1.6  2002/11/21 07:17:46  starvik
  77  * Change static inline to extern inline where otherwise outlined with gcc-3.2
  78  *
  79  * Revision 1.5  2002/11/14 15:59:49  starvik
  80  * Linux 2.5 port of the latest serial driver from 2.4. The work queue stuff
  81  * probably doesn't work yet.
  82  *
  83  * Revision 1.42  2002/11/05 09:08:47  johana
  84  * Better implementation of rs_stop() and rs_start() that uses the XOFF
  85  * register to start/stop transmission.
  86  * change_speed() also initilises XOFF register correctly so that
  87  * auto_xoff is enabled when IXON flag is set by user.
  88  * This gives fast XOFF response times.
  89  *
  90  * Revision 1.41  2002/11/04 18:40:57  johana
  91  * Implemented rs_stop() and rs_start().
  92  * Simple tests using hwtestserial indicates that this should be enough
  93  * to make it work.
  94  *
  95  * Revision 1.40  2002/10/14 05:33:18  starvik
  96  * RS-485 uses fast timers even if SERIAL_FAST_TIMER is disabled
  97  *
  98  * Revision 1.39  2002/09/30 21:00:57  johana
  99  * Support for CONFIG_ETRAX_SERx_DTR_RI_DSR_CD_MIXED where the status and
 100  * control pins can be mixed between PA and PB.
 101  * If no serial port uses MIXED old solution is used
 102  * (saves a few bytes and cycles).
 103  * control_pins struct uses masks instead of bit numbers.
 104  * Corrected dummy values and polarity in line_info() so
 105  * /proc/tty/driver/serial is now correct.
 106  * (the E100_xxx_GET() macros is really active low - perhaps not obvious)
 107  *
 108  * Revision 1.38  2002/08/23 11:01:36  starvik
 109  * Check that serial port is enabled in all interrupt handlers to avoid
 110  * restarts of DMA channels not assigned to serial ports
 111  *
 112  * Revision 1.37  2002/08/13 13:02:37  bjornw
 113  * Removed some warnings because of unused code
 114  *
 115  * Revision 1.36  2002/08/08 12:50:01  starvik
 116  * Serial interrupt is shared with synchronous serial port driver
 117  *
 118  * Revision 1.35  2002/06/03 10:40:49  starvik
 119  * Increased RS-485 RTS toggle timer to 2 characters
 120  *
 121  * Revision 1.34  2002/05/28 18:59:36  johana
 122  * Whitespace and comment fixing to be more like etrax100ser.c 1.71.
 123  *
 124  * Revision 1.33  2002/05/28 17:55:43  johana
 125  * RS-485 uses FAST_TIMER if enabled, and starts a short (one char time)
 126  * timer from tranismit_chars (interrupt context).
 127  * The timer toggles RTS in interrupt context when expired giving minimum
 128  * latencies.
 129  *
 130  * Revision 1.32  2002/05/22 13:58:00  johana
 131  * Renamed rs_write() to raw_write() and made it inline.
 132  * New rs_write() handles RS-485 if configured and enabled
 133  * (moved code from e100_write_rs485()).
 134  * RS-485 ioctl's uses copy_from_user() instead of verify_area().
 135  *
 136  * Revision 1.31  2002/04/22 11:20:03  johana
 137  * Updated copyright years.
 138  *
 139  * Revision 1.30  2002/04/22 09:39:12  johana
 140  * RS-485 support compiles.
 141  *
 142  * Revision 1.29  2002/01/14 16:10:01  pkj
 143  * Allocate the receive buffers dynamically. The static 4kB buffer was
 144  * too small for the peaks. This means that we can get rid of the extra
 145  * buffer and the copying to it. It also means we require less memory
 146  * under normal operations, but can use more when needed (there is a
 147  * cap at 64kB for safety reasons). If there is no memory available
 148  * we panic(), and die a horrible death...
 149  *
 150  * Revision 1.28  2001/12/18 15:04:53  johana
 151  * Cleaned up write_rs485() - now it works correctly without padding extra
 152  * char.
 153  * Added sane default initialisation of rs485.
 154  * Added #ifdef around dummy variables.
 155  *
 156  * Revision 1.27  2001/11/29 17:00:41  pkj
 157  * 2kB seems to be too small a buffer when using 921600 bps,
 158  * so increase it to 4kB (this was already done for the elinux
 159  * version of the serial driver).
 160  *
 161  * Revision 1.26  2001/11/19 14:20:41  pkj
 162  * Minor changes to comments and unused code.
 163  *
 164  * Revision 1.25  2001/11/12 20:03:43  pkj
 165  * Fixed compiler warnings.
 166  *
 167  * Revision 1.24  2001/11/12 15:10:05  pkj
 168  * Total redesign of the receiving part of the serial driver.
 169  * Uses eight chained descriptors to write to a 4kB buffer.
 170  * This data is then serialised into a 2kB buffer. From there it
 171  * is copied into the TTY's flip buffers when they become available.
 172  * A lot of copying, and the sizes of the buffers might need to be
 173  * tweaked, but all in all it should work better than the previous
 174  * version, without the need to modify the TTY code in any way.
 175  * Also note that erroneous bytes are now correctly marked in the
 176  * flag buffers (instead of always marking the first byte).
 177  *
 178  * Revision 1.23  2001/10/30 17:53:26  pkj
 179  * * Set info->uses_dma to 0 when a port is closed.
 180  * * Mark the timer1 interrupt as a fast one (SA_INTERRUPT).
 181  * * Call start_flush_timer() in start_receive() if
 182  *   CONFIG_ETRAX_SERIAL_FLUSH_DMA_FAST is defined.
 183  *
 184  * Revision 1.22  2001/10/30 17:44:03  pkj
 185  * Use %lu for received and transmitted counters in line_info().
 186  *
 187  * Revision 1.21  2001/10/30 17:40:34  pkj
 188  * Clean-up. The only change to functionality is that
 189  * CONFIG_ETRAX_SERIAL_RX_TIMEOUT_TICKS(=5) is used instead of
 190  * MAX_FLUSH_TIME(=8).
 191  *
 192  * Revision 1.20  2001/10/30 15:24:49  johana
 193  * Added char_time stuff from 2.0 driver.
 194  *
 195  * Revision 1.19  2001/10/30 15:23:03  johana
 196  * Merged with 1.13.2 branch + fixed indentation
 197  * and changed CONFIG_ETRAX100_XYS to CONFIG_ETRAX_XYZ
 198  *
 199  * Revision 1.18  2001/09/24 09:27:22  pkj
 200  * Completed ext_baud_table[] in cflag_to_baud() and cflag_to_etrax_baud().
 201  *
 202  * Revision 1.17  2001/08/24 11:32:49  ronny
 203  * More fixes for the CONFIG_ETRAX_SERIAL_PORT0 define.
 204  *
 205  * Revision 1.16  2001/08/24 07:56:22  ronny
 206  * Added config ifdefs around ser0 irq requests.
 207  *
 208  * Revision 1.15  2001/08/16 09:10:31  bjarne
 209  * serial.c - corrected the initialization of rs_table, the wrong defines
 210  *            where used.
 211  *            Corrected a test in timed_flush_handler.
 212  *            Changed configured to enabled.
 213  * serial.h - Changed configured to enabled.
 214  *
 215  * Revision 1.14  2001/08/15 07:31:23  bjarne
 216  * Introduced two new members to the e100_serial struct.
 217  * configured - Will be set to 1 if the port has been configured in .config
 218  * uses_dma   - Should be set to 1 if the port uses DMA. Currently it is set
 219  *              to 1
 220  *              when a port is opened. This is used to limit the DMA interrupt
 221  *              routines to only manipulate DMA channels actually used by the
 222  *              serial driver.
 223  *
 224  * Revision 1.13.2.2  2001/10/17 13:57:13  starvik
 225  * Receiver was broken by the break fixes
 226  *
 227  * Revision 1.13.2.1  2001/07/20 13:57:39  ronny
 228  * Merge with new stuff from etrax100ser.c. Works but haven't checked stuff
 229  * like break handling.
 230  *
 231  * Revision 1.13  2001/05/09 12:40:31  johana
 232  * Use DMA_NBR and IRQ_NBR defines from dma.h and irq.h
 233  *
 234  * Revision 1.12  2001/04/19 12:23:07  bjornw
 235  * CONFIG_RS485 -> CONFIG_ETRAX_RS485
 236  *
 237  * Revision 1.11  2001/04/05 14:29:48  markusl
 238  * Updated according to review remarks i.e.
 239  * -Use correct types in port structure to avoid compiler warnings
 240  * -Try to use IO_* macros whenever possible
 241  * -Open should never return -EBUSY
 242  *
 243  * Revision 1.10  2001/03/05 13:14:07  bjornw
 244  * Another spelling fix
 245  *
 246  * Revision 1.9  2001/02/23 13:46:38  bjornw
 247  * Spellling check
 248  *
 249  * Revision 1.8  2001/01/23 14:56:35  markusl
 250  * Made use of ser1 optional
 251  * Needed by USB
 252  *
 253  * Revision 1.7  2001/01/19 16:14:48  perf
 254  * Added kernel options for serial ports 234.
 255  * Changed option names from CONFIG_ETRAX100_XYZ to CONFIG_ETRAX_XYZ.
 256  *
 257  * Revision 1.6  2000/11/22 16:36:09  bjornw
 258  * Please marketing by using the correct case when spelling Etrax.
 259  *
 260  * Revision 1.5  2000/11/21 16:43:37  bjornw
 261  * Fixed so it compiles under CONFIG_SVINTO_SIM
 262  *
 263  * Revision 1.4  2000/11/15 17:34:12  bjornw
 264  * Added a timeout timer for flushing input channels. The interrupt-based
 265  * fast flush system should be easy to merge with this later (works the same
 266  * way, only with an irq instead of a system timer_list)
 267  *
 268  * Revision 1.3  2000/11/13 17:19:57  bjornw
 269  * * Incredibly, this almost complete rewrite of serial.c worked (at least
 270  *   for output) the first time.
 271  *
 272  *   Items worth noticing:
 273  *
 274  *      No Etrax100 port 1 workarounds (does only compile on 2.4 anyway now)
 275  *      RS485 is not ported (why can't it be done in userspace as on x86 ?)
 276  *      Statistics done through async_icount - if any more stats are needed,
 277  *      that's the place to put them or in an arch-dep version of it.
 278  *      timeout_interrupt and the other fast timeout stuff not ported yet
 279  *      There be dragons in this 3k+ line driver
 280  *
 281  * Revision 1.2  2000/11/10 16:50:28  bjornw
 282  * First shot at a 2.4 port, does not compile totally yet
 283  *
 284  * Revision 1.1  2000/11/10 16:47:32  bjornw
 285  * Added verbatim copy of rev 1.49 etrax100ser.c from elinux
 286  *
 287  * Revision 1.49  2000/10/30 15:47:14  tobiasa
 288  * Changed version number.
 289  *
 290  * Revision 1.48  2000/10/25 11:02:43  johana
 291  * Changed %ul to %lu in printf's
 292  *
 293  * Revision 1.47  2000/10/18 15:06:53  pkj
 294  * Compile correctly with CONFIG_ETRAX_SERIAL_FLUSH_DMA_FAST and
 295  * CONFIG_ETRAX_SERIAL_PROC_ENTRY together.
 296  * Some clean-up of the /proc/serial file.
 297  *
 298  * Revision 1.46  2000/10/16 12:59:40  johana
 299  * Added CONFIG_ETRAX_SERIAL_PROC_ENTRY for statistics and debug info.
 300  *
 301  * Revision 1.45  2000/10/13 17:10:59  pkj
 302  * Do not flush DMAs while flipping TTY buffers.
 303  *
 304  * Revision 1.44  2000/10/13 16:34:29  pkj
 305  * Added a delay in ser_interrupt() for 2.3ms when an error is detected.
 306  * We do not know why this delay is required yet, but without it the
 307  * irmaflash program does not work (this was the program that needed
 308  * the ser_interrupt() to be needed in the first place). This should not
 309  * affect normal use of the serial ports.
 310  *
 311  * Revision 1.43  2000/10/13 16:30:44  pkj
 312  * New version of the fast flush of serial buffers code. This time
 313  * it is localized to the serial driver and uses a fast timer to
 314  * do the work.
 315  *
 316  * Revision 1.42  2000/10/13 14:54:26  bennyo
 317  * Fix for switching RTS when using rs485
 318  *
 319  * Revision 1.41  2000/10/12 11:43:44  pkj
 320  * Cleaned up a number of comments.
 321  *
 322  * Revision 1.40  2000/10/10 11:58:39  johana
 323  * Made RS485 support generic for all ports.
 324  * Toggle rts in interrupt if no delay wanted.
 325  * WARNING: No true transmitter empty check??
 326  * Set d_wait bit when sending data so interrupt is delayed until
 327  * fifo flushed. (Fix tcdrain() problem)
 328  *
 329  * Revision 1.39  2000/10/04 16:08:02  bjornw
 330  * * Use virt_to_phys etc. for DMA addresses
 331  * * Removed CONFIG_FLUSH_DMA_FAST hacks
 332  * * Indentation fix
 333  *
 334  * Revision 1.38  2000/10/02 12:27:10  mattias
 335  * * added variable used when using fast flush on serial dma.
 336  *   (CONFIG_FLUSH_DMA_FAST)
 337  *
 338  * Revision 1.37  2000/09/27 09:44:24  pkj
 339  * Uncomment definition of SERIAL_HANDLE_EARLY_ERRORS.
 340  *
 341  * Revision 1.36  2000/09/20 13:12:52  johana
 342  * Support for CONFIG_ETRAX_SERIAL_RX_TIMEOUT_TICKS:
 343  *   Number of timer ticks between flush of receive fifo (1 tick = 10ms).
 344  *   Try 0-3 for low latency applications. Approx 5 for high load
 345  *   applications (e.g. PPP). Maybe this should be more adaptive some day...
 346  *
 347  * Revision 1.35  2000/09/20 10:36:08  johana
 348  * Typo in get_lsr_info()
 349  *
 350  * Revision 1.34  2000/09/20 10:29:59  johana
 351  * Let rs_chars_in_buffer() check fifo content as well.
 352  * get_lsr_info() might work now (not tested).
 353  * Easier to change the port to debug.
 354  *
 355  * Revision 1.33  2000/09/13 07:52:11  torbjore
 356  * Support RS485
 357  *
 358  * Revision 1.32  2000/08/31 14:45:37  bjornw
 359  * After sending a break we need to reset the transmit DMA channel
 360  *
 361  * Revision 1.31  2000/06/21 12:13:29  johana
 362  * Fixed wait for all chars sent when closing port.
 363  * (Used to always take 1 second!)
 364  * Added shadows for directions of status/ctrl signals.
 365  *
 366  * Revision 1.30  2000/05/29 16:27:55  bjornw
 367  * Simulator ifdef moved a bit
 368  *
 369  * Revision 1.29  2000/05/09 09:40:30  mattias
 370  * * Added description of dma registers used in timeout_interrupt
 371  * * Removed old code
 372  *
 373  * Revision 1.28  2000/05/08 16:38:58  mattias
 374  * * Bugfix for flushing fifo in timeout_interrupt
 375  *   Problem occurs when bluetooth stack waits for a small number of bytes
 376  *   containing an event acknowledging free buffers in bluetooth HW
 377  *   As before, data was stuck in fifo until more data came on uart and
 378  *   flushed it up to the stack.
 379  *
 380  * Revision 1.27  2000/05/02 09:52:28  jonasd
 381  * Added fix for peculiar etrax behaviour when eop is forced on an empty
 382  * fifo. This is used when flashing the IRMA chip. Disabled by default.
 383  *
 384  * Revision 1.26  2000/03/29 15:32:02  bjornw
 385  * 2.0.34 updates
 386  *
 387  * Revision 1.25  2000/02/16 16:59:36  bjornw
 388  * * Receive DMA directly into the flip-buffer, eliminating an intermediary
 389  *   receive buffer and a memcpy. Will avoid some overruns.
 390  * * Error message on debug port if an overrun or flip buffer overrun occurs.
 391  * * Just use the first byte in the flag flip buffer for errors.
 392  * * Check for timeout on the serial ports only each 5/100 s, not 1/100.
 393  *
 394  * Revision 1.24  2000/02/09 18:02:28  bjornw
 395  * * Clear serial errors (overrun, framing, parity) correctly. Before, the
 396  *   receiver would get stuck if an error occurred and we did not restart
 397  *   the input DMA.
 398  * * Cosmetics (indentation, some code made into inlines)
 399  * * Some more debug options
 400  * * Actually shut down the serial port (DMA irq, DMA reset, receiver stop)
 401  *   when the last open is closed. Corresponding fixes in startup().
 402  * * rs_close() "tx FIFO wait" code moved into right place, bug & -> && fixed
 403  *   and make a special case out of port 1 (R_DMA_CHx_STATUS is broken for that)
 404  * * e100_disable_rx/enable_rx just disables/enables the receiver, not RTS
 405  *
 406  * Revision 1.23  2000/01/24 17:46:19  johana
 407  * Wait for flush of DMA/FIFO when closing port.
 408  *
 409  * Revision 1.22  2000/01/20 18:10:23  johana
 410  * Added TIOCMGET ioctl to return modem status.
 411  * Implemented modem status/control that works with the extra signals
 412  * (DTR, DSR, RI,CD) as well.
 413  * 3 different modes supported:
 414  * ser0 on PB (Bundy), ser1 on PB (Lisa) and ser2 on PA (Bundy)
 415  * Fixed DEF_TX value that caused the serial transmitter pin (txd) to go to 0 when
 416  * closing the last filehandle, NASTY!.
 417  * Added break generation, not tested though!
 418  * Use SA_SHIRQ when request_irq() for ser2 and ser3 (shared with) par0 and par1.
 419  * You can't use them at the same time (yet..), but you can hopefully switch
 420  * between ser2/par0, ser3/par1 with the same kernel config.
 421  * Replaced some magic constants with defines
 422  *
 423  *
 424  */
 425
 426 static char *serial_version = "$Revision: 1.25 $";
 427
 428 #include <linux/config.h>
 429 #include <linux/version.h>
 430
 431 #include <linux/types.h>
 432 #include <linux/errno.h>
 433 #include <linux/signal.h>
 434 #include <linux/sched.h>
 435 #include <linux/timer.h>
 436 #include <linux/interrupt.h>
 437 #include <linux/tty.h>
 438 #include <linux/tty_flip.h>
 439 #include <linux/major.h>
 440 #include <linux/string.h>
 441 #include <linux/fcntl.h>
 442 #include <linux/mm.h>
 443 #include <linux/slab.h>
 444 #include <linux/init.h>
 445 #include <asm/uaccess.h>
 446 #include <linux/kernel.h>
 447
 448 #include <asm/io.h>
 449 #include <asm/irq.h>
 450 #include <asm/system.h>
 451 #include <asm/segment.h>
 452 #include <asm/bitops.h>
 453 #include <linux/delay.h>
 454
 455 #include <asm/arch/svinto.h>
 456
 457 /* non-arch dependent serial structures are in linux/serial.h */
 458 #include <linux/serial.h>
 459 /* while we keep our own stuff (struct e100_serial) in a local .h file */
 460 #include "serial.h"
 461 #include <asm/fasttimer.h>
 462
 463 #ifdef CONFIG_ETRAX_SERIAL_FAST_TIMER
 464 #ifndef CONFIG_ETRAX_FAST_TIMER
 465 #error "Enable FAST_TIMER to use SERIAL_FAST_TIMER"
 466 #endif
 467 #endif
 468
 469 #if defined(CONFIG_ETRAX_SERIAL_RX_TIMEOUT_TICKS) && \
 470            (CONFIG_ETRAX_SERIAL_RX_TIMEOUT_TICKS == 0)
 471 #error "RX_TIMEOUT_TICKS == 0 not allowed, use 1"
 472 #endif
 473
 474 #if defined(CONFIG_ETRAX_RS485_ON_PA) && defined(CONFIG_ETRAX_RS485_ON_PORT_G)
 475 #error "Disable either CONFIG_ETRAX_RS485_ON_PA or CONFIG_ETRAX_RS485_ON_PORT_G"
 476 #endif
 477
 478 /*
 479  * All of the compatibilty code so we can compile serial.c against
 480  * older kernels is hidden in serial_compat.h
 481  */
 482 #if defined(LOCAL_HEADERS)
 483 #include "serial_compat.h"
 484 #endif
 485
 486 #define _INLINE_ inline
 487
 488 struct tty_driver *serial_driver;
 489
 490 /* serial subtype definitions */
 491 #ifndef SERIAL_TYPE_NORMAL
 492 #define SERIAL_TYPE_NORMAL      1
 493 #endif
 494
 495 /* number of characters left in xmit buffer before we ask for more */
 496 #define WAKEUP_CHARS 256
 497
 498 //#define SERIAL_DEBUG_INTR
 499 //#define SERIAL_DEBUG_OPEN
 500 //#define SERIAL_DEBUG_FLOW
 501 //#define SERIAL_DEBUG_DATA
 502 //#define SERIAL_DEBUG_THROTTLE
 503 //#define SERIAL_DEBUG_IO  /* Debug for Extra control and status pins */
 504 //#define SERIAL_DEBUG_LINE 0 /* What serport we want to debug */
 505
 506 /* Enable this to use serial interrupts to handle when you
 507    expect the first received event on the serial port to
 508    be an error, break or similar. Used to be able to flash IRMA
 509    from eLinux */
 510 #define SERIAL_HANDLE_EARLY_ERRORS
 511
 512 /* Defined and used in n_tty.c, but we need it here as well */
 513 #define TTY_THRESHOLD_THROTTLE 128
 514
 515 /* Due to buffersizes and threshold values, our SERIAL_DESCR_BUF_SIZE
 516  * must not be to high or flow control won't work if we leave it to the tty
 517  * layer so we have our own throttling in flush_to_flip
 518  * TTY_FLIPBUF_SIZE=512,
 519  * TTY_THRESHOLD_THROTTLE/UNTHROTTLE=128
 520  * BUF_SIZE can't be > 128
 521  */
 522 /* Currently 16 descriptors x 128 bytes = 2048 bytes */
 523 #define SERIAL_DESCR_BUF_SIZE 256
 524
 525 #define SERIAL_PRESCALE_BASE 3125000 /* 3.125MHz */
 526 #define DEF_BAUD_BASE SERIAL_PRESCALE_BASE
 527
 528 /* We don't want to load the system with massive fast timer interrupt
 529  * on high baudrates so limit it to 250 us (4kHz) */
 530 #define MIN_FLUSH_TIME_USEC 250
 531
 532 /* Add an x here to log a lot of timer stuff */
 533 #define TIMERD(x)
 534 /* Debug details of interrupt handling */
 535 #define DINTR1(x)  /* irq on/off, errors */
 536 #define DINTR2(x)    /* tx and rx */
 537 /* Debug flip buffer stuff */
 538 #define DFLIP(x)
 539 /* Debug flow control and overview of data flow */
 540 #define DFLOW(x)
 541 #define DBAUD(x)
 542 #define DLOG_INT_TRIG(x)
 543
 544 //#define DEBUG_LOG_INCLUDED
 545 #ifndef DEBUG_LOG_INCLUDED
 546 #define DEBUG_LOG(line, string, value)
 547 #else
 548 struct debug_log_info
 549 {
 550         unsigned long time;
 551         unsigned long timer_data;
 552 //  int line;
 553         const char *string;
 554         int value;
 555 };
 556 #define DEBUG_LOG_SIZE 4096
 557
 558 struct debug_log_info debug_log[DEBUG_LOG_SIZE];
 559 int debug_log_pos = 0;
 560
 561 #define DEBUG_LOG(_line, _string, _value) do { \
 562   if ((_line) == SERIAL_DEBUG_LINE) {\
 563     debug_log_func(_line, _string, _value); \
 564   }\
 565 }while(0)
 566
 567 void debug_log_func(int line, const char *string, int value)
 568 {
 569         if (debug_log_pos < DEBUG_LOG_SIZE) {
 570                 debug_log[debug_log_pos].time = jiffies;
 571                 debug_log[debug_log_pos].timer_data = *R_TIMER_DATA;
 572 //    debug_log[debug_log_pos].line = line;
 573                 debug_log[debug_log_pos].string = string;
 574                 debug_log[debug_log_pos].value = value;
 575                 debug_log_pos++;
 576         }
 577         /*printk(string, value);*/
 578 }
 579 #endif
 580
 581 #ifndef CONFIG_ETRAX_SERIAL_RX_TIMEOUT_TICKS
 582 /* Default number of timer ticks before flushing rx fifo
 583  * When using "little data, low latency applications: use 0
 584  * When using "much data applications (PPP)" use ~5
 585  */
 586 #define CONFIG_ETRAX_SERIAL_RX_TIMEOUT_TICKS 5
 587 #endif
 588
 589 unsigned long timer_data_to_ns(unsigned long timer_data);
 590
 591 static void change_speed(struct e100_serial *info);
 592 static void rs_throttle(struct tty_struct * tty);
 593 static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
 594 static int rs_write(struct tty_struct * tty, int from_user,
 595                     const unsigned char *buf, int count);
 596 extern _INLINE_ int rs_raw_write(struct tty_struct * tty, int from_user,
 597                             const unsigned char *buf, int count);
 598 #ifdef CONFIG_ETRAX_RS485
 599 static int e100_write_rs485(struct tty_struct * tty, int from_user,
 600                             const unsigned char *buf, int count);
 601 #endif
 602 static int get_lsr_info(struct e100_serial * info, unsigned int *value);
 603
 604
 605 #define DEF_BAUD 115200   /* 115.2 kbit/s */
 606 #define STD_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST)
 607 #define DEF_RX 0x20  /* or SERIAL_CTRL_W >> 8 */
 608 /* Default value of tx_ctrl register: has txd(bit 7)=1 (idle) as default */
 609 #define DEF_TX 0x80  /* or SERIAL_CTRL_B */
 610
 611 /* offsets from R_SERIALx_CTRL */
 612
 613 #define REG_DATA 0
 614 #define REG_DATA_STATUS32 0 /* this is the 32 bit register R_SERIALx_READ */
 615 #define REG_TR_DATA 0
 616 #define REG_STATUS 1
 617 #define REG_TR_CTRL 1
 618 #define REG_REC_CTRL 2
 619 #define REG_BAUD 3
 620 #define REG_XOFF 4  /* this is a 32 bit register */
 621
 622 /* The bitfields are the same for all serial ports */
 623 #define SER_RXD_MASK         IO_MASK(R_SERIAL0_STATUS, rxd)
 624 #define SER_DATA_AVAIL_MASK  IO_MASK(R_SERIAL0_STATUS, data_avail)
 625 #define SER_FRAMING_ERR_MASK IO_MASK(R_SERIAL0_STATUS, framing_err)
 626 #define SER_PAR_ERR_MASK     IO_MASK(R_SERIAL0_STATUS, par_err)
 627 #define SER_OVERRUN_MASK     IO_MASK(R_SERIAL0_STATUS, overrun)
 628
 629 #define SER_ERROR_MASK (SER_OVERRUN_MASK | SER_PAR_ERR_MASK | SER_FRAMING_ERR_MASK)
 630
 631 /* Values for info->errorcode */
 632 #define ERRCODE_SET_BREAK    (TTY_BREAK)
 633 #define ERRCODE_INSERT        0x100
 634 #define ERRCODE_INSERT_BREAK (ERRCODE_INSERT | TTY_BREAK)
 635
 636 #define FORCE_EOP(info)  *R_SET_EOP = 1U << info->iseteop;
 637
 638 /*
 639  * General note regarding the use of IO_* macros in this file:
 640  *
 641  * We will use the bits defined for DMA channel 6 when using various
 642  * IO_* macros (e.g. IO_STATE, IO_MASK, IO_EXTRACT) and _assume_ they are
 643  * the same for all channels (which of course they are).
 644  *
 645  * We will also use the bits defined for serial port 0 when writing commands
 646  * to the different ports, as these bits too are the same for all ports.
 647  */
 648
 649
 650 /* Mask for the irqs possibly enabled in R_IRQ_MASK1_RD etc. */
 651 static const unsigned long e100_ser_int_mask = 0
 652 #ifdef CONFIG_ETRAX_SERIAL_PORT0
 653 | IO_MASK(R_IRQ_MASK1_RD, ser0_data) | IO_MASK(R_IRQ_MASK1_RD, ser0_ready)
 654 #endif
 655 #ifdef CONFIG_ETRAX_SERIAL_PORT1
 656 | IO_MASK(R_IRQ_MASK1_RD, ser1_data) | IO_MASK(R_IRQ_MASK1_RD, ser1_ready)
 657 #endif
 658 #ifdef CONFIG_ETRAX_SERIAL_PORT2
 659 | IO_MASK(R_IRQ_MASK1_RD, ser2_data) | IO_MASK(R_IRQ_MASK1_RD, ser2_ready)
 660 #endif
 661 #ifdef CONFIG_ETRAX_SERIAL_PORT3
 662 | IO_MASK(R_IRQ_MASK1_RD, ser3_data) | IO_MASK(R_IRQ_MASK1_RD, ser3_ready)
 663 #endif
 664 ;
 665 unsigned long r_alt_ser_baudrate_shadow = 0;
 666
 667 /* this is the data for the four serial ports in the etrax100 */
 668 /*  DMA2(ser2), DMA4(ser3), DMA6(ser0) or DMA8(ser1) */
 669 /* R_DMA_CHx_CLR_INTR, R_DMA_CHx_FIRST, R_DMA_CHx_CMD */
 670
 671 static struct e100_serial rs_table[] = {
 672         { .baud        = DEF_BAUD,
 673           .port        = (unsigned char *)R_SERIAL0_CTRL,
 674           .irq         = 1U << 12, /* uses DMA 6 and 7 */
 675           .oclrintradr = R_DMA_CH6_CLR_INTR,
 676           .ofirstadr   = R_DMA_CH6_FIRST,
 677           .ocmdadr     = R_DMA_CH6_CMD,
 678           .ostatusadr  = R_DMA_CH6_STATUS,
 679           .iclrintradr = R_DMA_CH7_CLR_INTR,
 680           .ifirstadr   = R_DMA_CH7_FIRST,
 681           .icmdadr     = R_DMA_CH7_CMD,
 682           .idescradr   = R_DMA_CH7_DESCR,
 683           .flags       = STD_FLAGS,
 684           .rx_ctrl     = DEF_RX,
 685           .tx_ctrl     = DEF_TX,
 686           .iseteop     = 2,
 687 #ifdef CONFIG_ETRAX_SERIAL_PORT0
 688           .enabled  = 1,
 689 #ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA6_OUT
 690           .dma_out_enabled = 1,
 691 #else
 692           .dma_out_enabled = 0,
 693 #endif
 694 #ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA7_IN
 695           .dma_in_enabled = 1,
 696 #else
 697           .dma_in_enabled = 0
 698 #endif
 699 #else
 700           .enabled  = 0,
 701           .dma_out_enabled = 0,
 702           .dma_in_enabled = 0
 703 #endif
 704
 705 },  /* ttyS0 */
 706 #ifndef CONFIG_SVINTO_SIM
 707         { .baud        = DEF_BAUD,
 708           .port        = (unsigned char *)R_SERIAL1_CTRL,
 709           .irq         = 1U << 16, /* uses DMA 8 and 9 */
 710           .oclrintradr = R_DMA_CH8_CLR_INTR,
 711           .ofirstadr   = R_DMA_CH8_FIRST,
 712           .ocmdadr     = R_DMA_CH8_CMD,
 713           .ostatusadr  = R_DMA_CH8_STATUS,
 714           .iclrintradr = R_DMA_CH9_CLR_INTR,
 715           .ifirstadr   = R_DMA_CH9_FIRST,
 716           .icmdadr     = R_DMA_CH9_CMD,
 717           .idescradr   = R_DMA_CH9_DESCR,
 718           .flags       = STD_FLAGS,
 719           .rx_ctrl     = DEF_RX,
 720           .tx_ctrl     = DEF_TX,
 721           .iseteop     = 3,
 722 #ifdef CONFIG_ETRAX_SERIAL_PORT1
 723           .enabled  = 1,
 724 #ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA8_OUT
 725           .dma_out_enabled = 1,
 726 #else
 727           .dma_out_enabled = 0,
 728 #endif
 729 #ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA9_IN
 730           .dma_in_enabled = 1,
 731 #else
 732           .dma_in_enabled = 0
 733 #endif
 734 #else
 735           .enabled  = 0,
 736           .dma_out_enabled = 0,
 737           .dma_in_enabled = 0
 738 #endif
 739 },  /* ttyS1 */
 740
 741         { .baud        = DEF_BAUD,
 742           .port        = (unsigned char *)R_SERIAL2_CTRL,
 743           .irq         = 1U << 4,  /* uses DMA 2 and 3 */
 744           .oclrintradr = R_DMA_CH2_CLR_INTR,
 745           .ofirstadr   = R_DMA_CH2_FIRST,
 746           .ocmdadr     = R_DMA_CH2_CMD,
 747           .ostatusadr  = R_DMA_CH2_STATUS,
 748           .iclrintradr = R_DMA_CH3_CLR_INTR,
 749           .ifirstadr   = R_DMA_CH3_FIRST,
 750           .icmdadr     = R_DMA_CH3_CMD,
 751           .idescradr   = R_DMA_CH3_DESCR,
 752           .flags       = STD_FLAGS,
 753           .rx_ctrl     = DEF_RX,
 754           .tx_ctrl     = DEF_TX,
 755           .iseteop     = 0,
 756 #ifdef CONFIG_ETRAX_SERIAL_PORT2
 757           .enabled  = 1,
 758 #ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA2_OUT
 759           .dma_out_enabled = 1,
 760 #else
 761           .dma_out_enabled = 0,
 762 #endif
 763 #ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA3_IN
 764           .dma_in_enabled = 1,
 765 #else
 766           .dma_in_enabled = 0
 767 #endif
 768 #else
 769           .enabled  = 0,
 770           .dma_out_enabled = 0,
 771           .dma_in_enabled = 0
 772 #endif
 773  },  /* ttyS2 */
 774
 775         { .baud        = DEF_BAUD,
 776           .port        = (unsigned char *)R_SERIAL3_CTRL,
 777           .irq         = 1U << 8,  /* uses DMA 4 and 5 */
 778           .oclrintradr = R_DMA_CH4_CLR_INTR,
 779           .ofirstadr   = R_DMA_CH4_FIRST,
 780           .ocmdadr     = R_DMA_CH4_CMD,
 781           .ostatusadr  = R_DMA_CH4_STATUS,
 782           .iclrintradr = R_DMA_CH5_CLR_INTR,
 783           .ifirstadr   = R_DMA_CH5_FIRST,
 784           .icmdadr     = R_DMA_CH5_CMD,
 785           .idescradr   = R_DMA_CH5_DESCR,
 786           .flags       = STD_FLAGS,
 787           .rx_ctrl     = DEF_RX,
 788           .tx_ctrl     = DEF_TX,
 789           .iseteop     = 1,
 790 #ifdef CONFIG_ETRAX_SERIAL_PORT3
 791           .enabled  = 1,
 792 #ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA4_OUT
 793           .dma_out_enabled = 1,
 794 #else
 795           .dma_out_enabled = 0,
 796 #endif
 797 #ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA5_IN
 798           .dma_in_enabled = 1,
 799 #else
 800           .dma_in_enabled = 0
 801 #endif
 802 #else
 803           .enabled  = 0,
 804           .dma_out_enabled = 0,
 805           .dma_in_enabled = 0
 806 #endif
 807  }   /* ttyS3 */
 808 #endif
 809 };
 810
 811
 812 #define NR_PORTS (sizeof(rs_table)/sizeof(struct e100_serial))
 813
 814 static struct termios *serial_termios[NR_PORTS];
 815 static struct termios *serial_termios_locked[NR_PORTS];
 816 #ifdef CONFIG_ETRAX_SERIAL_FAST_TIMER
 817 static struct fast_timer fast_timers[NR_PORTS];
 818 #endif
 819
 820 #ifdef CONFIG_ETRAX_SERIAL_PROC_ENTRY
 821 #define PROCSTAT(x) x
 822 struct ser_statistics_type {
 823         int overrun_cnt;
 824         int early_errors_cnt;
 825         int ser_ints_ok_cnt;
 826         int errors_cnt;
 827         unsigned long int processing_flip;
 828         unsigned long processing_flip_still_room;
 829         unsigned long int timeout_flush_cnt;
 830         int rx_dma_ints;
 831         int tx_dma_ints;
 832         int rx_tot;
 833         int tx_tot;
 834 };
 835
 836 static struct ser_statistics_type ser_stat[NR_PORTS];
 837
 838 #else
 839
 840 #define PROCSTAT(x)
 841
 842 #endif /* CONFIG_ETRAX_SERIAL_PROC_ENTRY */
 843
 844 /* RS-485 */
 845 #if defined(CONFIG_ETRAX_RS485)
 846 #ifdef CONFIG_ETRAX_FAST_TIMER
 847 static struct fast_timer fast_timers_rs485[NR_PORTS];
 848 #endif
 849 #if defined(CONFIG_ETRAX_RS485_ON_PA)
 850 static int rs485_pa_bit = CONFIG_ETRAX_RS485_ON_PA_BIT;
 851 #endif
 852 #if defined(CONFIG_ETRAX_RS485_ON_PORT_G)
 853 static int rs485_port_g_bit = CONFIG_ETRAX_RS485_ON_PORT_G_BIT;
 854 #endif
 855 #endif
 856
 857 /* Info and macros needed for each ports extra control/status signals. */
 858 #define E100_STRUCT_PORT(line, pinname) \
 859  ((CONFIG_ETRAX_SER##line##_##pinname##_ON_PA_BIT >= 0)? \
 860                 (R_PORT_PA_DATA): ( \
 861  (CONFIG_ETRAX_SER##line##_##pinname##_ON_PB_BIT >= 0)? \
 862                 (R_PORT_PB_DATA):&dummy_ser[line]))
 863
 864 #define E100_STRUCT_SHADOW(line, pinname) \
 865  ((CONFIG_ETRAX_SER##line##_##pinname##_ON_PA_BIT >= 0)? \
 866                 (&port_pa_data_shadow): ( \
 867  (CONFIG_ETRAX_SER##line##_##pinname##_ON_PB_BIT >= 0)? \
 868                 (&port_pb_data_shadow):&dummy_ser[line]))
 869 #define E100_STRUCT_MASK(line, pinname) \
 870  ((CONFIG_ETRAX_SER##line##_##pinname##_ON_PA_BIT >= 0)? \
 871                 (1<<CONFIG_ETRAX_SER##line##_##pinname##_ON_PA_BIT): ( \
 872  (CONFIG_ETRAX_SER##line##_##pinname##_ON_PB_BIT >= 0)? \
 873                 (1<<CONFIG_ETRAX_SER##line##_##pinname##_ON_PB_BIT):DUMMY_##pinname##_MASK))
 874
 875 #define DUMMY_DTR_MASK 1
 876 #define DUMMY_RI_MASK  2
 877 #define DUMMY_DSR_MASK 4
 878 #define DUMMY_CD_MASK  8
 879 static unsigned char dummy_ser[NR_PORTS] = {0xFF, 0xFF, 0xFF,0xFF};
 880
 881 /* If not all status pins are used or disabled, use mixed mode */
 882 #ifdef CONFIG_ETRAX_SERIAL_PORT0
 883
 884 #define SER0_PA_BITSUM (CONFIG_ETRAX_SER0_DTR_ON_PA_BIT+CONFIG_ETRAX_SER0_RI_ON_PA_BIT+CONFIG_ETRAX_SER0_DSR_ON_PA_BIT+CONFIG_ETRAX_SER0_CD_ON_PA_BIT)
 885
 886 #if SER0_PA_BITSUM != -4
 887 #  if CONFIG_ETRAX_SER0_DTR_ON_PA_BIT == -1
 888 #    ifndef CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED
 889 #      define CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED 1
 890 #    endif
 891 #   endif
 892 # if CONFIG_ETRAX_SER0_RI_ON_PA_BIT == -1
 893 #   ifndef CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED
 894 #     define CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED 1
 895 #   endif
 896 #  endif
 897 #  if CONFIG_ETRAX_SER0_DSR_ON_PA_BIT == -1
 898 #    ifndef CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED
 899 #      define CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED 1
 900 #    endif
 901 #  endif
 902 #  if CONFIG_ETRAX_SER0_CD_ON_PA_BIT == -1
 903 #    ifndef CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED
 904 #      define CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED 1
 905 #    endif
 906 #  endif
 907 #endif
 908
 909 #define SER0_PB_BITSUM (CONFIG_ETRAX_SER0_DTR_ON_PB_BIT+CONFIG_ETRAX_SER0_RI_ON_PB_BIT+CONFIG_ETRAX_SER0_DSR_ON_PB_BIT+CONFIG_ETRAX_SER0_CD_ON_PB_BIT)
 910
 911 #if SER0_PB_BITSUM != -4
 912 #  if CONFIG_ETRAX_SER0_DTR_ON_PB_BIT == -1
 913 #    ifndef CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED
 914 #      define CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED 1
 915 #    endif
 916 #   endif
 917 # if CONFIG_ETRAX_SER0_RI_ON_PB_BIT == -1
 918 #   ifndef CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED
 919 #     define CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED 1
 920 #   endif
 921 #  endif
 922 #  if CONFIG_ETRAX_SER0_DSR_ON_PB_BIT == -1
 923 #    ifndef CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED
 924 #      define CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED 1
 925 #    endif
 926 #  endif
 927 #  if CONFIG_ETRAX_SER0_CD_ON_PB_BIT == -1
 928 #    ifndef CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED
 929 #      define CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED 1
 930 #    endif
 931 #  endif
 932 #endif
 933
 934 #endif /* PORT0 */
 935
 936
 937 #ifdef CONFIG_ETRAX_SERIAL_PORT1
 938
 939 #define SER1_PA_BITSUM (CONFIG_ETRAX_SER1_DTR_ON_PA_BIT+CONFIG_ETRAX_SER1_RI_ON_PA_BIT+CONFIG_ETRAX_SER1_DSR_ON_PA_BIT+CONFIG_ETRAX_SER1_CD_ON_PA_BIT)
 940
 941 #if SER1_PA_BITSUM != -4
 942 #  if CONFIG_ETRAX_SER1_DTR_ON_PA_BIT == -1
 943 #    ifndef CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED
 944 #      define CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED 1
 945 #    endif
 946 #   endif
 947 # if CONFIG_ETRAX_SER1_RI_ON_PA_BIT == -1
 948 #   ifndef CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED
 949 #     define CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED 1
 950 #   endif
 951 #  endif
 952 #  if CONFIG_ETRAX_SER1_DSR_ON_PA_BIT == -1
 953 #    ifndef CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED
 954 #      define CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED 1
 955 #    endif
 956 #  endif
 957 #  if CONFIG_ETRAX_SER1_CD_ON_PA_BIT == -1
 958 #    ifndef CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED
 959 #      define CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED 1
 960 #    endif
 961 #  endif
 962 #endif
 963
 964 #define SER1_PB_BITSUM (CONFIG_ETRAX_SER1_DTR_ON_PB_BIT+CONFIG_ETRAX_SER1_RI_ON_PB_BIT+CONFIG_ETRAX_SER1_DSR_ON_PB_BIT+CONFIG_ETRAX_SER1_CD_ON_PB_BIT)
 965
 966 #if SER1_PB_BITSUM != -4
 967 #  if CONFIG_ETRAX_SER1_DTR_ON_PB_BIT == -1
 968 #    ifndef CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED
 969 #      define CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED 1
 970 #    endif
 971 #   endif
 972 # if CONFIG_ETRAX_SER1_RI_ON_PB_BIT == -1
 973 #   ifndef CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED
 974 #     define CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED 1
 975 #   endif
 976 #  endif
 977 #  if CONFIG_ETRAX_SER1_DSR_ON_PB_BIT == -1
 978 #    ifndef CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED
 979 #      define CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED 1
 980 #    endif
 981 #  endif
 982 #  if CONFIG_ETRAX_SER1_CD_ON_PB_BIT == -1
 983 #    ifndef CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED
 984 #      define CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED 1
 985 #    endif
 986 #  endif
 987 #endif
 988
 989 #endif /* PORT1 */
 990
 991 #ifdef CONFIG_ETRAX_SERIAL_PORT2
 992
 993 #define SER2_PA_BITSUM (CONFIG_ETRAX_SER2_DTR_ON_PA_BIT+CONFIG_ETRAX_SER2_RI_ON_PA_BIT+CONFIG_ETRAX_SER2_DSR_ON_PA_BIT+CONFIG_ETRAX_SER2_CD_ON_PA_BIT)
 994
 995 #if SER2_PA_BITSUM != -4
 996 #  if CONFIG_ETRAX_SER2_DTR_ON_PA_BIT == -1
 997 #    ifndef CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED
 998 #      define CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED 1
 999 #    endif
1000 #   endif
1001 # if CONFIG_ETRAX_SER2_RI_ON_PA_BIT == -1
1002 #   ifndef CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED
1003 #     define CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED 1
1004 #   endif
1005 #  endif
1006 #  if CONFIG_ETRAX_SER2_DSR_ON_PA_BIT == -1
1007 #    ifndef CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED
1008 #      define CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED 1
1009 #    endif
1010 #  endif
1011 #  if CONFIG_ETRAX_SER2_CD_ON_PA_BIT == -1
1012 #    ifndef CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED
1013 #      define CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED 1
1014 #    endif
1015 #  endif
1016 #endif
1017
1018 #define SER2_PB_BITSUM (CONFIG_ETRAX_SER2_DTR_ON_PB_BIT+CONFIG_ETRAX_SER2_RI_ON_PB_BIT+CONFIG_ETRAX_SER2_DSR_ON_PB_BIT+CONFIG_ETRAX_SER2_CD_ON_PB_BIT)
1019
1020 #if SER2_PB_BITSUM != -4
1021 #  if CONFIG_ETRAX_SER2_DTR_ON_PB_BIT == -1
1022 #    ifndef CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED
1023 #      define CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED 1
1024 #    endif
1025 #   endif
1026 # if CONFIG_ETRAX_SER2_RI_ON_PB_BIT == -1
1027 #   ifndef CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED
1028 #     define CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED 1
1029 #   endif
1030 #  endif
1031 #  if CONFIG_ETRAX_SER2_DSR_ON_PB_BIT == -1
1032 #    ifndef CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED
1033 #      define CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED 1
1034 #    endif
1035 #  endif
1036 #  if CONFIG_ETRAX_SER2_CD_ON_PB_BIT == -1
1037 #    ifndef CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED
1038 #      define CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED 1
1039 #    endif
1040 #  endif
1041 #endif
1042
1043 #endif /* PORT2 */
1044
1045 #ifdef CONFIG_ETRAX_SERIAL_PORT3
1046
1047 #define SER3_PA_BITSUM (CONFIG_ETRAX_SER3_DTR_ON_PA_BIT+CONFIG_ETRAX_SER3_RI_ON_PA_BIT+CONFIG_ETRAX_SER3_DSR_ON_PA_BIT+CONFIG_ETRAX_SER3_CD_ON_PA_BIT)
1048
1049 #if SER3_PA_BITSUM != -4
1050 #  if CONFIG_ETRAX_SER3_DTR_ON_PA_BIT == -1
1051 #    ifndef CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED
1052 #      define CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED 1
1053 #    endif
1054 #   endif
1055 # if CONFIG_ETRAX_SER3_RI_ON_PA_BIT == -1
1056 #   ifndef CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED
1057 #     define CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED 1
1058 #   endif
1059 #  endif
1060 #  if CONFIG_ETRAX_SER3_DSR_ON_PA_BIT == -1
1061 #    ifndef CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED
1062 #      define CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED 1
1063 #    endif
1064 #  endif
1065 #  if CONFIG_ETRAX_SER3_CD_ON_PA_BIT == -1
1066 #    ifndef CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED
1067 #      define CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED 1
1068 #    endif
1069 #  endif
1070 #endif
1071
1072 #define SER3_PB_BITSUM (CONFIG_ETRAX_SER3_DTR_ON_PB_BIT+CONFIG_ETRAX_SER3_RI_ON_PB_BIT+CONFIG_ETRAX_SER3_DSR_ON_PB_BIT+CONFIG_ETRAX_SER3_CD_ON_PB_BIT)
1073
1074 #if SER3_PB_BITSUM != -4
1075 #  if CONFIG_ETRAX_SER3_DTR_ON_PB_BIT == -1
1076 #    ifndef CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED
1077 #      define CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED 1
1078 #    endif
1079 #   endif
1080 # if CONFIG_ETRAX_SER3_RI_ON_PB_BIT == -1
1081 #   ifndef CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED
1082 #     define CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED 1
1083 #   endif
1084 #  endif
1085 #  if CONFIG_ETRAX_SER3_DSR_ON_PB_BIT == -1
1086 #    ifndef CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED
1087 #      define CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED 1
1088 #    endif
1089 #  endif
1090 #  if CONFIG_ETRAX_SER3_CD_ON_PB_BIT == -1
1091 #    ifndef CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED
1092 #      define CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED 1
1093 #    endif
1094 #  endif
1095 #endif
1096
1097 #endif /* PORT3 */
1098
1099
1100 #if defined(CONFIG_ETRAX_SER0_DTR_RI_DSR_CD_MIXED) || \
1101     defined(CONFIG_ETRAX_SER1_DTR_RI_DSR_CD_MIXED) || \
1102     defined(CONFIG_ETRAX_SER2_DTR_RI_DSR_CD_MIXED) || \
1103     defined(CONFIG_ETRAX_SER3_DTR_RI_DSR_CD_MIXED)
1104 #define CONFIG_ETRAX_SERX_DTR_RI_DSR_CD_MIXED
1105 #endif
1106
1107 #ifdef CONFIG_ETRAX_SERX_DTR_RI_DSR_CD_MIXED
1108 /* The pins can be mixed on PA and PB */
1109 #define CONTROL_PINS_PORT_NOT_USED(line) \
1110   &dummy_ser[line], &dummy_ser[line], \
1111   &dummy_ser[line], &dummy_ser[line], \
1112   &dummy_ser[line], &dummy_ser[line], \
1113   &dummy_ser[line], &dummy_ser[line], \
1114   DUMMY_DTR_MASK, DUMMY_RI_MASK, DUMMY_DSR_MASK, DUMMY_CD_MASK
1115
1116
1117 struct control_pins
1118 {
1119         volatile unsigned char *dtr_port;
1120         unsigned char          *dtr_shadow;
1121         volatile unsigned char *ri_port;
1122         unsigned char          *ri_shadow;
1123         volatile unsigned char *dsr_port;
1124         unsigned char          *dsr_shadow;
1125         volatile unsigned char *cd_port;
1126         unsigned char          *cd_shadow;
1127
1128         unsigned char dtr_mask;
1129         unsigned char ri_mask;
1130         unsigned char dsr_mask;
1131         unsigned char cd_mask;
1132 };
1133
1134 static const struct control_pins e100_modem_pins[NR_PORTS] =
1135 {
1136         /* Ser 0 */
1137         {
1138 #ifdef CONFIG_ETRAX_SERIAL_PORT0
1139         E100_STRUCT_PORT(0,DTR), E100_STRUCT_SHADOW(0,DTR),
1140         E100_STRUCT_PORT(0,RI),  E100_STRUCT_SHADOW(0,RI),
1141         E100_STRUCT_PORT(0,DSR), E100_STRUCT_SHADOW(0,DSR),
1142         E100_STRUCT_PORT(0,CD),  E100_STRUCT_SHADOW(0,CD),
1143         E100_STRUCT_MASK(0,DTR),
1144         E100_STRUCT_MASK(0,RI),
1145         E100_STRUCT_MASK(0,DSR),
1146         E100_STRUCT_MASK(0,CD)
1147 #else
1148         CONTROL_PINS_PORT_NOT_USED(0)
1149 #endif
1150         },
1151
1152         /* Ser 1 */
1153         {
1154 #ifdef CONFIG_ETRAX_SERIAL_PORT1
1155         E100_STRUCT_PORT(1,DTR), E100_STRUCT_SHADOW(1,DTR),
1156         E100_STRUCT_PORT(1,RI),  E100_STRUCT_SHADOW(1,RI),
1157         E100_STRUCT_PORT(1,DSR), E100_STRUCT_SHADOW(1,DSR),
1158         E100_STRUCT_PORT(1,CD),  E100_STRUCT_SHADOW(1,CD),
1159         E100_STRUCT_MASK(1,DTR),
1160         E100_STRUCT_MASK(1,RI),
1161         E100_STRUCT_MASK(1,DSR),
1162         E100_STRUCT_MASK(1,CD)
1163 #else
1164         CONTROL_PINS_PORT_NOT_USED(1)
1165 #endif
1166         },
1167
1168         /* Ser 2 */
1169         {
1170 #ifdef CONFIG_ETRAX_SERIAL_PORT2
1171         E100_STRUCT_PORT(2,DTR), E100_STRUCT_SHADOW(2,DTR),
1172         E100_STRUCT_PORT(2,RI),  E100_STRUCT_SHADOW(2,RI),
1173         E100_STRUCT_PORT(2,DSR), E100_STRUCT_SHADOW(2,DSR),
1174         E100_STRUCT_PORT(2,CD),  E100_STRUCT_SHADOW(2,CD),
1175         E100_STRUCT_MASK(2,DTR),
1176         E100_STRUCT_MASK(2,RI),
1177         E100_STRUCT_MASK(2,DSR),
1178         E100_STRUCT_MASK(2,CD)
1179 #else
1180         CONTROL_PINS_PORT_NOT_USED(2)
1181 #endif
1182         },
1183
1184         /* Ser 3 */
1185         {
1186 #ifdef CONFIG_ETRAX_SERIAL_PORT3
1187         E100_STRUCT_PORT(3,DTR), E100_STRUCT_SHADOW(3,DTR),
1188         E100_STRUCT_PORT(3,RI),  E100_STRUCT_SHADOW(3,RI),
1189         E100_STRUCT_PORT(3,DSR), E100_STRUCT_SHADOW(3,DSR),
1190         E100_STRUCT_PORT(3,CD),  E100_STRUCT_SHADOW(3,CD),
1191         E100_STRUCT_MASK(3,DTR),
1192         E100_STRUCT_MASK(3,RI),
1193         E100_STRUCT_MASK(3,DSR),
1194         E100_STRUCT_MASK(3,CD)
1195 #else
1196         CONTROL_PINS_PORT_NOT_USED(3)
1197 #endif
1198         }
1199 };
1200 #else  /* CONFIG_ETRAX_SERX_DTR_RI_DSR_CD_MIXED */
1201
1202 /* All pins are on either PA or PB for each serial port */
1203 #define CONTROL_PINS_PORT_NOT_USED(line) \
1204   &dummy_ser[line], &dummy_ser[line], \
1205   DUMMY_DTR_MASK, DUMMY_RI_MASK, DUMMY_DSR_MASK, DUMMY_CD_MASK
1206
1207
1208 struct control_pins
1209 {
1210         volatile unsigned char *port;
1211         unsigned char          *shadow;
1212
1213         unsigned char dtr_mask;
1214         unsigned char ri_mask;
1215         unsigned char dsr_mask;
1216         unsigned char cd_mask;
1217 };
1218
1219 #define dtr_port port
1220 #define dtr_shadow shadow
1221 #define ri_port port
1222 #define ri_shadow shadow
1223 #define dsr_port port
1224 #define dsr_shadow shadow
1225 #define cd_port port
1226 #define cd_shadow shadow
1227
1228 static const struct control_pins e100_modem_pins[NR_PORTS] =
1229 {
1230         /* Ser 0 */
1231         {
1232 #ifdef CONFIG_ETRAX_SERIAL_PORT0
1233         E100_STRUCT_PORT(0,DTR), E100_STRUCT_SHADOW(0,DTR),
1234         E100_STRUCT_MASK(0,DTR),
1235         E100_STRUCT_MASK(0,RI),
1236         E100_STRUCT_MASK(0,DSR),
1237         E100_STRUCT_MASK(0,CD)
1238 #else
1239         CONTROL_PINS_PORT_NOT_USED(0)
1240 #endif
1241         },
1242
1243         /* Ser 1 */
1244         {
1245 #ifdef CONFIG_ETRAX_SERIAL_PORT1
1246         E100_STRUCT_PORT(1,DTR), E100_STRUCT_SHADOW(1,DTR),
1247         E100_STRUCT_MASK(1,DTR),
1248         E100_STRUCT_MASK(1,RI),
1249         E100_STRUCT_MASK(1,DSR),
1250         E100_STRUCT_MASK(1,CD)
1251 #else
1252         CONTROL_PINS_PORT_NOT_USED(1)
1253 #endif
1254         },
1255
1256         /* Ser 2 */
1257         {
1258 #ifdef CONFIG_ETRAX_SERIAL_PORT2
1259         E100_STRUCT_PORT(2,DTR), E100_STRUCT_SHADOW(2,DTR),
1260         E100_STRUCT_MASK(2,DTR),
1261         E100_STRUCT_MASK(2,RI),
1262         E100_STRUCT_MASK(2,DSR),
1263         E100_STRUCT_MASK(2,CD)
1264 #else
1265         CONTROL_PINS_PORT_NOT_USED(2)
1266 #endif
1267         },
1268
1269         /* Ser 3 */
1270         {
1271 #ifdef CONFIG_ETRAX_SERIAL_PORT3
1272         E100_STRUCT_PORT(3,DTR), E100_STRUCT_SHADOW(3,DTR),
1273         E100_STRUCT_MASK(3,DTR),
1274         E100_STRUCT_MASK(3,RI),
1275         E100_STRUCT_MASK(3,DSR),
1276         E100_STRUCT_MASK(3,CD)
1277 #else
1278         CONTROL_PINS_PORT_NOT_USED(3)
1279 #endif
1280         }
1281 };
1282 #endif /* !CONFIG_ETRAX_SERX_DTR_RI_DSR_CD_MIXED */
1283
1284 #define E100_RTS_MASK 0x20
1285 #define E100_CTS_MASK 0x40
1286
1287 /* All serial port signals are active low:
1288  * active   = 0 -> 3.3V to RS-232 driver -> -12V on RS-232 level
1289  * inactive = 1 -> 0V   to RS-232 driver -> +12V on RS-232 level
1290  *
1291  * These macros returns the pin value: 0=0V, >=1 = 3.3V on ETRAX chip
1292  */
1293
1294 /* Output */
1295 #define E100_RTS_GET(info) ((info)->rx_ctrl & E100_RTS_MASK)
1296 /* Input */
1297 #define E100_CTS_GET(info) ((info)->port[REG_STATUS] & E100_CTS_MASK)
1298
1299 /* These are typically PA or PB and 0 means 0V, 1 means 3.3V */
1300 /* Is an output */
1301 #define E100_DTR_GET(info) ((*e100_modem_pins[(info)->line].dtr_shadow) & e100_modem_pins[(info)->line].dtr_mask)
1302
1303 /* Normally inputs */
1304 #define E100_RI_GET(info) ((*e100_modem_pins[(info)->line].ri_port) & e100_modem_pins[(info)->line].ri_mask)
1305 #define E100_CD_GET(info) ((*e100_modem_pins[(info)->line].cd_port) & e100_modem_pins[(info)->line].cd_mask)
1306
1307 /* Input */
1308 #define E100_DSR_GET(info) ((*e100_modem_pins[(info)->line].dsr_port) & e100_modem_pins[(info)->line].dsr_mask)
1309
1310
1311 /*
1312  * tmp_buf is used as a temporary buffer by serial_write.  We need to
1313  * lock it in case the memcpy_fromfs blocks while swapping in a page,
1314  * and some other program tries to do a serial write at the same time.
1315  * Since the lock will only come under contention when the system is
1316  * swapping and available memory is low, it makes sense to share one
1317  * buffer across all the serial ports, since it significantly saves
1318  * memory if large numbers of serial ports are open.
1319  */
1320 static unsigned char *tmp_buf;
1321 #ifdef DECLARE_MUTEX
1322 static DECLARE_MUTEX(tmp_buf_sem);
1323 #else
1324 static struct semaphore tmp_buf_sem = MUTEX;
1325 #endif
1326
1327 /* Calculate the chartime depending on baudrate, numbor of bits etc. */
1328 static void update_char_time(struct e100_serial * info)
1329 {
1330         tcflag_t cflags = info->tty->termios->c_cflag;
1331         int bits;
1332
1333         /* calc. number of bits / data byte */
1334         /* databits + startbit and 1 stopbit */
1335         if ((cflags & CSIZE) == CS7)
1336                 bits = 9;
1337         else
1338                 bits = 10;
1339
1340         if (cflags & CSTOPB)     /* 2 stopbits ? */
1341                 bits++;
1342
1343         if (cflags & PARENB)     /* parity bit ? */
1344                 bits++;
1345
1346         /* calc timeout */
1347         info->char_time_usec = ((bits * 1000000) / info->baud) + 1;
1348         info->flush_time_usec = 4*info->char_time_usec;
1349         if (info->flush_time_usec < MIN_FLUSH_TIME_USEC)
1350                 info->flush_time_usec = MIN_FLUSH_TIME_USEC;
1351
1352 }
1353
1354 /*
1355  * This function maps from the Bxxxx defines in asm/termbits.h into real
1356  * baud rates.
1357  */
1358
1359 static int
1360 cflag_to_baud(unsigned int cflag)
1361 {
1362         static int baud_table[] = {
1363                 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400,
1364                 4800, 9600, 19200, 38400 };
1365
1366         static int ext_baud_table[] = {
1367                 0, 57600, 115200, 230400, 460800, 921600, 1843200, 6250000,
1368                 0, 0, 0, 0, 0, 0, 0, 0 };
1369
1370         if (cflag & CBAUDEX)
1371                 return ext_baud_table[(cflag & CBAUD) & ~CBAUDEX];
1372         else
1373                 return baud_table[cflag & CBAUD];
1374 }
1375
1376 /* and this maps to an etrax100 hardware baud constant */
1377
1378 static unsigned char
1379 cflag_to_etrax_baud(unsigned int cflag)
1380 {
1381         char retval;
1382
1383         static char baud_table[] = {
1384                 -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, 3, 4, 5, 6, 7 };
1385
1386         static char ext_baud_table[] = {
1387                 -1, 8, 9, 10, 11, 12, 13, 14, -1, -1, -1, -1, -1, -1, -1, -1 };
1388
1389         if (cflag & CBAUDEX)
1390                 retval = ext_baud_table[(cflag & CBAUD) & ~CBAUDEX];
1391         else
1392                 retval = baud_table[cflag & CBAUD];
1393
1394         if (retval < 0) {
1395                 printk(KERN_WARNING "serdriver tried setting invalid baud rate, flags %x.\n", cflag);
1396                 retval = 5; /* choose default 9600 instead */
1397         }
1398
1399         return retval | (retval << 4); /* choose same for both TX and RX */
1400 }
1401
1402
1403 /* Various static support functions */
1404
1405 /* Functions to set or clear DTR/RTS on the requested line */
1406 /* It is complicated by the fact that RTS is a serial port register, while
1407  * DTR might not be implemented in the HW at all, and if it is, it can be on
1408  * any general port.
1409  */
1410
1411
1412 static inline void
1413 e100_dtr(struct e100_serial *info, int set)
1414 {
1415 #ifndef CONFIG_SVINTO_SIM
1416         unsigned char mask = e100_modem_pins[info->line].dtr_mask;
1417
1418 #ifdef SERIAL_DEBUG_IO
1419         printk("ser%i dtr %i mask: 0x%02X\n", info->line, set, mask);
1420         printk("ser%i shadow before 0x%02X get: %i\n",
1421                info->line, *e100_modem_pins[info->line].dtr_shadow,
1422                E100_DTR_GET(info));
1423 #endif
1424         /* DTR is active low */
1425         {
1426                 unsigned long flags;
1427
1428                 save_flags(flags);
1429                 cli();
1430                 *e100_modem_pins[info->line].dtr_shadow &= ~mask;
1431                 *e100_modem_pins[info->line].dtr_shadow |= (set ? 0 : mask);
1432                 *e100_modem_pins[info->line].dtr_port = *e100_modem_pins[info->line].dtr_shadow;
1433                 restore_flags(flags);
1434         }
1435
1436 #ifdef SERIAL_DEBUG_IO
1437         printk("ser%i shadow after 0x%02X get: %i\n",
1438                info->line, *e100_modem_pins[info->line].dtr_shadow,
1439                E100_DTR_GET(info));
1440 #endif
1441 #endif
1442 }
1443
1444 /* set = 0 means 3.3V on the pin, bitvalue: 0=active, 1=inactive
1445  *                                          0=0V    , 1=3.3V
1446  */
1447 static inline void
1448 e100_rts(struct e100_serial *info, int set)
1449 {
1450 #ifndef CONFIG_SVINTO_SIM
1451         unsigned long flags;
1452         save_flags(flags);
1453         cli();
1454         info->rx_ctrl &= ~E100_RTS_MASK;
1455         info->rx_ctrl |= (set ? 0 : E100_RTS_MASK);  /* RTS is active low */
1456         info->port[REG_REC_CTRL] = info->rx_ctrl;
1457         restore_flags(flags);
1458 #ifdef SERIAL_DEBUG_IO
1459         printk("ser%i rts %i\n", info->line, set);
1460 #endif
1461 #endif
1462 }
1463
1464
1465 /* If this behaves as a modem, RI and CD is an output */
1466 static inline void
1467 e100_ri_out(struct e100_serial *info, int set)
1468 {
1469 #ifndef CONFIG_SVINTO_SIM
1470         /* RI is active low */
1471         {
1472                 unsigned char mask = e100_modem_pins[info->line].ri_mask;
1473                 unsigned long flags;
1474
1475                 save_flags(flags);
1476                 cli();
1477                 *e100_modem_pins[info->line].ri_shadow &= ~mask;
1478                 *e100_modem_pins[info->line].ri_shadow |= (set ? 0 : mask);
1479                 *e100_modem_pins[info->line].ri_port = *e100_modem_pins[info->line].ri_shadow;
1480                 restore_flags(flags);
1481         }
1482 #endif
1483 }
1484 static inline void
1485 e100_cd_out(struct e100_serial *info, int set)
1486 {
1487 #ifndef CONFIG_SVINTO_SIM
1488         /* CD is active low */
1489         {
1490                 unsigned char mask = e100_modem_pins[info->line].cd_mask;
1491                 unsigned long flags;
1492
1493                 save_flags(flags);
1494                 cli();
1495                 *e100_modem_pins[info->line].cd_shadow &= ~mask;
1496                 *e100_modem_pins[info->line].cd_shadow |= (set ? 0 : mask);
1497                 *e100_modem_pins[info->line].cd_port = *e100_modem_pins[info->line].cd_shadow;
1498                 restore_flags(flags);
1499         }
1500 #endif
1501 }
1502
1503 static inline void
1504 e100_disable_rx(struct e100_serial *info)
1505 {
1506 #ifndef CONFIG_SVINTO_SIM
1507         /* disable the receiver */
1508         info->port[REG_REC_CTRL] =
1509                 (info->rx_ctrl &= ~IO_MASK(R_SERIAL0_REC_CTRL, rec_enable));
1510 #endif
1511 }
1512
1513 static inline void
1514 e100_enable_rx(struct e100_serial *info)
1515 {
1516 #ifndef CONFIG_SVINTO_SIM
1517         /* enable the receiver */
1518         info->port[REG_REC_CTRL] =
1519                 (info->rx_ctrl |= IO_MASK(R_SERIAL0_REC_CTRL, rec_enable));
1520 #endif
1521 }
1522
1523 /* the rx DMA uses both the dma_descr and the dma_eop interrupts */
1524
1525 static inline void
1526 e100_disable_rxdma_irq(struct e100_serial *info)
1527 {
1528 #ifdef SERIAL_DEBUG_INTR
1529         printk("rxdma_irq(%d): 0\n",info->line);
1530 #endif
1531         DINTR1(DEBUG_LOG(info->line,"IRQ disable_rxdma_irq %i\n", info->line));
1532         *R_IRQ_MASK2_CLR = (info->irq << 2) | (info->irq << 3);
1533 }
1534
1535 static inline void
1536 e100_enable_rxdma_irq(struct e100_serial *info)
1537 {
1538 #ifdef SERIAL_DEBUG_INTR
1539         printk("rxdma_irq(%d): 1\n",info->line);
1540 #endif
1541         DINTR1(DEBUG_LOG(info->line,"IRQ enable_rxdma_irq %i\n", info->line));
1542         *R_IRQ_MASK2_SET = (info->irq << 2) | (info->irq << 3);
1543 }
1544
1545 /* the tx DMA uses only dma_descr interrupt */
1546
1547 static _INLINE_ void
1548 e100_disable_txdma_irq(struct e100_serial *info)
1549 {
1550 #ifdef SERIAL_DEBUG_INTR
1551         printk("txdma_irq(%d): 0\n",info->line);
1552 #endif
1553         DINTR1(DEBUG_LOG(info->line,"IRQ disable_txdma_irq %i\n", info->line));
1554         *R_IRQ_MASK2_CLR = info->irq;
1555 }
1556
1557 static _INLINE_ void
1558 e100_enable_txdma_irq(struct e100_serial *info)
1559 {
1560 #ifdef SERIAL_DEBUG_INTR
1561         printk("txdma_irq(%d): 1\n",info->line);
1562 #endif
1563         DINTR1(DEBUG_LOG(info->line,"IRQ enable_txdma_irq %i\n", info->line));
1564         *R_IRQ_MASK2_SET = info->irq;
1565 }
1566
1567 static _INLINE_ void
1568 e100_disable_txdma_channel(struct e100_serial *info)
1569 {
1570         unsigned long flags;
1571
1572         /* Disable output DMA channel for the serial port in question
1573          * ( set to something other then serialX)
1574          */
1575         save_flags(flags);
1576         cli();
1577         DFLOW(DEBUG_LOG(info->line, "disable_txdma_channel %i\n", info->line));
1578         if (info->line == 0) {
1579                 if ((genconfig_shadow & IO_MASK(R_GEN_CONFIG, dma6)) ==
1580                     IO_STATE(R_GEN_CONFIG, dma6, serial0)) {
1581                         genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma6);
1582                         genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma6, unused);
1583                 }
1584         } else if (info->line == 1) {
1585                 if ((genconfig_shadow & IO_MASK(R_GEN_CONFIG, dma8)) ==
1586                     IO_STATE(R_GEN_CONFIG, dma8, serial1)) {
1587                         genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma8);
1588                         genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma8, usb);
1589                 }
1590         } else if (info->line == 2) {
1591                 if ((genconfig_shadow & IO_MASK(R_GEN_CONFIG, dma2)) ==
1592                     IO_STATE(R_GEN_CONFIG, dma2, serial2)) {
1593                         genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma2);
1594                         genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma2, par0);
1595                 }
1596         } else if (info->line == 3) {
1597                 if ((genconfig_shadow & IO_MASK(R_GEN_CONFIG, dma4)) ==
1598                     IO_STATE(R_GEN_CONFIG, dma4, serial3)) {
1599                         genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma4);
1600                         genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma4, par1);
1601                 }
1602         }
1603         *R_GEN_CONFIG = genconfig_shadow;
1604         restore_flags(flags);
1605 }
1606
1607
1608 static _INLINE_ void
1609 e100_enable_txdma_channel(struct e100_serial *info)
1610 {
1611         unsigned long flags;
1612
1613         save_flags(flags);
1614         cli();
1615         DFLOW(DEBUG_LOG(info->line, "enable_txdma_channel %i\n", info->line));
1616         /* Enable output DMA channel for the serial port in question */
1617         if (info->line == 0) {
1618                 genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma6);
1619                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma6, serial0);
1620         } else if (info->line == 1) {
1621                 genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma8);
1622                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma8, serial1);
1623         } else if (info->line == 2) {
1624                 genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma2);
1625                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma2, serial2);
1626         } else if (info->line == 3) {
1627                 genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma4);
1628                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma4, serial3);
1629         }
1630         *R_GEN_CONFIG = genconfig_shadow;
1631         restore_flags(flags);
1632 }
1633
1634 static _INLINE_ void
1635 e100_disable_rxdma_channel(struct e100_serial *info)
1636 {
1637         unsigned long flags;
1638
1639         /* Disable input DMA channel for the serial port in question
1640          * ( set to something other then serialX)
1641          */
1642         save_flags(flags);
1643         cli();
1644         if (info->line == 0) {
1645                 if ((genconfig_shadow & IO_MASK(R_GEN_CONFIG, dma7)) ==
1646                     IO_STATE(R_GEN_CONFIG, dma7, serial0)) {
1647                         genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma7);
1648                         genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma7, unused);
1649                 }
1650         } else if (info->line == 1) {
1651                 if ((genconfig_shadow & IO_MASK(R_GEN_CONFIG, dma9)) ==
1652                     IO_STATE(R_GEN_CONFIG, dma9, serial1)) {
1653                         genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma9);
1654                         genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma9, usb);
1655                 }
1656         } else if (info->line == 2) {
1657                 if ((genconfig_shadow & IO_MASK(R_GEN_CONFIG, dma3)) ==
1658                     IO_STATE(R_GEN_CONFIG, dma3, serial2)) {
1659                         genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma3);
1660                         genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma3, par0);
1661                 }
1662         } else if (info->line == 3) {
1663                 if ((genconfig_shadow & IO_MASK(R_GEN_CONFIG, dma5)) ==
1664                     IO_STATE(R_GEN_CONFIG, dma5, serial3)) {
1665                         genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma5);
1666                         genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma5, par1);
1667                 }
1668         }
1669         *R_GEN_CONFIG = genconfig_shadow;
1670         restore_flags(flags);
1671 }
1672
1673
1674 static _INLINE_ void
1675 e100_enable_rxdma_channel(struct e100_serial *info)
1676 {
1677         unsigned long flags;
1678
1679         save_flags(flags);
1680         cli();
1681         /* Enable input DMA channel for the serial port in question */
1682         if (info->line == 0) {
1683                 genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma7);
1684                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma7, serial0);
1685         } else if (info->line == 1) {
1686                 genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma9);
1687                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma9, serial1);
1688         } else if (info->line == 2) {
1689                 genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma3);
1690                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma3, serial2);
1691         } else if (info->line == 3) {
1692                 genconfig_shadow &=  ~IO_MASK(R_GEN_CONFIG, dma5);
1693                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma5, serial3);
1694         }
1695         *R_GEN_CONFIG = genconfig_shadow;
1696         restore_flags(flags);
1697 }
1698
1699 #ifdef SERIAL_HANDLE_EARLY_ERRORS
1700 /* in order to detect and fix errors on the first byte
1701    we have to use the serial interrupts as well. */
1702
1703 static inline void
1704 e100_disable_serial_data_irq(struct e100_serial *info)
1705 {
1706 #ifdef SERIAL_DEBUG_INTR
1707         printk("ser_irq(%d): 0\n",info->line);
1708 #endif
1709         DINTR1(DEBUG_LOG(info->line,"IRQ disable data_irq %i\n", info->line));
1710         *R_IRQ_MASK1_CLR = (1U << (8+2*info->line));
1711 }
1712
1713 static inline void
1714 e100_enable_serial_data_irq(struct e100_serial *info)
1715 {
1716 #ifdef SERIAL_DEBUG_INTR
1717         printk("ser_irq(%d): 1\n",info->line);
1718         printk("**** %d = %d\n",
1719                (8+2*info->line),
1720                (1U << (8+2*info->line)));
1721 #endif
1722         DINTR1(DEBUG_LOG(info->line,"IRQ enable data_irq %i\n", info->line));
1723         *R_IRQ_MASK1_SET = (1U << (8+2*info->line));
1724 }
1725 #endif
1726
1727 static inline void
1728 e100_disable_serial_tx_ready_irq(struct e100_serial *info)
1729 {
1730 #ifdef SERIAL_DEBUG_INTR
1731         printk("ser_tx_irq(%d): 0\n",info->line);
1732 #endif
1733         DINTR1(DEBUG_LOG(info->line,"IRQ disable ready_irq %i\n", info->line));
1734         *R_IRQ_MASK1_CLR = (1U << (8+1+2*info->line));
1735 }
1736
1737 static inline void
1738 e100_enable_serial_tx_ready_irq(struct e100_serial *info)
1739 {
1740 #ifdef SERIAL_DEBUG_INTR
1741         printk("ser_tx_irq(%d): 1\n",info->line);
1742         printk("**** %d = %d\n",
1743                (8+1+2*info->line),
1744                (1U << (8+1+2*info->line)));
1745 #endif
1746         DINTR2(DEBUG_LOG(info->line,"IRQ enable ready_irq %i\n", info->line));
1747         *R_IRQ_MASK1_SET = (1U << (8+1+2*info->line));
1748 }
1749
1750 static inline void e100_enable_rx_irq(struct e100_serial *info)
1751 {
1752         if (info->uses_dma_in)
1753                 e100_enable_rxdma_irq(info);
1754         else
1755                 e100_enable_serial_data_irq(info);
1756 }
1757 static inline void e100_disable_rx_irq(struct e100_serial *info)
1758 {
1759         if (info->uses_dma_in)
1760                 e100_disable_rxdma_irq(info);
1761         else
1762                 e100_disable_serial_data_irq(info);
1763 }
1764
1765 #if defined(CONFIG_ETRAX_RS485)
1766 /* Enable RS-485 mode on selected port. This is UGLY. */
1767 static int
1768 e100_enable_rs485(struct tty_struct *tty,struct rs485_control *r)
1769 {
1770         struct e100_serial * info = (struct e100_serial *)tty->driver_data;
1771
1772 #if defined(CONFIG_ETRAX_RS485_ON_PA)
1773         *R_PORT_PA_DATA = port_pa_data_shadow |= (1 << rs485_pa_bit);
1774 #endif
1775 #if defined(CONFIG_ETRAX_RS485_ON_PORT_G)
1776         REG_SHADOW_SET(R_PORT_G_DATA,  port_g_data_shadow,
1777                        rs485_port_g_bit, 1);
1778 #endif
1779 #if defined(CONFIG_ETRAX_RS485_LTC1387)
1780         REG_SHADOW_SET(R_PORT_G_DATA, port_g_data_shadow,
1781                        CONFIG_ETRAX_RS485_LTC1387_DXEN_PORT_G_BIT, 1);
1782         REG_SHADOW_SET(R_PORT_G_DATA, port_g_data_shadow,
1783                        CONFIG_ETRAX_RS485_LTC1387_RXEN_PORT_G_BIT, 1);
1784 #endif
1785
1786         info->rs485.rts_on_send = 0x01 & r->rts_on_send;
1787         info->rs485.rts_after_sent = 0x01 & r->rts_after_sent;
1788         if (r->delay_rts_before_send >= 1000)
1789                 info->rs485.delay_rts_before_send = 1000;
1790         else
1791                 info->rs485.delay_rts_before_send = r->delay_rts_before_send;
1792         info->rs485.enabled = r->enabled;
1793 /*      printk("rts: on send = %i, after = %i, enabled = %i",
1794                     info->rs485.rts_on_send,
1795                     info->rs485.rts_after_sent,
1796                     info->rs485.enabled
1797         );
1798 */
1799         return 0;
1800 }
1801
1802 static int
1803 e100_write_rs485(struct tty_struct *tty, int from_user,
1804                  const unsigned char *buf, int count)
1805 {
1806         struct e100_serial * info = (struct e100_serial *)tty->driver_data;
1807         int old_enabled = info->rs485.enabled;
1808
1809         /* rs485 is always implicitly enabled if we're using the ioctl()
1810          * but it doesn't have to be set in the rs485_control
1811          * (to be backward compatible with old apps)
1812          * So we store, set and restore it.
1813          */
1814         info->rs485.enabled = 1;
1815         /* rs_write now deals with RS485 if enabled */
1816         count = rs_write(tty, from_user, buf, count);
1817         info->rs485.enabled = old_enabled;
1818         return count;
1819 }
1820
1821 #ifdef CONFIG_ETRAX_FAST_TIMER
1822 /* Timer function to toggle RTS when using FAST_TIMER */
1823 static void rs485_toggle_rts_timer_function(unsigned long data)
1824 {
1825         struct e100_serial *info = (struct e100_serial *)data;
1826
1827         fast_timers_rs485[info->line].function = NULL;
1828         e100_rts(info, info->rs485.rts_after_sent);
1829 #if defined(CONFIG_ETRAX_RS485_DISABLE_RECEIVER)
1830         e100_enable_rx(info);
1831         e100_enable_rx_irq(info);
1832 #endif
1833 }
1834 #endif
1835 #endif /* CONFIG_ETRAX_RS485 */
1836
1837 /*
1838  * ------------------------------------------------------------
1839  * rs_stop() and rs_start()
1840  *
1841  * This routines are called before setting or resetting tty->stopped.
1842  * They enable or disable transmitter using the XOFF registers, as necessary.
1843  * ------------------------------------------------------------
1844  */
1845
1846 static void
1847 rs_stop(struct tty_struct *tty)
1848 {
1849         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
1850         if (info) {
1851                 unsigned long flags;
1852                 unsigned long xoff;
1853
1854                 save_flags(flags); cli();
1855                 DFLOW(DEBUG_LOG(info->line, "XOFF rs_stop xmit %i\n",
1856                                 CIRC_CNT(info->xmit.head,
1857                                          info->xmit.tail,SERIAL_XMIT_SIZE)));
1858
1859                 xoff = IO_FIELD(R_SERIAL0_XOFF, xoff_char, STOP_CHAR(info->tty));
1860                 xoff |= IO_STATE(R_SERIAL0_XOFF, tx_stop, stop);
1861                 if (tty->termios->c_iflag & IXON ) {
1862                         xoff |= IO_STATE(R_SERIAL0_XOFF, auto_xoff, enable);
1863                 }
1864
1865                 *((unsigned long *)&info->port[REG_XOFF]) = xoff;
1866                 restore_flags(flags);
1867         }
1868 }
1869
1870 static void
1871 rs_start(struct tty_struct *tty)
1872 {
1873         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
1874         if (info) {
1875                 unsigned long flags;
1876                 unsigned long xoff;
1877
1878                 save_flags(flags); cli();
1879                 DFLOW(DEBUG_LOG(info->line, "XOFF rs_start xmit %i\n",
1880                                 CIRC_CNT(info->xmit.head,
1881                                          info->xmit.tail,SERIAL_XMIT_SIZE)));
1882                 xoff = IO_FIELD(R_SERIAL0_XOFF, xoff_char, STOP_CHAR(tty));
1883                 xoff |= IO_STATE(R_SERIAL0_XOFF, tx_stop, enable);
1884                 if (tty->termios->c_iflag & IXON ) {
1885                         xoff |= IO_STATE(R_SERIAL0_XOFF, auto_xoff, enable);
1886                 }
1887
1888                 *((unsigned long *)&info->port[REG_XOFF]) = xoff;
1889                 if (!info->uses_dma_out &&
1890                     info->xmit.head != info->xmit.tail && info->xmit.buf)
1891                         e100_enable_serial_tx_ready_irq(info);
1892
1893                 restore_flags(flags);
1894         }
1895 }
1896
1897 /*
1898  * ----------------------------------------------------------------------
1899  *
1900  * Here starts the interrupt handling routines.  All of the following
1901  * subroutines are declared as inline and are folded into
1902  * rs_interrupt().  They were separated out for readability's sake.
1903  *
1904  * Note: rs_interrupt() is a "fast" interrupt, which means that it
1905  * runs with interrupts turned off.  People who may want to modify
1906  * rs_interrupt() should try to keep the interrupt handler as fast as
1907  * possible.  After you are done making modifications, it is not a bad
1908  * idea to do:
1909  *
1910  * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
1911  *
1912  * and look at the resulting assemble code in serial.s.
1913  *
1914  *                              - Ted Ts'o (tytso@mit.edu), 7-Mar-93
1915  * -----------------------------------------------------------------------
1916  */
1917
1918 /*
1919  * This routine is used by the interrupt handler to schedule
1920  * processing in the software interrupt portion of the driver.
1921  */
1922 static _INLINE_ void
1923 rs_sched_event(struct e100_serial *info,
1924                                     int event)
1925 {
1926         if (info->event & (1 << event))
1927                 return;
1928         info->event |= 1 << event;
1929         schedule_work(&info->work);
1930 }
1931
1932 /* The output DMA channel is free - use it to send as many chars as possible
1933  * NOTES:
1934  *   We don't pay attention to info->x_char, which means if the TTY wants to
1935  *   use XON/XOFF it will set info->x_char but we won't send any X char!
1936  *
1937  *   To implement this, we'd just start a DMA send of 1 byte pointing at a
1938  *   buffer containing the X char, and skip updating xmit. We'd also have to
1939  *   check if the last sent char was the X char when we enter this function
1940  *   the next time, to avoid updating xmit with the sent X value.
1941  */
1942
1943 static void
1944 transmit_chars_dma(struct e100_serial *info)
1945 {
1946         unsigned int c, sentl;
1947         struct etrax_dma_descr *descr;
1948
1949 #ifdef CONFIG_SVINTO_SIM
1950         /* This will output too little if tail is not 0 always since
1951          * we don't reloop to send the other part. Anyway this SHOULD be a
1952          * no-op - transmit_chars_dma would never really be called during sim
1953          * since rs_write does not write into the xmit buffer then.
1954          */
1955         if (info->xmit.tail)
1956                 printk("Error in serial.c:transmit_chars-dma(), tail!=0\n");
1957         if (info->xmit.head != info->xmit.tail) {
1958                 SIMCOUT(info->xmit.buf + info->xmit.tail,
1959                         CIRC_CNT(info->xmit.head,
1960                                  info->xmit.tail,
1961                                  SERIAL_XMIT_SIZE));
1962                 info->xmit.head = info->xmit.tail;  /* move back head */
1963                 info->tr_running = 0;
1964         }
1965         return;
1966 #endif
1967         /* acknowledge both dma_descr and dma_eop irq in R_DMA_CHx_CLR_INTR */
1968         *info->oclrintradr =
1969                 IO_STATE(R_DMA_CH6_CLR_INTR, clr_descr, do) |
1970                 IO_STATE(R_DMA_CH6_CLR_INTR, clr_eop, do);
1971
1972 #ifdef SERIAL_DEBUG_INTR
1973         if (info->line == SERIAL_DEBUG_LINE)
1974                 printk("tc\n");
1975 #endif
1976         if (!info->tr_running) {
1977                 /* weirdo... we shouldn't get here! */
1978                 printk(KERN_WARNING "Achtung: transmit_chars_dma with !tr_running\n");
1979                 return;
1980         }
1981
1982         descr = &info->tr_descr;
1983
1984         /* first get the amount of bytes sent during the last DMA transfer,
1985            and update xmit accordingly */
1986
1987         /* if the stop bit was not set, all data has been sent */
1988         if (!(descr->status & d_stop)) {
1989                 sentl = descr->sw_len;
1990         } else
1991                 /* otherwise we find the amount of data sent here */
1992                 sentl = descr->hw_len;
1993
1994         DFLOW(DEBUG_LOG(info->line, "TX %i done\n", sentl));
1995
1996         /* update stats */
1997         info->icount.tx += sentl;
1998
1999         /* update xmit buffer */
2000         info->xmit.tail = (info->xmit.tail + sentl) & (SERIAL_XMIT_SIZE - 1);
2001
2002         /* if there is only a few chars left in the buf, wake up the blocked
2003            write if any */
2004         if (CIRC_CNT(info->xmit.head,
2005                      info->xmit.tail,
2006                      SERIAL_XMIT_SIZE) < WAKEUP_CHARS)
2007                 rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
2008
2009         /* find out the largest amount of consecutive bytes we want to send now */
2010
2011         c = CIRC_CNT_TO_END(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
2012
2013         /* Don't send all in one DMA transfer - divide it so we wake up
2014          * application before all is sent
2015          */
2016
2017         if (c >= 4*WAKEUP_CHARS)
2018                 c = c/2;
2019
2020         if (c <= 0) {
2021                 /* our job here is done, don't schedule any new DMA transfer */
2022                 info->tr_running = 0;
2023
2024 #if defined(CONFIG_ETRAX_RS485) && defined(CONFIG_ETRAX_FAST_TIMER)
2025                 if (info->rs485.enabled) {
2026                         /* Set a short timer to toggle RTS */
2027                         start_one_shot_timer(&fast_timers_rs485[info->line],
2028                                              rs485_toggle_rts_timer_function,
2029                                              (unsigned long)info,
2030                                              info->char_time_usec*2,
2031                                              "RS-485");
2032                 }
2033 #endif /* RS485 */
2034                 return;
2035         }
2036
2037         /* ok we can schedule a dma send of c chars starting at info->xmit.tail */
2038         /* set up the descriptor correctly for output */
2039         DFLOW(DEBUG_LOG(info->line, "TX %i\n", c));
2040         descr->ctrl = d_int | d_eol | d_wait; /* Wait needed for tty_wait_until_sent() */
2041         descr->sw_len = c;
2042         descr->buf = virt_to_phys(info->xmit.buf + info->xmit.tail);
2043         descr->status = 0;
2044
2045         *info->ofirstadr = virt_to_phys(descr); /* write to R_DMAx_FIRST */
2046         *info->ocmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, start);
2047
2048         /* DMA is now running (hopefully) */
2049 } /* transmit_chars_dma */
2050
2051 static void
2052 start_transmit(struct e100_serial *info)
2053 {
2054 #if 0
2055         if (info->line == SERIAL_DEBUG_LINE)
2056                 printk("x\n");
2057 #endif
2058
2059         info->tr_descr.sw_len = 0;
2060         info->tr_descr.hw_len = 0;
2061         info->tr_descr.status = 0;
2062         info->tr_running = 1;
2063         if (info->uses_dma_out)
2064                 transmit_chars_dma(info);
2065         else
2066                 e100_enable_serial_tx_ready_irq(info);
2067 } /* start_transmit */
2068
2069 #ifdef CONFIG_ETRAX_SERIAL_FAST_TIMER
2070 static int serial_fast_timer_started = 0;
2071 static int serial_fast_timer_expired = 0;
2072 static void flush_timeout_function(unsigned long data);
2073 #define START_FLUSH_FAST_TIMER_TIME(info, string, usec) {\
2074   unsigned long timer_flags; \
2075   save_flags(timer_flags); \
2076   cli(); \
2077   if (fast_timers[info->line].function == NULL) { \
2078     serial_fast_timer_started++; \
2079     TIMERD(DEBUG_LOG(info->line, "start_timer %i ", info->line)); \
2080     TIMERD(DEBUG_LOG(info->line, "num started: %i\n", serial_fast_timer_started)); \
2081     start_one_shot_timer(&fast_timers[info->line], \
2082                          flush_timeout_function, \
2083                          (unsigned long)info, \
2084                          (usec), \
2085                          string); \
2086   } \
2087   else { \
2088     TIMERD(DEBUG_LOG(info->line, "timer %i already running\n", info->line)); \
2089   } \
2090   restore_flags(timer_flags); \
2091 }
2092 #define START_FLUSH_FAST_TIMER(info, string) START_FLUSH_FAST_TIMER_TIME(info, string, info->flush_time_usec)
2093
2094 #else
2095 #define START_FLUSH_FAST_TIMER_TIME(info, string, usec)
2096 #define START_FLUSH_FAST_TIMER(info, string)
2097 #endif
2098
2099 static struct etrax_recv_buffer *
2100 alloc_recv_buffer(unsigned int size)
2101 {
2102         struct etrax_recv_buffer *buffer;
2103
2104         if (!(buffer = kmalloc(sizeof *buffer + size, GFP_ATOMIC)))
2105                 return NULL;
2106
2107         buffer->next = NULL;
2108         buffer->length = 0;
2109         buffer->error = TTY_NORMAL;
2110
2111         return buffer;
2112 }
2113
2114 static void
2115 append_recv_buffer(struct e100_serial *info, struct etrax_recv_buffer *buffer)
2116 {
2117         unsigned long flags;
2118
2119         save_flags(flags);
2120         cli();
2121
2122         if (!info->first_recv_buffer)
2123                 info->first_recv_buffer = buffer;
2124         else
2125                 info->last_recv_buffer->next = buffer;
2126
2127         info->last_recv_buffer = buffer;
2128
2129         info->recv_cnt += buffer->length;
2130         if (info->recv_cnt > info->max_recv_cnt)
2131                 info->max_recv_cnt = info->recv_cnt;
2132
2133         restore_flags(flags);
2134 }
2135
2136 static int
2137 add_char_and_flag(struct e100_serial *info, unsigned char data, unsigned char flag)
2138 {
2139         struct etrax_recv_buffer *buffer;
2140         if (info->uses_dma_in) {
2141                 if (!(buffer = alloc_recv_buffer(4)))
2142                         return 0;
2143
2144                 buffer->length = 1;
2145                 buffer->error = flag;
2146                 buffer->buffer[0] = data;
2147
2148                 append_recv_buffer(info, buffer);
2149
2150                 info->icount.rx++;
2151         } else {
2152                 struct tty_struct *tty = info->tty;
2153                 *tty->flip.char_buf_ptr = data;
2154                 *tty->flip.flag_buf_ptr = flag;
2155                 tty->flip.flag_buf_ptr++;
2156                 tty->flip.char_buf_ptr++;
2157                 tty->flip.count++;
2158                 info->icount.rx++;
2159         }
2160
2161         return 1;
2162 }
2163
2164 extern _INLINE_ unsigned int
2165 handle_descr_data(struct e100_serial *info, struct etrax_dma_descr *descr, unsigned int recvl)
2166 {
2167         struct etrax_recv_buffer *buffer = phys_to_virt(descr->buf) - sizeof *buffer;
2168
2169         if (info->recv_cnt + recvl > 65536) {
2170                 printk(KERN_CRIT
2171                        "%s: Too much pending incoming serial data! Dropping %u bytes.\n", __FUNCTION__, recvl);
2172                 return 0;
2173         }
2174
2175         buffer->length = recvl;
2176
2177         if (info->errorcode == ERRCODE_SET_BREAK)
2178                 buffer->error = TTY_BREAK;
2179         info->errorcode = 0;
2180
2181         append_recv_buffer(info, buffer);
2182
2183         if (!(buffer = alloc_recv_buffer(SERIAL_DESCR_BUF_SIZE)))
2184                 panic("%s: Failed to allocate memory for receive buffer!\n", __FUNCTION__);
2185
2186         descr->buf = virt_to_phys(buffer->buffer);
2187
2188         return recvl;
2189 }
2190
2191 static _INLINE_ unsigned int
2192 handle_all_descr_data(struct e100_serial *info)
2193 {
2194         struct etrax_dma_descr *descr;
2195         unsigned int recvl;
2196         unsigned int ret = 0;
2197
2198         while (1)
2199         {
2200                 descr = &info->rec_descr[info->cur_rec_descr];
2201
2202                 if (descr == phys_to_virt(*info->idescradr))
2203                         break;
2204
2205                 if (++info->cur_rec_descr == SERIAL_RECV_DESCRIPTORS)
2206                         info->cur_rec_descr = 0;
2207
2208                 /* find out how many bytes were read */
2209
2210                 /* if the eop bit was not set, all data has been received */
2211                 if (!(descr->status & d_eop)) {
2212                         recvl = descr->sw_len;
2213                 } else {
2214                         /* otherwise we find the amount of data received here */
2215                         recvl = descr->hw_len;
2216                 }
2217
2218                 /* Reset the status information */
2219                 descr->status = 0;
2220
2221                 DFLOW(  DEBUG_LOG(info->line, "RX %lu\n", recvl);
2222                         if (info->tty->stopped) {
2223                                 unsigned char *buf = phys_to_virt(descr->buf);
2224                                 DEBUG_LOG(info->line, "rx 0x%02X\n", buf[0]);
2225                                 DEBUG_LOG(info->line, "rx 0x%02X\n", buf[1]);
2226                                 DEBUG_LOG(info->line, "rx 0x%02X\n", buf[2]);
2227                         }
2228                         );
2229
2230                 /* update stats */
2231                 info->icount.rx += recvl;
2232
2233                 ret += handle_descr_data(info, descr, recvl);
2234         }
2235
2236         return ret;
2237 }
2238
2239 static _INLINE_ void
2240 receive_chars_dma(struct e100_serial *info)
2241 {
2242         struct tty_struct *tty;
2243         unsigned char rstat;
2244
2245 #ifdef CONFIG_SVINTO_SIM
2246         /* No receive in the simulator.  Will probably be when the rest of
2247          * the serial interface works, and this piece will just be removed.
2248          */
2249         return;
2250 #endif
2251
2252         /* Acknowledge both dma_descr and dma_eop irq in R_DMA_CHx_CLR_INTR */
2253         *info->iclrintradr =
2254                 IO_STATE(R_DMA_CH6_CLR_INTR, clr_descr, do) |
2255                 IO_STATE(R_DMA_CH6_CLR_INTR, clr_eop, do);
2256
2257         tty = info->tty;
2258         if (!tty) /* Something wrong... */
2259                 return;
2260
2261 #ifdef SERIAL_HANDLE_EARLY_ERRORS
2262         if (info->uses_dma_in)
2263                 e100_enable_serial_data_irq(info);
2264 #endif
2265
2266         if (info->errorcode == ERRCODE_INSERT_BREAK)
2267                 add_char_and_flag(info, '\0', TTY_BREAK);
2268
2269         handle_all_descr_data(info);
2270
2271         /* Read the status register to detect errors */
2272         rstat = info->port[REG_STATUS];
2273         if (rstat & IO_MASK(R_SERIAL0_STATUS, xoff_detect) ) {
2274                 DFLOW(DEBUG_LOG(info->line, "XOFF detect stat %x\n", rstat));
2275         }
2276
2277         if (rstat & SER_ERROR_MASK) {
2278                 /* If we got an error, we must reset it by reading the
2279                  * data_in field
2280                  */
2281                 unsigned char data = info->port[REG_DATA];
2282
2283                 PROCSTAT(ser_stat[info->line].errors_cnt++);
2284                 DEBUG_LOG(info->line, "#dERR: s d 0x%04X\n",
2285                           ((rstat & SER_ERROR_MASK) << 8) | data);
2286
2287                 if (rstat & SER_PAR_ERR_MASK)
2288                         add_char_and_flag(info, data, TTY_PARITY);
2289                 else if (rstat & SER_OVERRUN_MASK)
2290                         add_char_and_flag(info, data, TTY_OVERRUN);
2291                 else if (rstat & SER_FRAMING_ERR_MASK)
2292                         add_char_and_flag(info, data, TTY_FRAME);
2293         }
2294
2295         START_FLUSH_FAST_TIMER(info, "receive_chars");
2296
2297         /* Restart the receiving DMA */
2298         *info->icmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, restart);
2299 }
2300
2301 static _INLINE_ int
2302 start_recv_dma(struct e100_serial *info)
2303 {
2304         struct etrax_dma_descr *descr = info->rec_descr;
2305         struct etrax_recv_buffer *buffer;
2306         int i;
2307
2308         /* Set up the receiving descriptors */
2309         for (i = 0; i < SERIAL_RECV_DESCRIPTORS; i++) {
2310                 if (!(buffer = alloc_recv_buffer(SERIAL_DESCR_BUF_SIZE)))
2311                         panic("%s: Failed to allocate memory for receive buffer!\n", __FUNCTION__);
2312
2313                 descr[i].ctrl = d_int;
2314                 descr[i].buf = virt_to_phys(buffer->buffer);
2315                 descr[i].sw_len = SERIAL_DESCR_BUF_SIZE;
2316                 descr[i].hw_len = 0;
2317                 descr[i].status = 0;
2318                 descr[i].next = virt_to_phys(&descr[i+1]);
2319         }
2320
2321         /* Link the last descriptor to the first */
2322         descr[i-1].next = virt_to_phys(&descr[0]);
2323
2324         /* Start with the first descriptor in the list */
2325         info->cur_rec_descr = 0;
2326
2327         /* Start the DMA */
2328         *info->ifirstadr = virt_to_phys(&descr[info->cur_rec_descr]);
2329         *info->icmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, start);
2330
2331         /* Input DMA should be running now */
2332         return 1;
2333 }
2334
2335 static void
2336 start_receive(struct e100_serial *info)
2337 {
2338 #ifdef CONFIG_SVINTO_SIM
2339         /* No receive in the simulator.  Will probably be when the rest of
2340          * the serial interface works, and this piece will just be removed.
2341          */
2342         return;
2343 #endif
2344         info->tty->flip.count = 0;
2345         if (info->uses_dma_in) {
2346                 /* reset the input dma channel to be sure it works */
2347
2348                 *info->icmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, reset);
2349                 while (IO_EXTRACT(R_DMA_CH6_CMD, cmd, *info->icmdadr) ==
2350                        IO_STATE_VALUE(R_DMA_CH6_CMD, cmd, reset));
2351
2352                 start_recv_dma(info);
2353         }
2354 }
2355
2356
2357 static _INLINE_ void
2358 status_handle(struct e100_serial *info, unsigned short status)
2359 {
2360 }
2361
2362 /* the bits in the MASK2 register are laid out like this:
2363    DMAI_EOP DMAI_DESCR DMAO_EOP DMAO_DESCR
2364    where I is the input channel and O is the output channel for the port.
2365    info->irq is the bit number for the DMAO_DESCR so to check the others we
2366    shift info->irq to the left.
2367 */
2368
2369 /* dma output channel interrupt handler
2370    this interrupt is called from DMA2(ser2), DMA4(ser3), DMA6(ser0) or
2371    DMA8(ser1) when they have finished a descriptor with the intr flag set.
2372 */
2373
2374 static irqreturn_t
2375 tr_interrupt(int irq, void *dev_id, struct pt_regs * regs)
2376 {
2377         struct e100_serial *info;
2378         unsigned long ireg;
2379         int i;
2380         int handled = 0;
2381
2382 #ifdef CONFIG_SVINTO_SIM
2383         /* No receive in the simulator.  Will probably be when the rest of
2384          * the serial interface works, and this piece will just be removed.
2385          */
2386         {
2387                 const char *s = "What? tr_interrupt in simulator??\n";
2388                 SIMCOUT(s,strlen(s));
2389         }
2390         return IRQ_HANDLED;
2391 #endif
2392
2393         /* find out the line that caused this irq and get it from rs_table */
2394
2395         ireg = *R_IRQ_MASK2_RD;  /* get the active irq bits for the dma channels */
2396
2397         for (i = 0; i < NR_PORTS; i++) {
2398                 info = rs_table + i;
2399                 if (!info->enabled || !info->uses_dma_out)
2400                         continue;
2401                 /* check for dma_descr (don't need to check for dma_eop in output dma for serial */
2402                 if (ireg & info->irq) {
2403                         handled = 1;
2404                         /* we can send a new dma bunch. make it so. */
2405                         DINTR2(DEBUG_LOG(info->line, "tr_interrupt %i\n", i));
2406                         /* Read jiffies_usec first,
2407                          * we want this time to be as late as possible
2408                          */
2409                         PROCSTAT(ser_stat[info->line].tx_dma_ints++);
2410                         info->last_tx_active_usec = GET_JIFFIES_USEC();
2411                         info->last_tx_active = jiffies;
2412                         transmit_chars_dma(info);
2413                 }
2414
2415                 /* FIXME: here we should really check for a change in the
2416                    status lines and if so call status_handle(info) */
2417         }
2418         return IRQ_RETVAL(handled);
2419 } /* tr_interrupt */
2420
2421 /* dma input channel interrupt handler */
2422
2423 static irqreturn_t
2424 rec_interrupt(int irq, void *dev_id, struct pt_regs * regs)
2425 {
2426         struct e100_serial *info;
2427         unsigned long ireg;
2428         int i;
2429         int handled = 0;
2430
2431 #ifdef CONFIG_SVINTO_SIM
2432         /* No receive in the simulator.  Will probably be when the rest of
2433          * the serial interface works, and this piece will just be removed.
2434          */
2435         {
2436                 const char *s = "What? rec_interrupt in simulator??\n";
2437                 SIMCOUT(s,strlen(s));
2438         }
2439         return IRQ_HANDLED;
2440 #endif
2441
2442         /* find out the line that caused this irq and get it from rs_table */
2443
2444         ireg = *R_IRQ_MASK2_RD;  /* get the active irq bits for the dma channels */
2445
2446         for (i = 0; i < NR_PORTS; i++) {
2447                 info = rs_table + i;
2448                 if (!info->enabled || !info->uses_dma_in)
2449                         continue;
2450                 /* check for both dma_eop and dma_descr for the input dma channel */
2451                 if (ireg & ((info->irq << 2) | (info->irq << 3))) {
2452                         handled = 1;
2453                         /* we have received something */
2454                         receive_chars_dma(info);
2455                 }
2456
2457                 /* FIXME: here we should really check for a change in the
2458                    status lines and if so call status_handle(info) */
2459         }
2460         return IRQ_RETVAL(handled);
2461 } /* rec_interrupt */
2462
2463 static _INLINE_ int
2464 force_eop_if_needed(struct e100_serial *info)
2465 {
2466         /* We check data_avail bit to determine if data has
2467          * arrived since last time
2468          */
2469         unsigned char rstat = info->port[REG_STATUS];
2470
2471         /* error or datavail? */
2472         if (rstat & SER_ERROR_MASK) {
2473                 /* Some error has occurred. If there has been valid data, an
2474                  * EOP interrupt will be made automatically. If no data, the
2475                  * normal ser_interrupt should be enabled and handle it.
2476                  * So do nothing!
2477                  */
2478                 DEBUG_LOG(info->line, "timeout err: rstat 0x%03X\n",
2479                           rstat | (info->line << 8));
2480                 return 0;
2481         }
2482
2483         if (rstat & SER_DATA_AVAIL_MASK) {
2484                 /* Ok data, no error, count it */
2485                 TIMERD(DEBUG_LOG(info->line, "timeout: rstat 0x%03X\n",
2486                           rstat | (info->line << 8)));
2487                 /* Read data to clear status flags */
2488                 (void)info->port[REG_DATA];
2489
2490                 info->forced_eop = 0;
2491                 START_FLUSH_FAST_TIMER(info, "magic");
2492                 return 0;
2493         }
2494
2495         /* hit the timeout, force an EOP for the input
2496          * dma channel if we haven't already
2497          */
2498         if (!info->forced_eop) {
2499                 info->forced_eop = 1;
2500                 PROCSTAT(ser_stat[info->line].timeout_flush_cnt++);
2501                 TIMERD(DEBUG_LOG(info->line, "timeout EOP %i\n", info->line));
2502                 FORCE_EOP(info);
2503         }
2504
2505         return 1;
2506 }
2507
2508 extern _INLINE_ void
2509 flush_to_flip_buffer(struct e100_serial *info)
2510 {
2511         struct tty_struct *tty;
2512         struct etrax_recv_buffer *buffer;
2513         unsigned int length;
2514         unsigned long flags;
2515         int max_flip_size;
2516
2517         if (!info->first_recv_buffer)
2518                 return;
2519
2520         save_flags(flags);
2521         cli();
2522
2523         if (!(tty = info->tty)) {
2524                 restore_flags(flags);
2525                 return;
2526         }
2527
2528         length = tty->flip.count;
2529         /* Don't flip more than the ldisc has room for.
2530          * The return value from ldisc.receive_room(tty) - might not be up to
2531          * date, the previous flip of up to TTY_FLIPBUF_SIZE might be on the
2532          * processed and not accounted for yet.
2533          * Since we use DMA, 1 SERIAL_DESCR_BUF_SIZE could be on the way.
2534          * Lets buffer data here and let flow control take care of it.
2535          * Since we normally flip large chunks, the ldisc don't react
2536          * with throttle until too late if we flip to much.
2537          */
2538         max_flip_size = tty->ldisc.receive_room(tty);
2539         if (max_flip_size < 0)
2540                 max_flip_size = 0;
2541         if (max_flip_size <= (TTY_FLIPBUF_SIZE +         /* Maybe not accounted for */
2542                               length + info->recv_cnt +  /* We have this queued */
2543                               2*SERIAL_DESCR_BUF_SIZE +    /* This could be on the way */
2544                               TTY_THRESHOLD_THROTTLE)) { /* Some slack */
2545                 /* check TTY_THROTTLED first so it indicates our state */
2546                 if (!test_and_set_bit(TTY_THROTTLED, &tty->flags)) {
2547                         DFLOW(DEBUG_LOG(info->line,"flush_to_flip throttles room %lu\n", max_flip_size));
2548                         rs_throttle(tty);
2549                 }
2550 #if 0
2551                 else if (max_flip_size <= (TTY_FLIPBUF_SIZE +         /* Maybe not accounted for */
2552                                            length + info->recv_cnt +  /* We have this queued */
2553                                            SERIAL_DESCR_BUF_SIZE +    /* This could be on the way */
2554                                            TTY_THRESHOLD_THROTTLE)) { /* Some slack */
2555                         DFLOW(DEBUG_LOG(info->line,"flush_to_flip throttles again! %lu\n", max_flip_size));
2556                         rs_throttle(tty);
2557                 }
2558 #endif
2559         }
2560
2561         if (max_flip_size > TTY_FLIPBUF_SIZE)
2562                 max_flip_size = TTY_FLIPBUF_SIZE;
2563
2564         while ((buffer = info->first_recv_buffer) && length < max_flip_size) {
2565                 unsigned int count = buffer->length;
2566
2567                 if (length + count > max_flip_size)
2568                         count = max_flip_size - length;
2569
2570                 memcpy(tty->flip.char_buf_ptr + length, buffer->buffer, count);
2571                 memset(tty->flip.flag_buf_ptr + length, TTY_NORMAL, count);
2572                 tty->flip.flag_buf_ptr[length] = buffer->error;
2573
2574                 length += count;
2575                 info->recv_cnt -= count;
2576                 DFLIP(DEBUG_LOG(info->line,"flip: %i\n", length));
2577
2578                 if (count == buffer->length) {
2579                         info->first_recv_buffer = buffer->next;
2580                         kfree(buffer);
2581                 } else {
2582                         buffer->length -= count;
2583                         memmove(buffer->buffer, buffer->buffer + count, buffer->length);
2584                         buffer->error = TTY_NORMAL;
2585                 }
2586         }
2587
2588         if (!info->first_recv_buffer)
2589                 info->last_recv_buffer = NULL;
2590
2591         tty->flip.count = length;
2592         DFLIP(if (tty->ldisc.chars_in_buffer(tty) > 3500) {
2593                 DEBUG_LOG(info->line, "ldisc %lu\n",
2594                           tty->ldisc.chars_in_buffer(tty));
2595                 DEBUG_LOG(info->line, "flip.count %lu\n",
2596                           tty->flip.count);
2597               }
2598               );
2599         restore_flags(flags);
2600
2601         DFLIP(
2602           if (1) {
2603
2604                   if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2605                           DEBUG_LOG(info->line, "*** TTY_DONT_FLIP set flip.count %i ***\n", tty->flip.count);
2606                           DEBUG_LOG(info->line, "*** recv_cnt %i\n", info->recv_cnt);
2607                   } else {
2608                   }
2609                   DEBUG_LOG(info->line, "*** rxtot %i\n", info->icount.rx);
2610                   DEBUG_LOG(info->line, "ldisc %lu\n", tty->ldisc.chars_in_buffer(tty));
2611                   DEBUG_LOG(info->line, "room  %lu\n", tty->ldisc.receive_room(tty));
2612           }
2613
2614         );
2615
2616         /* this includes a check for low-latency */
2617         tty_flip_buffer_push(tty);
2618 }
2619
2620 static _INLINE_ void
2621 check_flush_timeout(struct e100_serial *info)
2622 {
2623         /* Flip what we've got (if we can) */
2624         flush_to_flip_buffer(info);
2625
2626         /* We might need to flip later, but not to fast
2627          * since the system is busy processing input... */
2628         if (info->first_recv_buffer)
2629                 START_FLUSH_FAST_TIMER_TIME(info, "flip", 2000);
2630
2631         /* Force eop last, since data might have come while we're processing
2632          * and if we started the slow timer above, we won't start a fast
2633          * below.
2634          */
2635         force_eop_if_needed(info);
2636 }
2637
2638 #ifdef CONFIG_ETRAX_SERIAL_FAST_TIMER
2639 static void flush_timeout_function(unsigned long data)
2640 {
2641         struct e100_serial *info = (struct e100_serial *)data;
2642
2643         fast_timers[info->line].function = NULL;
2644         serial_fast_timer_expired++;
2645         TIMERD(DEBUG_LOG(info->line, "flush_timout %i ", info->line));
2646         TIMERD(DEBUG_LOG(info->line, "num expired: %i\n", serial_fast_timer_expired));
2647         check_flush_timeout(info);
2648 }
2649
2650 #else
2651
2652 /* dma fifo/buffer timeout handler
2653    forces an end-of-packet for the dma input channel if no chars
2654    have been received for CONFIG_ETRAX_SERIAL_RX_TIMEOUT_TICKS/100 s.
2655 */
2656
2657 static struct timer_list flush_timer;
2658
2659 static void
2660 timed_flush_handler(unsigned long ptr)
2661 {
2662         struct e100_serial *info;
2663         int i;
2664
2665 #ifdef CONFIG_SVINTO_SIM
2666         return;
2667 #endif
2668
2669         for (i = 0; i < NR_PORTS; i++) {
2670                 info = rs_table + i;
2671                 if (info->uses_dma_in)
2672                         check_flush_timeout(info);
2673         }
2674
2675         /* restart flush timer */
2676         mod_timer(&flush_timer, jiffies + CONFIG_ETRAX_SERIAL_RX_TIMEOUT_TICKS);
2677 }
2678 #endif
2679
2680 #ifdef SERIAL_HANDLE_EARLY_ERRORS
2681
2682 /* If there is an error (ie break) when the DMA is running and
2683  * there are no bytes in the fifo the DMA is stopped and we get no
2684  * eop interrupt. Thus we have to monitor the first bytes on a DMA
2685  * transfer, and if it is without error we can turn the serial
2686  * interrupts off.
2687  */
2688
2689 /*
2690 BREAK handling on ETRAX 100:
2691 ETRAX will generate interrupt although there is no stop bit between the
2692 characters.
2693
2694 Depending on how long the break sequence is, the end of the breaksequence
2695 will look differently:
2696 | indicates start/end of a character.
2697
2698 B= Break character (0x00) with framing error.
2699 E= Error byte with parity error received after B characters.
2700 F= "Faked" valid byte received immediately after B characters.
2701 V= Valid byte
2702
2703 1.
2704     B          BL         ___________________________ V
2705 .._|__________|__________|                           |valid data |
2706
2707 Multiple frame errors with data == 0x00 (B),
2708 the timing matches up "perfectly" so no extra ending char is detected.
2709 The RXD pin is 1 in the last interrupt, in that case
2710 we set info->errorcode = ERRCODE_INSERT_BREAK, but we can't really
2711 know if another byte will come and this really is case 2. below
2712 (e.g F=0xFF or 0xFE)
2713 If RXD pin is 0 we can expect another character (see 2. below).
2714
2715
2716 2.
2717
2718     B          B          E or F__________________..__ V
2719 .._|__________|__________|______    |                 |valid data
2720                           "valid" or
2721                           parity error
2722
2723 Multiple frame errors with data == 0x00 (B),
2724 but the part of the break trigs is interpreted as a start bit (and possibly
2725 some 0 bits followed by a number of 1 bits and a stop bit).
2726 Depending on parity settings etc. this last character can be either
2727 a fake "valid" char (F) or have a parity error (E).
2728
2729 If the character is valid it will be put in the buffer,
2730 we set info->errorcode = ERRCODE_SET_BREAK so the receive interrupt
2731 will set the flags so the tty will handle it,
2732 if it's an error byte it will not be put in the buffer
2733 and we set info->errorcode = ERRCODE_INSERT_BREAK.
2734
2735 To distinguish a V byte in 1. from an F byte in 2. we keep a timestamp
2736 of the last faulty char (B) and compares it with the current time:
2737 If the time elapsed time is less then 2*char_time_usec we will assume
2738 it's a faked F char and not a Valid char and set
2739 info->errorcode = ERRCODE_SET_BREAK.
2740
2741 Flaws in the above solution:
2742 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2743 We use the timer to distinguish a F character from a V character,
2744 if a V character is to close after the break we might make the wrong decision.
2745
2746 TODO: The break will be delayed until an F or V character is received.
2747
2748 */
2749
2750 extern _INLINE_
2751 struct e100_serial * handle_ser_rx_interrupt_no_dma(struct e100_serial *info)
2752 {
2753         unsigned long data_read;
2754         struct tty_struct *tty = info->tty;
2755
2756         if (!tty) {
2757                 printk("!NO TTY!\n");
2758                 return info;
2759         }
2760         if (tty->flip.count >= TTY_FLIPBUF_SIZE - TTY_THRESHOLD_THROTTLE) {
2761                 /* check TTY_THROTTLED first so it indicates our state */
2762                 if (!test_and_set_bit(TTY_THROTTLED, &tty->flags)) {
2763                         DFLOW(DEBUG_LOG(info->line, "rs_throttle flip.count: %i\n", tty->flip.count));
2764                         rs_throttle(tty);
2765                 }
2766         }
2767         if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
2768                 DEBUG_LOG(info->line, "force FLIP! %i\n", tty->flip.count);
2769                 tty->flip.work.func((void *) tty);
2770                 if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
2771                         DEBUG_LOG(info->line, "FLIP FULL! %i\n", tty->flip.count);
2772                         return info;            /* if TTY_DONT_FLIP is set */
2773                 }
2774         }
2775         /* Read data and status at the same time */
2776         data_read = *((unsigned long *)&info->port[REG_DATA_STATUS32]);
2777 more_data:
2778         if (data_read & IO_MASK(R_SERIAL0_READ, xoff_detect) ) {
2779                 DFLOW(DEBUG_LOG(info->line, "XOFF detect\n", 0));
2780         }
2781         DINTR2(DEBUG_LOG(info->line, "ser_rx   %c\n", IO_EXTRACT(R_SERIAL0_READ, data_in, data_read)));
2782
2783         if (data_read & ( IO_MASK(R_SERIAL0_READ, framing_err) |
2784                           IO_MASK(R_SERIAL0_READ, par_err) |
2785                           IO_MASK(R_SERIAL0_READ, overrun) )) {
2786                 /* An error */
2787                 info->last_rx_active_usec = GET_JIFFIES_USEC();
2788                 info->last_rx_active = jiffies;
2789                 DINTR1(DEBUG_LOG(info->line, "ser_rx err stat_data %04X\n", data_read));
2790                 DLOG_INT_TRIG(
2791                 if (!log_int_trig1_pos) {
2792                         log_int_trig1_pos = log_int_pos;
2793                         log_int(rdpc(), 0, 0);
2794                 }
2795                 );
2796
2797
2798                 if ( ((data_read & IO_MASK(R_SERIAL0_READ, data_in)) == 0) &&
2799                      (data_read & IO_MASK(R_SERIAL0_READ, framing_err)) ) {
2800                         /* Most likely a break, but we get interrupts over and
2801                          * over again.
2802                          */
2803
2804                         if (!info->break_detected_cnt) {
2805                                 DEBUG_LOG(info->line, "#BRK start\n", 0);
2806                         }
2807                         if (data_read & IO_MASK(R_SERIAL0_READ, rxd)) {
2808                                 /* The RX pin is high now, so the break
2809                                  * must be over, but....
2810                                  * we can't really know if we will get another
2811                                  * last byte ending the break or not.
2812                                  * And we don't know if the byte (if any) will
2813                                  * have an error or look valid.
2814                                  */
2815                                 DEBUG_LOG(info->line, "# BL BRK\n", 0);
2816                                 info->errorcode = ERRCODE_INSERT_BREAK;
2817                         }
2818                         info->break_detected_cnt++;
2819                 } else {
2820                         /* The error does not look like a break, but could be
2821                          * the end of one
2822                          */
2823                         if (info->break_detected_cnt) {
2824                                 DEBUG_LOG(info->line, "EBRK %i\n", info->break_detected_cnt);
2825                                 info->errorcode = ERRCODE_INSERT_BREAK;
2826                         } else {
2827                                 if (info->errorcode == ERRCODE_INSERT_BREAK) {
2828                                         info->icount.brk++;
2829                                         *tty->flip.char_buf_ptr = 0;
2830                                         *tty->flip.flag_buf_ptr = TTY_BREAK;
2831                                         tty->flip.flag_buf_ptr++;
2832                                         tty->flip.char_buf_ptr++;
2833                                         tty->flip.count++;
2834                                         info->icount.rx++;
2835                                 }
2836                                 *tty->flip.char_buf_ptr = IO_EXTRACT(R_SERIAL0_READ, data_in, data_read);
2837
2838                                 if (data_read & IO_MASK(R_SERIAL0_READ, par_err)) {
2839                                         info->icount.parity++;
2840                                         *tty->flip.flag_buf_ptr = TTY_PARITY;
2841                                 } else if (data_read & IO_MASK(R_SERIAL0_READ, overrun)) {
2842                                         info->icount.overrun++;
2843                                         *tty->flip.flag_buf_ptr = TTY_OVERRUN;
2844                                 } else if (data_read & IO_MASK(R_SERIAL0_READ, framing_err)) {
2845                                         info->icount.frame++;
2846                                         *tty->flip.flag_buf_ptr = TTY_FRAME;
2847                                 }
2848                                 info->errorcode = 0;
2849                         }
2850                         info->break_detected_cnt = 0;
2851                 }
2852         } else if (data_read & IO_MASK(R_SERIAL0_READ, data_avail)) {
2853                 /* No error */
2854                 DLOG_INT_TRIG(
2855                 if (!log_int_trig1_pos) {
2856                         if (log_int_pos >= log_int_size) {
2857                                 log_int_pos = 0;
2858                         }
2859                         log_int_trig0_pos = log_int_pos;
2860                         log_int(rdpc(), 0, 0);
2861                 }
2862                 );
2863                 *tty->flip.char_buf_ptr = IO_EXTRACT(R_SERIAL0_READ, data_in, data_read);
2864                 *tty->flip.flag_buf_ptr = 0;
2865         } else {
2866                 DEBUG_LOG(info->line, "ser_rx int but no data_avail  %08lX\n", data_read);
2867         }
2868
2869
2870         tty->flip.flag_buf_ptr++;
2871         tty->flip.char_buf_ptr++;
2872         tty->flip.count++;
2873         info->icount.rx++;
2874         data_read = *((unsigned long *)&info->port[REG_DATA_STATUS32]);
2875         if (data_read & IO_MASK(R_SERIAL0_READ, data_avail)) {
2876                 DEBUG_LOG(info->line, "ser_rx   %c in loop\n", IO_EXTRACT(R_SERIAL0_READ, data_in, data_read));
2877                 goto more_data;
2878         }
2879
2880         tty_flip_buffer_push(info->tty);
2881         return info;
2882 }
2883
2884 extern _INLINE_
2885 struct e100_serial* handle_ser_rx_interrupt(struct e100_serial *info)
2886 {
2887         unsigned char rstat;
2888
2889 #ifdef SERIAL_DEBUG_INTR
2890         printk("Interrupt from serport %d\n", i);
2891 #endif
2892 /*      DEBUG_LOG(info->line, "ser_interrupt stat %03X\n", rstat | (i << 8)); */
2893         if (!info->uses_dma_in) {
2894                 return handle_ser_rx_interrupt_no_dma(info);
2895         }
2896         /* DMA is used */
2897         rstat = info->port[REG_STATUS];
2898         if (rstat & IO_MASK(R_SERIAL0_STATUS, xoff_detect) ) {
2899                 DFLOW(DEBUG_LOG(info->line, "XOFF detect\n", 0));
2900         }
2901
2902         if (rstat & SER_ERROR_MASK) {
2903                 unsigned char data;
2904
2905                 info->last_rx_active_usec = GET_JIFFIES_USEC();
2906                 info->last_rx_active = jiffies;
2907                 /* If we got an error, we must reset it by reading the
2908                  * data_in field
2909                  */
2910                 data = info->port[REG_DATA];
2911                 DINTR1(DEBUG_LOG(info->line, "ser_rx!  %c\n", data));
2912                 DINTR1(DEBUG_LOG(info->line, "ser_rx err stat %02X\n", rstat));
2913                 if (!data && (rstat & SER_FRAMING_ERR_MASK)) {
2914                         /* Most likely a break, but we get interrupts over and
2915                          * over again.
2916                          */
2917
2918                         if (!info->break_detected_cnt) {
2919                                 DEBUG_LOG(info->line, "#BRK start\n", 0);
2920                         }
2921                         if (rstat & SER_RXD_MASK) {
2922                                 /* The RX pin is high now, so the break
2923                                  * must be over, but....
2924                                  * we can't really know if we will get another
2925                                  * last byte ending the break or not.
2926                                  * And we don't know if the byte (if any) will
2927                                  * have an error or look valid.
2928                                  */
2929                                 DEBUG_LOG(info->line, "# BL BRK\n", 0);
2930                                 info->errorcode = ERRCODE_INSERT_BREAK;
2931                         }
2932                         info->break_detected_cnt++;
2933                 } else {
2934                         /* The error does not look like a break, but could be
2935                          * the end of one
2936                          */
2937                         if (info->break_detected_cnt) {
2938                                 DEBUG_LOG(info->line, "EBRK %i\n", info->break_detected_cnt);
2939                                 info->errorcode = ERRCODE_INSERT_BREAK;
2940                         } else {
2941                                 if (info->errorcode == ERRCODE_INSERT_BREAK) {
2942                                         info->icount.brk++;
2943                                         add_char_and_flag(info, '\0', TTY_BREAK);
2944                                 }
2945
2946                                 if (rstat & SER_PAR_ERR_MASK) {
2947                                         info->icount.parity++;
2948                                         add_char_and_flag(info, data, TTY_PARITY);
2949                                 } else if (rstat & SER_OVERRUN_MASK) {
2950                                         info->icount.overrun++;
2951                                         add_char_and_flag(info, data, TTY_OVERRUN);
2952                                 } else if (rstat & SER_FRAMING_ERR_MASK) {
2953                                         info->icount.frame++;
2954                                         add_char_and_flag(info, data, TTY_FRAME);
2955                                 }
2956
2957                                 info->errorcode = 0;
2958                         }
2959                         info->break_detected_cnt = 0;
2960                         DEBUG_LOG(info->line, "#iERR s d %04X\n",
2961                                   ((rstat & SER_ERROR_MASK) << 8) | data);
2962                 }
2963                 PROCSTAT(ser_stat[info->line].early_errors_cnt++);
2964         } else { /* It was a valid byte, now let the DMA do the rest */
2965                 unsigned long curr_time_u = GET_JIFFIES_USEC();
2966                 unsigned long curr_time = jiffies;
2967
2968                 if (info->break_detected_cnt) {
2969                         /* Detect if this character is a new valid char or the
2970                          * last char in a break sequence: If LSBits are 0 and
2971                          * MSBits are high AND the time is close to the
2972                          * previous interrupt we should discard it.
2973                          */
2974                         long elapsed_usec =
2975                           (curr_time - info->last_rx_active) * (1000000/HZ) +
2976                           curr_time_u - info->last_rx_active_usec;
2977                         if (elapsed_usec < 2*info->char_time_usec) {
2978                                 DEBUG_LOG(info->line, "FBRK %i\n", info->line);
2979                                 /* Report as BREAK (error) and let
2980                                  * receive_chars_dma() handle it
2981                                  */
2982                                 info->errorcode = ERRCODE_SET_BREAK;
2983                         } else {
2984                                 DEBUG_LOG(info->line, "Not end of BRK (V)%i\n", info->line);
2985                         }
2986                         DEBUG_LOG(info->line, "num brk %i\n", info->break_detected_cnt);
2987                 }
2988
2989 #ifdef SERIAL_DEBUG_INTR
2990                 printk("** OK, disabling ser_interrupts\n");
2991 #endif
2992                 e100_disable_serial_data_irq(info);
2993                 DINTR2(DEBUG_LOG(info->line, "ser_rx OK %d\n", info->line));
2994                 info->break_detected_cnt = 0;
2995
2996                 PROCSTAT(ser_stat[info->line].ser_ints_ok_cnt++);
2997         }
2998         /* Restarting the DMA never hurts */
2999         *info->icmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, restart);
3000         START_FLUSH_FAST_TIMER(info, "ser_int");
3001         return info;
3002 } /* handle_ser_rx_interrupt */
3003
3004 extern _INLINE_ void handle_ser_tx_interrupt(struct e100_serial *info)
3005 {
3006         unsigned long flags;
3007
3008         if (info->x_char) {
3009                 unsigned char rstat;
3010                 DFLOW(DEBUG_LOG(info->line, "tx_int: xchar 0x%02X\n", info->x_char));
3011                 save_flags(flags); cli();
3012                 rstat = info->port[REG_STATUS];
3013                 DFLOW(DEBUG_LOG(info->line, "stat %x\n", rstat));
3014
3015                 info->port[REG_TR_DATA] = info->x_char;
3016                 info->icount.tx++;
3017                 info->x_char = 0;
3018                 /* We must enable since it is disabled in ser_interrupt */
3019                 e100_enable_serial_tx_ready_irq(info);
3020                 restore_flags(flags);
3021                 return;
3022         }
3023         if (info->uses_dma_out) {
3024                 unsigned char rstat;
3025                 int i;
3026                 /* We only use normal tx interrupt when sending x_char */
3027                 DFLOW(DEBUG_LOG(info->line, "tx_int: xchar sent\n", 0));
3028                 save_flags(flags); cli();
3029                 rstat = info->port[REG_STATUS];
3030                 DFLOW(DEBUG_LOG(info->line, "stat %x\n", rstat));
3031                 e100_disable_serial_tx_ready_irq(info);
3032                 if (info->tty->stopped)
3033                         rs_stop(info->tty);
3034                 /* Enable the DMA channel and tell it to continue */
3035                 e100_enable_txdma_channel(info);
3036                 /* Wait 12 cycles before doing the DMA command */
3037                 for(i = 6;  i > 0; i--)
3038                         nop();
3039
3040                 *info->ocmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, continue);
3041                 restore_flags(flags);
3042                 return;
3043         }
3044         /* Normal char-by-char interrupt */
3045         if (info->xmit.head == info->xmit.tail
3046             || info->tty->stopped
3047             || info->tty->hw_stopped) {
3048                 DFLOW(DEBUG_LOG(info->line, "tx_int: stopped %i\n", info->tty->stopped));
3049                 e100_disable_serial_tx_ready_irq(info);
3050                 info->tr_running = 0;
3051                 return;
3052         }
3053         DINTR2(DEBUG_LOG(info->line, "tx_int %c\n", info->xmit.buf[info->xmit.tail]));
3054         /* Send a byte, rs485 timing is critical so turn of ints */
3055         save_flags(flags); cli();
3056         info->port[REG_TR_DATA] = info->xmit.buf[info->xmit.tail];
3057         info->xmit.tail = (info->xmit.tail + 1) & (SERIAL_XMIT_SIZE-1);
3058         info->icount.tx++;
3059         if (info->xmit.head == info->xmit.tail) {
3060 #if defined(CONFIG_ETRAX_RS485) && defined(CONFIG_ETRAX_FAST_TIMER)
3061                 if (info->rs485.enabled) {
3062                         /* Set a short timer to toggle RTS */
3063                         start_one_shot_timer(&fast_timers_rs485[info->line],
3064                                              rs485_toggle_rts_timer_function,
3065                                              (unsigned long)info,
3066                                              info->char_time_usec*2,
3067                                              "RS-485");
3068                 }
3069 #endif /* RS485 */
3070                 info->last_tx_active_usec = GET_JIFFIES_USEC();
3071                 info->last_tx_active = jiffies;
3072                 e100_disable_serial_tx_ready_irq(info);
3073                 info->tr_running = 0;
3074                 DFLOW(DEBUG_LOG(info->line, "tx_int: stop2\n", 0));
3075         } else {
3076                 /* We must enable since it is disabled in ser_interrupt */
3077                 e100_enable_serial_tx_ready_irq(info);
3078         }
3079         restore_flags(flags);
3080
3081         if (CIRC_CNT(info->xmit.head,
3082                      info->xmit.tail,
3083                      SERIAL_XMIT_SIZE) < WAKEUP_CHARS)
3084                 rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
3085
3086 } /* handle_ser_tx_interrupt */
3087
3088 /* result of time measurements:
3089  * RX duration 54-60 us when doing something, otherwise 6-9 us
3090  * ser_int duration: just sending: 8-15 us normally, up to 73 us
3091  */
3092 static irqreturn_t
3093 ser_interrupt(int irq, void *dev_id, struct pt_regs *regs)
3094 {
3095         static volatile int tx_started = 0;
3096         struct e100_serial *info;
3097         int i;
3098         unsigned long flags;
3099         unsigned long irq_mask1_rd;
3100         unsigned long data_mask = (1 << (8+2*0)); /* ser0 data_avail */
3101         int handled = 0;
3102         static volatile unsigned long reentered_ready_mask = 0;
3103
3104         save_flags(flags); cli();
3105         irq_mask1_rd = *R_IRQ_MASK1_RD;
3106         /* First handle all rx interrupts with ints disabled */
3107         info = rs_table;
3108         irq_mask1_rd &= e100_ser_int_mask;
3109         for (i = 0; i < NR_PORTS; i++) {
3110                 /* Which line caused the data irq? */
3111                 if (irq_mask1_rd & data_mask) {
3112                         handled = 1;
3113                         handle_ser_rx_interrupt(info);
3114                 }
3115                 info += 1;
3116                 data_mask <<= 2;
3117         }
3118         /* Handle tx interrupts with interrupts enabled so we
3119          * can take care of new data interrupts while transmitting
3120          * We protect the tx part with the tx_started flag.
3121          * We disable the tr_ready interrupts we are about to handle and
3122          * unblock the serial interrupt so new serial interrupts may come.
3123          *
3124          * If we get a new interrupt:
3125          *  - it migth be due to synchronous serial ports.
3126          *  - serial irq will be blocked by general irq handler.
3127          *  - async data will be handled above (sync will be ignored).
3128          *  - tx_started flag will prevent us from trying to send again and
3129          *    we will exit fast - no need to unblock serial irq.
3130          *  - Next (sync) serial interrupt handler will be runned with
3131          *    disabled interrupt due to restore_flags() at end of function,
3132          *    so sync handler will not be preempted or reentered.
3133          */
3134         if (!tx_started) {
3135                 unsigned long ready_mask;
3136                 unsigned long
3137                 tx_started = 1;
3138                 /* Only the tr_ready interrupts left */
3139                 irq_mask1_rd &= (IO_MASK(R_IRQ_MASK1_RD, ser0_ready) |
3140                                  IO_MASK(R_IRQ_MASK1_RD, ser1_ready) |
3141                                  IO_MASK(R_IRQ_MASK1_RD, ser2_ready) |
3142                                  IO_MASK(R_IRQ_MASK1_RD, ser3_ready));
3143                 while (irq_mask1_rd) {
3144                         /* Disable those we are about to handle */
3145                         *R_IRQ_MASK1_CLR = irq_mask1_rd;
3146                         /* Unblock the serial interrupt */
3147                         *R_VECT_MASK_SET = IO_STATE(R_VECT_MASK_SET, serial, set);
3148
3149                         sti();
3150                         ready_mask = (1 << (8+1+2*0)); /* ser0 tr_ready */
3151                         info = rs_table;
3152                         for (i = 0; i < NR_PORTS; i++) {
3153                                 /* Which line caused the ready irq? */
3154                                 if (irq_mask1_rd & ready_mask) {
3155                                         handled = 1;
3156                                         handle_ser_tx_interrupt(info);
3157                                 }
3158                                 info += 1;
3159                                 ready_mask <<= 2;
3160                         }
3161                         /* handle_ser_tx_interrupt enables tr_ready interrupts */
3162                         cli();
3163                         /* Handle reentered TX interrupt */
3164                         irq_mask1_rd = reentered_ready_mask;
3165                 }
3166                 cli();
3167                 tx_started = 0;
3168         } else {
3169                 unsigned long ready_mask;
3170                 ready_mask = irq_mask1_rd & (IO_MASK(R_IRQ_MASK1_RD, ser0_ready) |
3171                                              IO_MASK(R_IRQ_MASK1_RD, ser1_ready) |
3172                                              IO_MASK(R_IRQ_MASK1_RD, ser2_ready) |
3173                                              IO_MASK(R_IRQ_MASK1_RD, ser3_ready));
3174                 if (ready_mask) {
3175                         reentered_ready_mask |= ready_mask;
3176                         /* Disable those we are about to handle */
3177                         *R_IRQ_MASK1_CLR = ready_mask;
3178                         DFLOW(DEBUG_LOG(SERIAL_DEBUG_LINE, "ser_int reentered with TX %X\n", ready_mask));
3179                 }
3180         }
3181
3182         restore_flags(flags);
3183         return IRQ_RETVAL(handled);
3184 } /* ser_interrupt */
3185 #endif
3186
3187 /*
3188  * -------------------------------------------------------------------
3189  * Here ends the serial interrupt routines.
3190  * -------------------------------------------------------------------
3191  */
3192
3193 /*
3194  * This routine is used to handle the "bottom half" processing for the
3195  * serial driver, known also the "software interrupt" processing.
3196  * This processing is done at the kernel interrupt level, after the
3197  * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
3198  * is where time-consuming activities which can not be done in the
3199  * interrupt driver proper are done; the interrupt driver schedules
3200  * them using rs_sched_event(), and they get done here.
3201  */
3202 static void
3203 do_softint(void *private_)
3204 {
3205         struct e100_serial      *info = (struct e100_serial *) private_;
3206         struct tty_struct       *tty;
3207
3208         tty = info->tty;
3209         if (!tty)
3210                 return;
3211
3212         if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
3213                 if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
3214                     tty->ldisc.write_wakeup)
3215                         (tty->ldisc.write_wakeup)(tty);
3216                 wake_up_interruptible(&tty->write_wait);
3217         }
3218 }
3219
3220 static int
3221 startup(struct e100_serial * info)
3222 {
3223         unsigned long flags;
3224         unsigned long xmit_page;
3225         int i;
3226
3227         xmit_page = get_zeroed_page(GFP_KERNEL);
3228         if (!xmit_page)
3229                 return -ENOMEM;
3230
3231         save_flags(flags);
3232         cli();
3233
3234         /* if it was already initialized, skip this */
3235
3236         if (info->flags & ASYNC_INITIALIZED) {
3237                 restore_flags(flags);
3238                 free_page(xmit_page);
3239                 return 0;
3240         }
3241
3242         if (info->xmit.buf)
3243                 free_page(xmit_page);
3244         else
3245                 info->xmit.buf = (unsigned char *) xmit_page;
3246
3247 #ifdef SERIAL_DEBUG_OPEN
3248         printk("starting up ttyS%d (xmit_buf 0x%p)...\n", info->line, info->xmit.buf);
3249 #endif
3250
3251 #ifdef CONFIG_SVINTO_SIM
3252         /* Bits and pieces collected from below.  Better to have them
3253            in one ifdef:ed clause than to mix in a lot of ifdefs,
3254            right? */
3255         if (info->tty)
3256                 clear_bit(TTY_IO_ERROR, &info->tty->flags);
3257
3258         info->xmit.head = info->xmit.tail = 0;
3259         info->first_recv_buffer = info->last_recv_buffer = NULL;
3260         info->recv_cnt = info->max_recv_cnt = 0;
3261
3262         for (i = 0; i < SERIAL_RECV_DESCRIPTORS; i++)
3263                 info->rec_descr[i].buf = NULL;
3264
3265         /* No real action in the simulator, but may set info important
3266            to ioctl. */
3267         change_speed(info);
3268 #else
3269
3270         /*
3271          * Clear the FIFO buffers and disable them
3272          * (they will be reenabled in change_speed())
3273          */
3274
3275         /*
3276          * Reset the DMA channels and make sure their interrupts are cleared
3277          */
3278
3279         if (info->dma_in_enabled) {
3280                 info->uses_dma_in = 1;
3281                 e100_enable_rxdma_channel(info);
3282
3283                 *info->icmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, reset);
3284
3285                 /* Wait until reset cycle is complete */
3286                 while (IO_EXTRACT(R_DMA_CH6_CMD, cmd, *info->icmdadr) ==
3287                        IO_STATE_VALUE(R_DMA_CH6_CMD, cmd, reset));
3288
3289                 /* Make sure the irqs are cleared */
3290                 *info->iclrintradr =
3291                         IO_STATE(R_DMA_CH6_CLR_INTR, clr_descr, do) |
3292                         IO_STATE(R_DMA_CH6_CLR_INTR, clr_eop, do);
3293         } else {
3294                 e100_disable_rxdma_channel(info);
3295         }
3296
3297         if (info->dma_out_enabled) {
3298                 info->uses_dma_out = 1;
3299                 e100_enable_txdma_channel(info);
3300                 *info->ocmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, reset);
3301
3302                 while (IO_EXTRACT(R_DMA_CH6_CMD, cmd, *info->ocmdadr) ==
3303                        IO_STATE_VALUE(R_DMA_CH6_CMD, cmd, reset));
3304
3305                 /* Make sure the irqs are cleared */
3306                 *info->oclrintradr =
3307                         IO_STATE(R_DMA_CH6_CLR_INTR, clr_descr, do) |
3308                         IO_STATE(R_DMA_CH6_CLR_INTR, clr_eop, do);
3309         } else {
3310                 e100_disable_txdma_channel(info);
3311         }
3312
3313         if (info->tty)
3314                 clear_bit(TTY_IO_ERROR, &info->tty->flags);
3315
3316         info->xmit.head = info->xmit.tail = 0;
3317         info->first_recv_buffer = info->last_recv_buffer = NULL;
3318         info->recv_cnt = info->max_recv_cnt = 0;
3319
3320         for (i = 0; i < SERIAL_RECV_DESCRIPTORS; i++)
3321                 info->rec_descr[i].buf = 0;
3322
3323         /*
3324          * and set the speed and other flags of the serial port
3325          * this will start the rx/tx as well
3326          */
3327 #ifdef SERIAL_HANDLE_EARLY_ERRORS
3328         e100_enable_serial_data_irq(info);
3329 #endif
3330         change_speed(info);
3331
3332         /* dummy read to reset any serial errors */
3333
3334         (void)info->port[REG_DATA];
3335
3336         /* enable the interrupts */
3337         if (info->uses_dma_out)
3338                 e100_enable_txdma_irq(info);
3339
3340         e100_enable_rx_irq(info);
3341
3342         info->tr_running = 0; /* to be sure we don't lock up the transmitter */
3343
3344         /* setup the dma input descriptor and start dma */
3345
3346         start_receive(info);
3347
3348         /* for safety, make sure the descriptors last result is 0 bytes written */
3349
3350         info->tr_descr.sw_len = 0;
3351         info->tr_descr.hw_len = 0;
3352         info->tr_descr.status = 0;
3353
3354         /* enable RTS/DTR last */
3355
3356         e100_rts(info, 1);
3357         e100_dtr(info, 1);
3358
3359 #endif /* CONFIG_SVINTO_SIM */
3360
3361         info->flags |= ASYNC_INITIALIZED;
3362
3363         restore_flags(flags);
3364         return 0;
3365 }
3366
3367 /*
3368  * This routine will shutdown a serial port; interrupts are disabled, and
3369  * DTR is dropped if the hangup on close termio flag is on.
3370  */
3371 static void
3372 shutdown(struct e100_serial * info)
3373 {
3374         unsigned long flags;
3375         struct etrax_dma_descr *descr = info->rec_descr;
3376         struct etrax_recv_buffer *buffer;
3377         int i;
3378
3379 #ifndef CONFIG_SVINTO_SIM
3380         /* shut down the transmitter and receiver */
3381         DFLOW(DEBUG_LOG(info->line, "shutdown %i\n", info->line));
3382         e100_disable_rx(info);
3383         info->port[REG_TR_CTRL] = (info->tx_ctrl &= ~0x40);
3384
3385         /* disable interrupts, reset dma channels */
3386         if (info->uses_dma_in) {
3387                 e100_disable_rxdma_irq(info);
3388                 *info->icmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, reset);
3389                 info->uses_dma_in = 0;
3390         } else {
3391                 e100_disable_serial_data_irq(info);
3392         }
3393
3394         if (info->uses_dma_out) {
3395                 e100_disable_txdma_irq(info);
3396                 info->tr_running = 0;
3397                 *info->ocmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, reset);
3398                 info->uses_dma_out = 0;
3399         } else {
3400                 e100_disable_serial_tx_ready_irq(info);
3401                 info->tr_running = 0;
3402         }
3403
3404 #endif /* CONFIG_SVINTO_SIM */
3405
3406         if (!(info->flags & ASYNC_INITIALIZED))
3407                 return;
3408
3409 #ifdef SERIAL_DEBUG_OPEN
3410         printk("Shutting down serial port %d (irq %d)....\n", info->line,
3411                info->irq);
3412 #endif
3413
3414         save_flags(flags);
3415         cli(); /* Disable interrupts */
3416
3417         if (info->xmit.buf) {
3418                 free_page((unsigned long)info->xmit.buf);
3419                 info->xmit.buf = NULL;
3420         }
3421
3422         for (i = 0; i < SERIAL_RECV_DESCRIPTORS; i++)
3423                 if (descr[i].buf) {
3424                         buffer = phys_to_virt(descr[i].buf) - sizeof *buffer;
3425                         kfree(buffer);
3426                         descr[i].buf = 0;
3427                 }
3428
3429         if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
3430                 /* hang up DTR and RTS if HUPCL is enabled */
3431                 e100_dtr(info, 0);
3432                 e100_rts(info, 0); /* could check CRTSCTS before doing this */
3433         }
3434
3435         if (info->tty)
3436                 set_bit(TTY_IO_ERROR, &info->tty->flags);
3437
3438         info->flags &= ~ASYNC_INITIALIZED;
3439         restore_flags(flags);
3440 }
3441
3442
3443 /* change baud rate and other assorted parameters */
3444
3445 static void
3446 change_speed(struct e100_serial *info)
3447 {
3448         unsigned int cflag;
3449         unsigned long xoff;
3450         unsigned long flags;
3451         /* first some safety checks */
3452
3453         if (!info->tty || !info->tty->termios)
3454                 return;
3455         if (!info->port)
3456                 return;
3457
3458         cflag = info->tty->termios->c_cflag;
3459
3460         /* possibly, the tx/rx should be disabled first to do this safely */
3461
3462         /* change baud-rate and write it to the hardware */
3463         if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) {
3464                 /* Special baudrate */
3465                 u32 mask = 0xFF << (info->line*8); /* Each port has 8 bits */
3466                 unsigned long alt_source =
3467                                 IO_STATE(R_ALT_SER_BAUDRATE, ser0_rec, normal) |
3468                                 IO_STATE(R_ALT_SER_BAUDRATE, ser0_tr, normal);
3469                 /* R_ALT_SER_BAUDRATE selects the source */
3470                 DBAUD(printk("Custom baudrate: baud_base/divisor %lu/%i\n",
3471                        (unsigned long)info->baud_base, info->custom_divisor));
3472                 if (info->baud_base == SERIAL_PRESCALE_BASE) {
3473                         /* 0, 2-65535 (0=65536) */
3474                         u16 divisor = info->custom_divisor;
3475                         /* R_SERIAL_PRESCALE (upper 16 bits of R_CLOCK_PRESCALE) */
3476                         /* baudrate is 3.125MHz/custom_divisor */
3477                         alt_source =
3478                                 IO_STATE(R_ALT_SER_BAUDRATE, ser0_rec, prescale) |
3479                                 IO_STATE(R_ALT_SER_BAUDRATE, ser0_tr, prescale);
3480                         alt_source = 0x11;
3481                         DBAUD(printk("Writing SERIAL_PRESCALE: divisor %i\n", divisor));
3482                         *R_SERIAL_PRESCALE = divisor;
3483                         info->baud = SERIAL_PRESCALE_BASE/divisor;
3484                 }
3485 #ifdef CONFIG_ETRAX_EXTERN_PB6CLK_ENABLED
3486                 else if ((info->baud_base==CONFIG_ETRAX_EXTERN_PB6CLK_FREQ/8 &&
3487                           info->custom_divisor == 1) ||
3488                          (info->baud_base==CONFIG_ETRAX_EXTERN_PB6CLK_FREQ &&
3489                           info->custom_divisor == 8)) {
3490                                 /* ext_clk selected */
3491                                 alt_source =
3492                                         IO_STATE(R_ALT_SER_BAUDRATE, ser0_rec, extern) |
3493                                         IO_STATE(R_ALT_SER_BAUDRATE, ser0_tr, extern);
3494                                 DBAUD(printk("using external baudrate: %lu\n", CONFIG_ETRAX_EXTERN_PB6CLK_FREQ/8));
3495                                 info->baud = CONFIG_ETRAX_EXTERN_PB6CLK_FREQ/8;
3496                         }
3497                 }
3498 #endif
3499                 else
3500                 {
3501                         /* Bad baudbase, we don't support using timer0
3502                          * for baudrate.
3503                          */
3504                         printk(KERN_WARNING "Bad baud_base/custom_divisor: %lu/%i\n",
3505                                (unsigned long)info->baud_base, info->custom_divisor);
3506                 }
3507                 r_alt_ser_baudrate_shadow &= ~mask;
3508                 r_alt_ser_baudrate_shadow |= (alt_source << (info->line*8));
3509                 *R_ALT_SER_BAUDRATE = r_alt_ser_baudrate_shadow;
3510         } else {
3511                 /* Normal baudrate */
3512                 /* Make sure we use normal baudrate */
3513                 u32 mask = 0xFF << (info->line*8); /* Each port has 8 bits */
3514                 unsigned long alt_source =
3515                         IO_STATE(R_ALT_SER_BAUDRATE, ser0_rec, normal) |
3516                         IO_STATE(R_ALT_SER_BAUDRATE, ser0_tr, normal);
3517                 r_alt_ser_baudrate_shadow &= ~mask;
3518                 r_alt_ser_baudrate_shadow |= (alt_source << (info->line*8));
3519 #ifndef CONFIG_SVINTO_SIM
3520                 *R_ALT_SER_BAUDRATE = r_alt_ser_baudrate_shadow;
3521 #endif /* CONFIG_SVINTO_SIM */
3522
3523                 info->baud = cflag_to_baud(cflag);
3524 #ifndef CONFIG_SVINTO_SIM
3525                 info->port[REG_BAUD] = cflag_to_etrax_baud(cflag);
3526 #endif /* CONFIG_SVINTO_SIM */
3527         }
3528
3529 #ifndef CONFIG_SVINTO_SIM
3530         /* start with default settings and then fill in changes */
3531         save_flags(flags);
3532         cli();
3533         /* 8 bit, no/even parity */
3534         info->rx_ctrl &= ~(IO_MASK(R_SERIAL0_REC_CTRL, rec_bitnr) |
3535                            IO_MASK(R_SERIAL0_REC_CTRL, rec_par_en) |
3536                            IO_MASK(R_SERIAL0_REC_CTRL, rec_par));
3537
3538         /* 8 bit, no/even parity, 1 stop bit, no cts */
3539         info->tx_ctrl &= ~(IO_MASK(R_SERIAL0_TR_CTRL, tr_bitnr) |
3540                            IO_MASK(R_SERIAL0_TR_CTRL, tr_par_en) |
3541                            IO_MASK(R_SERIAL0_TR_CTRL, tr_par) |
3542                            IO_MASK(R_SERIAL0_TR_CTRL, stop_bits) |
3543                            IO_MASK(R_SERIAL0_TR_CTRL, auto_cts));
3544
3545         if ((cflag & CSIZE) == CS7) {
3546                 /* set 7 bit mode */
3547                 info->tx_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, tr_bitnr, tr_7bit);
3548                 info->rx_ctrl |= IO_STATE(R_SERIAL0_REC_CTRL, rec_bitnr, rec_7bit);
3549         }
3550
3551         if (cflag & CSTOPB) {
3552                 /* set 2 stop bit mode */
3553                 info->tx_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, stop_bits, two_bits);
3554         }
3555
3556         if (cflag & PARENB) {
3557                 /* enable parity */
3558                 info->tx_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, enable);
3559                 info->rx_ctrl |= IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, enable);
3560         }
3561
3562         if (cflag & CMSPAR) {
3563                 /* enable stick parity, PARODD mean Mark which matches ETRAX */
3564                 info->tx_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, tr_stick_par, stick);
3565                 info->rx_ctrl |= IO_STATE(R_SERIAL0_REC_CTRL, rec_stick_par, stick);
3566         }
3567         if (cflag & PARODD) {
3568                 /* set odd parity (or Mark if CMSPAR) */
3569                 info->tx_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, tr_par, odd);
3570                 info->rx_ctrl |= IO_STATE(R_SERIAL0_REC_CTRL, rec_par, odd);
3571         }
3572
3573         if (cflag & CRTSCTS) {
3574                 /* enable automatic CTS handling */
3575                 DFLOW(DEBUG_LOG(info->line, "FLOW auto_cts enabled\n", 0));
3576                 info->tx_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, auto_cts, active);
3577         }
3578
3579         /* make sure the tx and rx are enabled */
3580
3581         info->tx_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, tr_enable, enable);
3582         info->rx_ctrl |= IO_STATE(R_SERIAL0_REC_CTRL, rec_enable, enable);
3583
3584         /* actually write the control regs to the hardware */
3585
3586         info->port[REG_TR_CTRL] = info->tx_ctrl;
3587         info->port[REG_REC_CTRL] = info->rx_ctrl;
3588         xoff = IO_FIELD(R_SERIAL0_XOFF, xoff_char, STOP_CHAR(info->tty));
3589         xoff |= IO_STATE(R_SERIAL0_XOFF, tx_stop, enable);
3590         if (info->tty->termios->c_iflag & IXON ) {
3591                 DFLOW(DEBUG_LOG(info->line, "FLOW XOFF enabled 0x%02X\n", STOP_CHAR(info->tty)));
3592                 xoff |= IO_STATE(R_SERIAL0_XOFF, auto_xoff, enable);
3593         }
3594
3595         *((unsigned long *)&info->port[REG_XOFF]) = xoff;
3596         restore_flags(flags);
3597 #endif /* !CONFIG_SVINTO_SIM */
3598
3599         update_char_time(info);
3600
3601 } /* change_speed */
3602
3603 /* start transmitting chars NOW */
3604
3605 static void
3606 rs_flush_chars(struct tty_struct *tty)
3607 {
3608         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3609         unsigned long flags;
3610
3611         if (info->tr_running ||
3612             info->xmit.head == info->xmit.tail ||
3613             tty->stopped ||
3614             tty->hw_stopped ||
3615             !info->xmit.buf)
3616                 return;
3617
3618 #ifdef SERIAL_DEBUG_FLOW
3619         printk("rs_flush_chars\n");
3620 #endif
3621
3622         /* this protection might not exactly be necessary here */
3623
3624         save_flags(flags);
3625         cli();
3626         start_transmit(info);
3627         restore_flags(flags);
3628 }
3629
3630 extern _INLINE_ int
3631 rs_raw_write(struct tty_struct * tty, int from_user,
3632           const unsigned char *buf, int count)
3633 {
3634         int     c, ret = 0;
3635         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3636         unsigned long flags;
3637
3638         /* first some sanity checks */
3639
3640         if (!tty || !info->xmit.buf || !tmp_buf)
3641                 return 0;
3642
3643 #ifdef SERIAL_DEBUG_DATA
3644         if (info->line == SERIAL_DEBUG_LINE)
3645                 printk("rs_raw_write (%d), status %d\n",
3646                        count, info->port[REG_STATUS]);
3647 #endif
3648
3649 #ifdef CONFIG_SVINTO_SIM
3650         /* Really simple.  The output is here and now. */
3651         SIMCOUT(buf, count);
3652         return count;
3653 #endif
3654         save_flags(flags);
3655         DFLOW(DEBUG_LOG(info->line, "write count %i ", count));
3656         DFLOW(DEBUG_LOG(info->line, "ldisc %i\n", tty->ldisc.chars_in_buffer(tty)));
3657
3658
3659         /* the cli/restore_flags pairs below are needed because the
3660          * DMA interrupt handler moves the info->xmit values. the memcpy
3661          * needs to be in the critical region unfortunately, because we
3662          * need to read xmit values, memcpy, write xmit values in one
3663          * atomic operation... this could perhaps be avoided by more clever
3664          * design.
3665          */
3666         if (from_user) {
3667                 down(&tmp_buf_sem);
3668                 while (1) {
3669                         int c1;
3670                         c = CIRC_SPACE_TO_END(info->xmit.head,
3671                                               info->xmit.tail,
3672                                               SERIAL_XMIT_SIZE);
3673                         if (count < c)
3674                                 c = count;
3675                         if (c <= 0)
3676                                 break;
3677
3678                         c -= copy_from_user(tmp_buf, buf, c);
3679                         if (!c) {
3680                                 if (!ret)
3681                                         ret = -EFAULT;
3682                                 break;
3683                         }
3684                         cli();
3685                         c1 = CIRC_SPACE_TO_END(info->xmit.head,
3686                                                info->xmit.tail,
3687                                                SERIAL_XMIT_SIZE);
3688                         if (c1 < c)
3689                                 c = c1;
3690                         memcpy(info->xmit.buf + info->xmit.head, tmp_buf, c);
3691                         info->xmit.head = ((info->xmit.head + c) &
3692                                            (SERIAL_XMIT_SIZE-1));
3693                         restore_flags(flags);
3694                         buf += c;
3695                         count -= c;
3696                         ret += c;
3697                 }
3698                 up(&tmp_buf_sem);
3699         } else {
3700                 cli();
3701                 while (count) {
3702                         c = CIRC_SPACE_TO_END(info->xmit.head,
3703                                               info->xmit.tail,
3704                                               SERIAL_XMIT_SIZE);
3705
3706                         if (count < c)
3707                                 c = count;
3708                         if (c <= 0)
3709                                 break;
3710
3711                         memcpy(info->xmit.buf + info->xmit.head, buf, c);
3712                         info->xmit.head = (info->xmit.head + c) &
3713                                 (SERIAL_XMIT_SIZE-1);
3714                         buf += c;
3715                         count -= c;
3716                         ret += c;
3717                 }
3718                 restore_flags(flags);
3719         }
3720
3721         /* enable transmitter if not running, unless the tty is stopped
3722          * this does not need IRQ protection since if tr_running == 0
3723          * the IRQ's are not running anyway for this port.
3724          */
3725         DFLOW(DEBUG_LOG(info->line, "write ret %i\n", ret));
3726
3727         if (info->xmit.head != info->xmit.tail &&
3728             !tty->stopped &&
3729             !tty->hw_stopped &&
3730             !info->tr_running) {
3731                 start_transmit(info);
3732         }
3733
3734         return ret;
3735 } /* raw_raw_write() */
3736
3737 static int
3738 rs_write(struct tty_struct * tty, int from_user,
3739          const unsigned char *buf, int count)
3740 {
3741 #if defined(CONFIG_ETRAX_RS485)
3742         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3743
3744         if (info->rs485.enabled)
3745         {
3746                 /* If we are in RS-485 mode, we need to toggle RTS and disable
3747                  * the receiver before initiating a DMA transfer
3748                  */
3749 #ifdef CONFIG_ETRAX_FAST_TIMER
3750                 /* Abort any started timer */
3751                 fast_timers_rs485[info->line].function = NULL;
3752                 del_fast_timer(&fast_timers_rs485[info->line]);
3753 #endif
3754                 e100_rts(info, info->rs485.rts_on_send);
3755 #if defined(CONFIG_ETRAX_RS485_DISABLE_RECEIVER)
3756                 e100_disable_rx(info);
3757                 e100_enable_rx_irq(info);
3758 #endif
3759
3760                 if (info->rs485.delay_rts_before_send > 0)
3761                         msleep(info->rs485.delay_rts_before_send);
3762         }
3763 #endif /* CONFIG_ETRAX_RS485 */
3764
3765         count = rs_raw_write(tty, from_user, buf, count);
3766
3767 #if defined(CONFIG_ETRAX_RS485)
3768         if (info->rs485.enabled)
3769         {
3770                 unsigned int val;
3771                 /* If we are in RS-485 mode the following has to be done:
3772                  * wait until DMA is ready
3773                  * wait on transmit shift register
3774                  * toggle RTS
3775                  * enable the receiver
3776                  */
3777
3778                 /* Sleep until all sent */
3779                 tty_wait_until_sent(tty, 0);
3780 #ifdef CONFIG_ETRAX_FAST_TIMER
3781                 /* Now sleep a little more so that shift register is empty */
3782                 schedule_usleep(info->char_time_usec * 2);
3783 #endif
3784                 /* wait on transmit shift register */
3785                 do{
3786                         get_lsr_info(info, &val);
3787                 }while (!(val & TIOCSER_TEMT));
3788
3789                 e100_rts(info, info->rs485.rts_after_sent);
3790
3791 #if defined(CONFIG_ETRAX_RS485_DISABLE_RECEIVER)
3792                 e100_enable_rx(info);
3793                 e100_enable_rxdma_irq(info);
3794 #endif
3795         }
3796 #endif /* CONFIG_ETRAX_RS485 */
3797
3798         return count;
3799 } /* rs_write */
3800
3801
3802 /* how much space is available in the xmit buffer? */
3803
3804 static int
3805 rs_write_room(struct tty_struct *tty)
3806 {
3807         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3808
3809         return CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
3810 }
3811
3812 /* How many chars are in the xmit buffer?
3813  * This does not include any chars in the transmitter FIFO.
3814  * Use wait_until_sent for waiting for FIFO drain.
3815  */
3816
3817 static int
3818 rs_chars_in_buffer(struct tty_struct *tty)
3819 {
3820         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3821
3822         return CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
3823 }
3824
3825 /* discard everything in the xmit buffer */
3826
3827 static void
3828 rs_flush_buffer(struct tty_struct *tty)
3829 {
3830         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3831         unsigned long flags;
3832
3833         save_flags(flags);
3834         cli();
3835         info->xmit.head = info->xmit.tail = 0;
3836         restore_flags(flags);
3837
3838         wake_up_interruptible(&tty->write_wait);
3839
3840         if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
3841             tty->ldisc.write_wakeup)
3842                 (tty->ldisc.write_wakeup)(tty);
3843 }
3844
3845 /*
3846  * This function is used to send a high-priority XON/XOFF character to
3847  * the device
3848  *
3849  * Since we use DMA we don't check for info->x_char in transmit_chars_dma(),
3850  * but we do it in handle_ser_tx_interrupt().
3851  * We disable DMA channel and enable tx ready interrupt and write the
3852  * character when possible.
3853  */
3854 static void rs_send_xchar(struct tty_struct *tty, char ch)
3855 {
3856         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3857         unsigned long flags;
3858         save_flags(flags); cli();
3859         if (info->uses_dma_out) {
3860                 /* Put the DMA on hold and disable the channel */
3861                 *info->ocmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, hold);
3862                 while (IO_EXTRACT(R_DMA_CH6_CMD, cmd, *info->ocmdadr) !=
3863                        IO_STATE_VALUE(R_DMA_CH6_CMD, cmd, hold));
3864                 e100_disable_txdma_channel(info);
3865         }
3866
3867         /* Must make sure transmitter is not stopped before we can transmit */
3868         if (tty->stopped)
3869                 rs_start(tty);
3870
3871         /* Enable manual transmit interrupt and send from there */
3872         DFLOW(DEBUG_LOG(info->line, "rs_send_xchar 0x%02X\n", ch));
3873         info->x_char = ch;
3874         e100_enable_serial_tx_ready_irq(info);
3875         restore_flags(flags);
3876 }
3877
3878 /*
3879  * ------------------------------------------------------------
3880  * rs_throttle()
3881  *
3882  * This routine is called by the upper-layer tty layer to signal that
3883  * incoming characters should be throttled.
3884  * ------------------------------------------------------------
3885  */
3886 static void
3887 rs_throttle(struct tty_struct * tty)
3888 {
3889         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3890 #ifdef SERIAL_DEBUG_THROTTLE
3891         char    buf[64];
3892
3893         printk("throttle %s: %lu....\n", tty_name(tty, buf),
3894                (unsigned long)tty->ldisc.chars_in_buffer(tty));
3895 #endif
3896         DFLOW(DEBUG_LOG(info->line,"rs_throttle %lu\n", tty->ldisc.chars_in_buffer(tty)));
3897
3898         /* Do RTS before XOFF since XOFF might take some time */
3899         if (tty->termios->c_cflag & CRTSCTS) {
3900                 /* Turn off RTS line */
3901                 e100_rts(info, 0);
3902         }
3903         if (I_IXOFF(tty))
3904                 rs_send_xchar(tty, STOP_CHAR(tty));
3905
3906 }
3907
3908 static void
3909 rs_unthrottle(struct tty_struct * tty)
3910 {
3911         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3912 #ifdef SERIAL_DEBUG_THROTTLE
3913         char    buf[64];
3914
3915         printk("unthrottle %s: %lu....\n", tty_name(tty, buf),
3916                (unsigned long)tty->ldisc.chars_in_buffer(tty));
3917 #endif
3918         DFLOW(DEBUG_LOG(info->line,"rs_unthrottle ldisc %d\n", tty->ldisc.chars_in_buffer(tty)));
3919         DFLOW(DEBUG_LOG(info->line,"rs_unthrottle flip.count: %i\n", tty->flip.count));
3920         /* Do RTS before XOFF since XOFF might take some time */
3921         if (tty->termios->c_cflag & CRTSCTS) {
3922                 /* Assert RTS line  */
3923                 e100_rts(info, 1);
3924         }
3925
3926         if (I_IXOFF(tty)) {
3927                 if (info->x_char)
3928                         info->x_char = 0;
3929                 else
3930                         rs_send_xchar(tty, START_CHAR(tty));
3931         }
3932
3933 }
3934
3935 /*
3936  * ------------------------------------------------------------
3937  * rs_ioctl() and friends
3938  * ------------------------------------------------------------
3939  */
3940
3941 static int
3942 get_serial_info(struct e100_serial * info,
3943                 struct serial_struct * retinfo)
3944 {
3945         struct serial_struct tmp;
3946
3947         /* this is all probably wrong, there are a lot of fields
3948          * here that we don't have in e100_serial and maybe we
3949          * should set them to something else than 0.
3950          */
3951
3952         if (!retinfo)
3953                 return -EFAULT;
3954         memset(&tmp, 0, sizeof(tmp));
3955         tmp.type = info->type;
3956         tmp.line = info->line;
3957         tmp.port = (int)info->port;
3958         tmp.irq = info->irq;
3959         tmp.flags = info->flags;
3960         tmp.baud_base = info->baud_base;
3961         tmp.close_delay = info->close_delay;
3962         tmp.closing_wait = info->closing_wait;
3963         tmp.custom_divisor = info->custom_divisor;
3964         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
3965                 return -EFAULT;
3966         return 0;
3967 }
3968
3969 static int
3970 set_serial_info(struct e100_serial *info,
3971                 struct serial_struct *new_info)
3972 {
3973         struct serial_struct new_serial;
3974         struct e100_serial old_info;
3975         int retval = 0;
3976
3977         if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
3978                 return -EFAULT;
3979
3980         old_info = *info;
3981
3982         if (!capable(CAP_SYS_ADMIN)) {
3983                 if ((new_serial.type != info->type) ||
3984                     (new_serial.close_delay != info->close_delay) ||
3985                     ((new_serial.flags & ~ASYNC_USR_MASK) !=
3986                      (info->flags & ~ASYNC_USR_MASK)))
3987                         return -EPERM;
3988                 info->flags = ((info->flags & ~ASYNC_USR_MASK) |
3989                                (new_serial.flags & ASYNC_USR_MASK));
3990                 goto check_and_exit;
3991         }
3992
3993         if (info->count > 1)
3994                 return -EBUSY;
3995
3996         /*
3997          * OK, past this point, all the error checking has been done.
3998          * At this point, we start making changes.....
3999          */
4000
4001         info->baud_base = new_serial.baud_base;
4002         info->flags = ((info->flags & ~ASYNC_FLAGS) |
4003                        (new_serial.flags & ASYNC_FLAGS));
4004         info->custom_divisor = new_serial.custom_divisor;
4005         info->type = new_serial.type;
4006         info->close_delay = new_serial.close_delay;
4007         info->closing_wait = new_serial.closing_wait;
4008         info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
4009
4010  check_and_exit:
4011         if (info->flags & ASYNC_INITIALIZED) {
4012                 change_speed(info);
4013         } else
4014                 retval = startup(info);
4015         return retval;
4016 }
4017
4018 /*
4019  * get_lsr_info - get line status register info
4020  *
4021  * Purpose: Let user call ioctl() to get info when the UART physically
4022  *          is emptied.  On bus types like RS485, the transmitter must
4023  *          release the bus after transmitting. This must be done when
4024  *          the transmit shift register is empty, not be done when the
4025  *          transmit holding register is empty.  This functionality
4026  *          allows an RS485 driver to be written in user space.
4027  */
4028 static int
4029 get_lsr_info(struct e100_serial * info, unsigned int *value)
4030 {
4031         unsigned int result = TIOCSER_TEMT;
4032 #ifndef CONFIG_SVINTO_SIM
4033         unsigned long curr_time = jiffies;
4034         unsigned long curr_time_usec = GET_JIFFIES_USEC();
4035         unsigned long elapsed_usec =
4036                 (curr_time - info->last_tx_active) * 1000000/HZ +
4037                 curr_time_usec - info->last_tx_active_usec;
4038
4039         if (info->xmit.head != info->xmit.tail ||
4040             elapsed_usec < 2*info->char_time_usec) {
4041                 result = 0;
4042         }
4043 #endif
4044
4045         if (copy_to_user(value, &result, sizeof(int)))
4046                 return -EFAULT;
4047         return 0;
4048 }
4049
4050 #ifdef SERIAL_DEBUG_IO
4051 struct state_str
4052 {
4053         int state;
4054         const char *str;
4055 };
4056
4057 const struct state_str control_state_str[] = {
4058         {TIOCM_DTR, "DTR" },
4059         {TIOCM_RTS, "RTS"},
4060         {TIOCM_ST, "ST?" },
4061         {TIOCM_SR, "SR?" },
4062         {TIOCM_CTS, "CTS" },
4063         {TIOCM_CD, "CD" },
4064         {TIOCM_RI, "RI" },
4065         {TIOCM_DSR, "DSR" },
4066         {0, NULL }
4067 };
4068
4069 char *get_control_state_str(int MLines, char *s)
4070 {
4071         int i = 0;
4072
4073         s[0]='\0';
4074         while (control_state_str[i].str != NULL) {
4075                 if (MLines & control_state_str[i].state) {
4076                         if (s[0] != '\0') {
4077                                 strcat(s, ", ");
4078                         }
4079                         strcat(s, control_state_str[i].str);
4080                 }
4081                 i++;
4082         }
4083         return s;
4084 }
4085 #endif
4086
4087 static int
4088 get_modem_info(struct e100_serial * info, unsigned int *value)
4089 {
4090         unsigned int result;
4091         /* Polarity isn't verified */
4092 #if 0 /*def SERIAL_DEBUG_IO  */
4093
4094         printk("get_modem_info: RTS: %i DTR: %i CD: %i RI: %i DSR: %i CTS: %i\n",
4095                E100_RTS_GET(info),
4096                E100_DTR_GET(info),
4097                E100_CD_GET(info),
4098                E100_RI_GET(info),
4099                E100_DSR_GET(info),
4100                E100_CTS_GET(info));
4101 #endif
4102
4103         result =
4104                 (!E100_RTS_GET(info) ? TIOCM_RTS : 0)
4105                 | (!E100_DTR_GET(info) ? TIOCM_DTR : 0)
4106                 | (!E100_RI_GET(info) ? TIOCM_RNG : 0)
4107                 | (!E100_DSR_GET(info) ? TIOCM_DSR : 0)
4108                 | (!E100_CD_GET(info) ? TIOCM_CAR : 0)
4109                 | (!E100_CTS_GET(info) ? TIOCM_CTS : 0);
4110
4111 #ifdef SERIAL_DEBUG_IO
4112         printk("e100ser: modem state: %i 0x%08X\n", result, result);
4113         {
4114                 char s[100];
4115
4116                 get_control_state_str(result, s);
4117                 printk("state: %s\n", s);
4118         }
4119 #endif
4120         if (copy_to_user(value, &result, sizeof(int)))
4121                 return -EFAULT;
4122         return 0;
4123 }
4124
4125
4126 static int
4127 set_modem_info(struct e100_serial * info, unsigned int cmd,
4128                unsigned int *value)
4129 {
4130         unsigned int arg;
4131
4132         if (copy_from_user(&arg, value, sizeof(int)))
4133                 return -EFAULT;
4134
4135         switch (cmd) {
4136         case TIOCMBIS:
4137                 if (arg & TIOCM_RTS) {
4138                         e100_rts(info, 1);
4139                 }
4140                 if (arg & TIOCM_DTR) {
4141                         e100_dtr(info, 1);
4142                 }
4143                 /* Handle FEMALE behaviour */
4144                 if (arg & TIOCM_RI) {
4145                         e100_ri_out(info, 1);
4146                 }
4147                 if (arg & TIOCM_CD) {
4148                         e100_cd_out(info, 1);
4149                 }
4150                 break;
4151         case TIOCMBIC:
4152                 if (arg & TIOCM_RTS) {
4153                         e100_rts(info, 0);
4154                 }
4155                 if (arg & TIOCM_DTR) {
4156                         e100_dtr(info, 0);
4157                 }
4158                 /* Handle FEMALE behaviour */
4159                 if (arg & TIOCM_RI) {
4160                         e100_ri_out(info, 0);
4161                 }
4162                 if (arg & TIOCM_CD) {
4163                         e100_cd_out(info, 0);
4164                 }
4165                 break;
4166         case TIOCMSET:
4167                 e100_rts(info, arg & TIOCM_RTS);
4168                 e100_dtr(info, arg & TIOCM_DTR);
4169                 /* Handle FEMALE behaviour */
4170                 e100_ri_out(info, arg & TIOCM_RI);
4171                 e100_cd_out(info, arg & TIOCM_CD);
4172                 break;
4173         default:
4174                 return -EINVAL;
4175         }
4176         return 0;
4177 }
4178
4179
4180 static void
4181 rs_break(struct tty_struct *tty, int break_state)
4182 {
4183         struct e100_serial * info = (struct e100_serial *)tty->driver_data;
4184         unsigned long flags;
4185
4186         if (!info->port)
4187                 return;
4188
4189         save_flags(flags);
4190         cli();
4191         if (break_state == -1) {
4192                 /* Go to manual mode and set the txd pin to 0 */
4193                 info->tx_ctrl &= 0x3F; /* Clear bit 7 (txd) and 6 (tr_enable) */
4194         } else {
4195                 info->tx_ctrl |= (0x80 | 0x40); /* Set bit 7 (txd) and 6 (tr_enable) */
4196         }
4197         info->port[REG_TR_CTRL] = info->tx_ctrl;
4198         restore_flags(flags);
4199 }
4200
4201 static int
4202 rs_ioctl(struct tty_struct *tty, struct file * file,
4203          unsigned int cmd, unsigned long arg)
4204 {
4205         struct e100_serial * info = (struct e100_serial *)tty->driver_data;
4206
4207         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
4208             (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
4209             (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
4210                 if (tty->flags & (1 << TTY_IO_ERROR))
4211                         return -EIO;
4212         }
4213
4214         switch (cmd) {
4215                 case TIOCMGET:
4216                         return get_modem_info(info, (unsigned int *) arg);
4217                 case TIOCMBIS:
4218                 case TIOCMBIC:
4219                 case TIOCMSET:
4220                         return set_modem_info(info, cmd, (unsigned int *) arg);
4221                 case TIOCGSERIAL:
4222                         return get_serial_info(info,
4223                                                (struct serial_struct *) arg);
4224                 case TIOCSSERIAL:
4225                         return set_serial_info(info,
4226                                                (struct serial_struct *) arg);
4227                 case TIOCSERGETLSR: /* Get line status register */
4228                         return get_lsr_info(info, (unsigned int *) arg);
4229
4230                 case TIOCSERGSTRUCT:
4231                         if (copy_to_user((struct e100_serial *) arg,
4232                                          info, sizeof(struct e100_serial)))
4233                                 return -EFAULT;
4234                         return 0;
4235
4236 #if defined(CONFIG_ETRAX_RS485)
4237                 case TIOCSERSETRS485:
4238                 {
4239                         struct rs485_control rs485ctrl;
4240                         if (copy_from_user(&rs485ctrl, (struct rs485_control*)arg, sizeof(rs485ctrl)))
4241                                 return -EFAULT;
4242
4243                         return e100_enable_rs485(tty, &rs485ctrl);
4244                 }
4245
4246                 case TIOCSERWRRS485:
4247                 {
4248                         struct rs485_write rs485wr;
4249                         if (copy_from_user(&rs485wr, (struct rs485_write*)arg, sizeof(rs485wr)))
4250                                 return -EFAULT;
4251
4252                         return e100_write_rs485(tty, 1, rs485wr.outc, rs485wr.outc_size);
4253                 }
4254 #endif
4255
4256                 default:
4257                         return -ENOIOCTLCMD;
4258         }
4259         return 0;
4260 }
4261
4262 static void
4263 rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
4264 {
4265         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
4266
4267         if (tty->termios->c_cflag == old_termios->c_cflag &&
4268             tty->termios->c_iflag == old_termios->c_iflag)
4269                 return;
4270
4271         change_speed(info);
4272
4273         /* Handle turning off CRTSCTS */
4274         if ((old_termios->c_cflag & CRTSCTS) &&
4275             !(tty->termios->c_cflag & CRTSCTS)) {
4276                 tty->hw_stopped = 0;
4277                 rs_start(tty);
4278         }
4279
4280 }
4281
4282 /* In debugport.c - register a console write function that uses the normal
4283  * serial driver
4284  */
4285 typedef int (*debugport_write_function)(int i, const char *buf, unsigned int len);
4286
4287 extern debugport_write_function debug_write_function;
4288
4289 static int rs_debug_write_function(int i, const char *buf, unsigned int len)
4290 {
4291         int cnt;
4292         int written = 0;
4293         struct tty_struct *tty;
4294         static int recurse_cnt = 0;
4295
4296         tty = rs_table[i].tty;
4297         if (tty)  {
4298                 unsigned long flags;
4299                 if (recurse_cnt > 5) /* We skip this debug output */
4300                         return 1;
4301
4302                 local_irq_save(flags);
4303                 recurse_cnt++;
4304                 local_irq_restore(flags);
4305                 do {
4306                         cnt = rs_write(tty, 0, buf + written, len);
4307                         if (cnt >= 0) {
4308                                 written += cnt;
4309                                 buf += cnt;
4310                                 len -= cnt;
4311                         } else
4312                                 len = cnt;
4313                 } while(len > 0);
4314                 local_irq_save(flags);
4315                 recurse_cnt--;
4316                 local_irq_restore(flags);
4317                 return 1;
4318         }
4319         return 0;
4320 }
4321
4322 /*
4323  * ------------------------------------------------------------
4324  * rs_close()
4325  *
4326  * This routine is called when the serial port gets closed.  First, we
4327  * wait for the last remaining data to be sent.  Then, we unlink its
4328  * S structure from the interrupt chain if necessary, and we free
4329  * that IRQ if nothing is left in the chain.
4330  * ------------------------------------------------------------
4331  */
4332 static void
4333 rs_close(struct tty_struct *tty, struct file * filp)
4334 {
4335         struct e100_serial * info = (struct e100_serial *)tty->driver_data;
4336         unsigned long flags;
4337
4338         if (!info)
4339                 return;
4340
4341         /* interrupts are disabled for this entire function */
4342
4343         save_flags(flags);
4344         cli();
4345
4346         if (tty_hung_up_p(filp)) {
4347                 restore_flags(flags);
4348                 return;
4349         }
4350
4351 #ifdef SERIAL_DEBUG_OPEN
4352         printk("[%d] rs_close ttyS%d, count = %d\n", current->pid,
4353                info->line, info->count);
4354 #endif
4355         if ((tty->count == 1) && (info->count != 1)) {
4356                 /*
4357                  * Uh, oh.  tty->count is 1, which means that the tty
4358                  * structure will be freed.  Info->count should always
4359                  * be one in these conditions.  If it's greater than
4360                  * one, we've got real problems, since it means the
4361                  * serial port won't be shutdown.
4362                  */
4363                 printk(KERN_CRIT
4364                        "rs_close: bad serial port count; tty->count is 1, "
4365                        "info->count is %d\n", info->count);
4366                 info->count = 1;
4367         }
4368         if (--info->count < 0) {
4369                 printk(KERN_CRIT "rs_close: bad serial port count for ttyS%d: %d\n",
4370                        info->line, info->count);
4371                 info->count = 0;
4372         }
4373         if (info->count) {
4374                 restore_flags(flags);
4375                 return;
4376         }
4377         info->flags |= ASYNC_CLOSING;
4378         /*
4379          * Save the termios structure, since this port may have
4380          * separate termios for callout and dialin.
4381          */
4382         if (info->flags & ASYNC_NORMAL_ACTIVE)
4383                 info->normal_termios = *tty->termios;
4384         /*
4385          * Now we wait for the transmit buffer to clear; and we notify
4386          * the line discipline to only process XON/XOFF characters.
4387          */
4388         tty->closing = 1;
4389         if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE)
4390                 tty_wait_until_sent(tty, info->closing_wait);
4391         /*
4392          * At this point we stop accepting input.  To do this, we
4393          * disable the serial receiver and the DMA receive interrupt.
4394          */
4395 #ifdef SERIAL_HANDLE_EARLY_ERRORS
4396         e100_disable_serial_data_irq(info);
4397 #endif
4398
4399 #ifndef CONFIG_SVINTO_SIM
4400         e100_disable_rx(info);
4401         e100_disable_rx_irq(info);
4402
4403         if (info->flags & ASYNC_INITIALIZED) {
4404                 /*
4405                  * Before we drop DTR, make sure the UART transmitter
4406                  * has completely drained; this is especially
4407                  * important as we have a transmit FIFO!
4408                  */
4409                 rs_wait_until_sent(tty, HZ);
4410         }
4411 #endif
4412
4413         shutdown(info);
4414         if (tty->driver->flush_buffer)
4415                 tty->driver->flush_buffer(tty);
4416         if (tty->ldisc.flush_buffer)
4417                 tty->ldisc.flush_buffer(tty);
4418         tty->closing = 0;
4419         info->event = 0;
4420         info->tty = 0;
4421         if (info->blocked_open) {
4422                 if (info->close_delay) {
4423                         set_current_state(TASK_INTERRUPTIBLE);
4424                         schedule_timeout(info->close_delay);
4425                 }
4426                 wake_up_interruptible(&info->open_wait);
4427         }
4428         info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
4429         wake_up_interruptible(&info->close_wait);
4430         restore_flags(flags);
4431
4432         /* port closed */
4433
4434 #if defined(CONFIG_ETRAX_RS485)
4435         if (info->rs485.enabled) {
4436                 info->rs485.enabled = 0;
4437 #if defined(CONFIG_ETRAX_RS485_ON_PA)
4438                 *R_PORT_PA_DATA = port_pa_data_shadow &= ~(1 << rs485_pa_bit);
4439 #endif
4440 #if defined(CONFIG_ETRAX_RS485_ON_PORT_G)
4441                 REG_SHADOW_SET(R_PORT_G_DATA, port_g_data_shadow,
4442                                rs485_port_g_bit, 0);
4443 #endif
4444 #if defined(CONFIG_ETRAX_RS485_LTC1387)
4445                 REG_SHADOW_SET(R_PORT_G_DATA, port_g_data_shadow,
4446                                CONFIG_ETRAX_RS485_LTC1387_DXEN_PORT_G_BIT, 0);
4447                 REG_SHADOW_SET(R_PORT_G_DATA, port_g_data_shadow,
4448                                CONFIG_ETRAX_RS485_LTC1387_RXEN_PORT_G_BIT, 0);
4449 #endif
4450         }
4451 #endif
4452 }
4453
4454 /*
4455  * rs_wait_until_sent() --- wait until the transmitter is empty
4456  */
4457 static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
4458 {
4459         unsigned long orig_jiffies;
4460         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
4461         unsigned long curr_time = jiffies;
4462         unsigned long curr_time_usec = GET_JIFFIES_USEC();
4463         long elapsed_usec =
4464                 (curr_time - info->last_tx_active) * (1000000/HZ) +
4465                 curr_time_usec - info->last_tx_active_usec;
4466
4467         /*
4468          * Check R_DMA_CHx_STATUS bit 0-6=number of available bytes in FIFO
4469          * R_DMA_CHx_HWSW bit 31-16=nbr of bytes left in DMA buffer (0=64k)
4470          */
4471         orig_jiffies = jiffies;
4472         while (info->xmit.head != info->xmit.tail || /* More in send queue */
4473                (*info->ostatusadr & 0x007f) ||  /* more in FIFO */
4474                (elapsed_usec < 2*info->char_time_usec)) {
4475                 set_current_state(TASK_INTERRUPTIBLE);
4476                 schedule_timeout(1);
4477                 if (signal_pending(current))
4478                         break;
4479                 if (timeout && time_after(jiffies, orig_jiffies + timeout))
4480                         break;
4481                 curr_time = jiffies;
4482                 curr_time_usec = GET_JIFFIES_USEC();
4483                 elapsed_usec =
4484                         (curr_time - info->last_tx_active) * (1000000/HZ) +
4485                         curr_time_usec - info->last_tx_active_usec;
4486         }
4487         set_current_state(TASK_RUNNING);
4488 }
4489
4490 /*
4491  * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
4492  */
4493 void
4494 rs_hangup(struct tty_struct *tty)
4495 {
4496         struct e100_serial * info = (struct e100_serial *)tty->driver_data;
4497
4498         rs_flush_buffer(tty);
4499         shutdown(info);
4500         info->event = 0;
4501         info->count = 0;
4502         info->flags &= ~ASYNC_NORMAL_ACTIVE;
4503         info->tty = 0;
4504         wake_up_interruptible(&info->open_wait);
4505 }
4506
4507 /*
4508  * ------------------------------------------------------------
4509  * rs_open() and friends
4510  * ------------------------------------------------------------
4511  */
4512 static int
4513 block_til_ready(struct tty_struct *tty, struct file * filp,
4514                 struct e100_serial *info)
4515 {
4516         DECLARE_WAITQUEUE(wait, current);
4517         unsigned long   flags;
4518         int             retval;
4519         int             do_clocal = 0, extra_count = 0;
4520
4521         /*
4522          * If the device is in the middle of being closed, then block
4523          * until it's done, and then try again.
4524          */
4525         if (tty_hung_up_p(filp) ||
4526             (info->flags & ASYNC_CLOSING)) {
4527                 if (info->flags & ASYNC_CLOSING)
4528                         interruptible_sleep_on(&info->close_wait);
4529 #ifdef SERIAL_DO_RESTART
4530                 if (info->flags & ASYNC_HUP_NOTIFY)
4531                         return -EAGAIN;
4532                 else
4533                         return -ERESTARTSYS;
4534 #else
4535                 return -EAGAIN;
4536 #endif
4537         }
4538
4539         /*
4540          * If non-blocking mode is set, or the port is not enabled,
4541          * then make the check up front and then exit.
4542          */
4543         if ((filp->f_flags & O_NONBLOCK) ||
4544             (tty->flags & (1 << TTY_IO_ERROR))) {
4545                 info->flags |= ASYNC_NORMAL_ACTIVE;
4546                 return 0;
4547         }
4548
4549         if (tty->termios->c_cflag & CLOCAL) {
4550                         do_clocal = 1;
4551         }
4552
4553         /*
4554          * Block waiting for the carrier detect and the line to become
4555          * free (i.e., not in use by the callout).  While we are in
4556          * this loop, info->count is dropped by one, so that
4557          * rs_close() knows when to free things.  We restore it upon
4558          * exit, either normal or abnormal.
4559          */
4560         retval = 0;
4561         add_wait_queue(&info->open_wait, &wait);
4562 #ifdef SERIAL_DEBUG_OPEN
4563         printk("block_til_ready before block: ttyS%d, count = %d\n",
4564                info->line, info->count);
4565 #endif
4566         save_flags(flags);
4567         cli();
4568         if (!tty_hung_up_p(filp)) {
4569                 extra_count++;
4570                 info->count--;
4571         }
4572         restore_flags(flags);
4573         info->blocked_open++;
4574         while (1) {
4575                 save_flags(flags);
4576                 cli();
4577                 /* assert RTS and DTR */
4578                 e100_rts(info, 1);
4579                 e100_dtr(info, 1);
4580                 restore_flags(flags);
4581                 set_current_state(TASK_INTERRUPTIBLE);
4582                 if (tty_hung_up_p(filp) ||
4583                     !(info->flags & ASYNC_INITIALIZED)) {
4584 #ifdef SERIAL_DO_RESTART
4585                         if (info->flags & ASYNC_HUP_NOTIFY)
4586                                 retval = -EAGAIN;
4587                         else
4588                                 retval = -ERESTARTSYS;
4589 #else
4590                         retval = -EAGAIN;
4591 #endif
4592                         break;
4593                 }
4594                 if (!(info->flags & ASYNC_CLOSING) && do_clocal)
4595                         /* && (do_clocal || DCD_IS_ASSERTED) */
4596                         break;
4597                 if (signal_pending(current)) {
4598                         retval = -ERESTARTSYS;
4599                         break;
4600                 }
4601 #ifdef SERIAL_DEBUG_OPEN
4602                 printk("block_til_ready blocking: ttyS%d, count = %d\n",
4603                        info->line, info->count);
4604 #endif
4605                 schedule();
4606         }
4607         set_current_state(TASK_RUNNING);
4608         remove_wait_queue(&info->open_wait, &wait);
4609         if (extra_count)
4610                 info->count++;
4611         info->blocked_open--;
4612 #ifdef SERIAL_DEBUG_OPEN
4613         printk("block_til_ready after blocking: ttyS%d, count = %d\n",
4614                info->line, info->count);
4615 #endif
4616         if (retval)
4617                 return retval;
4618         info->flags |= ASYNC_NORMAL_ACTIVE;
4619         return 0;
4620 }
4621
4622 /*
4623  * This routine is called whenever a serial port is opened.
4624  * It performs the serial-specific initialization for the tty structure.
4625  */
4626 static int
4627 rs_open(struct tty_struct *tty, struct file * filp)
4628 {
4629         struct e100_serial      *info;
4630         int                     retval, line;
4631         unsigned long           page;
4632
4633         /* find which port we want to open */
4634
4635         line = tty->index;
4636
4637         if (line < 0 || line >= NR_PORTS)
4638                 return -ENODEV;
4639
4640         /* find the corresponding e100_serial struct in the table */
4641         info = rs_table + line;
4642
4643         /* don't allow the opening of ports that are not enabled in the HW config */
4644         if (!info->enabled)
4645                 return -ENODEV;
4646
4647 #ifdef SERIAL_DEBUG_OPEN
4648         printk("[%d] rs_open %s, count = %d\n", current->pid, tty->name,
4649                info->count);
4650 #endif
4651
4652         info->count++;
4653         tty->driver_data = info;
4654         info->tty = tty;
4655
4656         info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
4657
4658         if (!tmp_buf) {
4659                 page = get_zeroed_page(GFP_KERNEL);
4660                 if (!page) {
4661                         return -ENOMEM;
4662                 }
4663                 if (tmp_buf)
4664                         free_page(page);
4665                 else
4666                         tmp_buf = (unsigned char *) page;
4667         }
4668
4669         /*
4670          * If the port is in the middle of closing, bail out now
4671          */
4672         if (tty_hung_up_p(filp) ||
4673             (info->flags & ASYNC_CLOSING)) {
4674                 if (info->flags & ASYNC_CLOSING)
4675                         interruptible_sleep_on(&info->close_wait);
4676 #ifdef SERIAL_DO_RESTART
4677                 return ((info->flags & ASYNC_HUP_NOTIFY) ?
4678                         -EAGAIN : -ERESTARTSYS);
4679 #else
4680                 return -EAGAIN;
4681 #endif
4682         }
4683
4684         /*
4685          * Start up the serial port
4686          */
4687
4688         retval = startup(info);
4689         if (retval)
4690                 return retval;
4691
4692         retval = block_til_ready(tty, filp, info);
4693         if (retval) {
4694 #ifdef SERIAL_DEBUG_OPEN
4695                 printk("rs_open returning after block_til_ready with %d\n",
4696                        retval);
4697 #endif
4698                 return retval;
4699         }
4700
4701         if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
4702                 *tty->termios = info->normal_termios;
4703                 change_speed(info);
4704         }
4705
4706 #ifdef SERIAL_DEBUG_OPEN
4707         printk("rs_open ttyS%d successful...\n", info->line);
4708 #endif
4709         DLOG_INT_TRIG( log_int_pos = 0);
4710
4711         DFLIP(  if (info->line == SERIAL_DEBUG_LINE) {
4712                         info->icount.rx = 0;
4713                 } );
4714
4715         return 0;
4716 }
4717
4718 /*
4719  * /proc fs routines....
4720  */
4721
4722 extern _INLINE_ int line_info(char *buf, struct e100_serial *info)
4723 {
4724         char    stat_buf[30];
4725         int     ret;
4726         unsigned long tmp;
4727
4728         ret = sprintf(buf, "%d: uart:E100 port:%lX irq:%d",
4729                       info->line, (unsigned long)info->port, info->irq);
4730
4731         if (!info->port || (info->type == PORT_UNKNOWN)) {
4732                 ret += sprintf(buf+ret, "\n");
4733                 return ret;
4734         }
4735
4736         stat_buf[0] = 0;
4737         stat_buf[1] = 0;
4738         if (!E100_RTS_GET(info))
4739                 strcat(stat_buf, "|RTS");
4740         if (!E100_CTS_GET(info))
4741                 strcat(stat_buf, "|CTS");
4742         if (!E100_DTR_GET(info))
4743                 strcat(stat_buf, "|DTR");
4744         if (!E100_DSR_GET(info))
4745                 strcat(stat_buf, "|DSR");
4746         if (!E100_CD_GET(info))
4747                 strcat(stat_buf, "|CD");
4748         if (!E100_RI_GET(info))
4749                 strcat(stat_buf, "|RI");
4750
4751         ret += sprintf(buf+ret, " baud:%d", info->baud);
4752
4753         ret += sprintf(buf+ret, " tx:%lu rx:%lu",
4754                        (unsigned long)info->icount.tx,
4755                        (unsigned long)info->icount.rx);
4756         tmp = CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
4757         if (tmp) {
4758                 ret += sprintf(buf+ret, " tx_pend:%lu/%lu",
4759                                (unsigned long)tmp,
4760                                (unsigned long)SERIAL_XMIT_SIZE);
4761         }
4762
4763         ret += sprintf(buf+ret, " rx_pend:%lu/%lu",
4764                        (unsigned long)info->recv_cnt,
4765                        (unsigned long)info->max_recv_cnt);
4766
4767 #if 1
4768         if (info->tty) {
4769
4770                 if (info->tty->stopped)
4771                         ret += sprintf(buf+ret, " stopped:%i",
4772                                        (int)info->tty->stopped);
4773                 if (info->tty->hw_stopped)
4774                         ret += sprintf(buf+ret, " hw_stopped:%i",
4775                                        (int)info->tty->hw_stopped);
4776         }
4777
4778         {
4779                 unsigned char rstat = info->port[REG_STATUS];
4780                 if (rstat & IO_MASK(R_SERIAL0_STATUS, xoff_detect) )
4781                         ret += sprintf(buf+ret, " xoff_detect:1");
4782         }
4783
4784 #endif
4785
4786
4787
4788
4789         if (info->icount.frame)
4790                 ret += sprintf(buf+ret, " fe:%lu",
4791                                (unsigned long)info->icount.frame);
4792
4793         if (info->icount.parity)
4794                 ret += sprintf(buf+ret, " pe:%lu",
4795                                (unsigned long)info->icount.parity);
4796
4797         if (info->icount.brk)
4798                 ret += sprintf(buf+ret, " brk:%lu",
4799                                (unsigned long)info->icount.brk);
4800
4801         if (info->icount.overrun)
4802                 ret += sprintf(buf+ret, " oe:%lu",
4803                                (unsigned long)info->icount.overrun);
4804
4805         /*
4806          * Last thing is the RS-232 status lines
4807          */
4808         ret += sprintf(buf+ret, " %s\n", stat_buf+1);
4809         return ret;
4810 }
4811
4812 int rs_read_proc(char *page, char **start, off_t off, int count,
4813                  int *eof, void *data)
4814 {
4815         int i, len = 0, l;
4816         off_t   begin = 0;
4817
4818         len += sprintf(page, "serinfo:1.0 driver:%s\n",
4819                        serial_version);
4820         for (i = 0; i < NR_PORTS && len < 4000; i++) {
4821                 if (!rs_table[i].enabled)
4822                         continue;
4823                 l = line_info(page + len, &rs_table[i]);
4824                 len += l;
4825                 if (len+begin > off+count)
4826                         goto done;
4827                 if (len+begin < off) {
4828                         begin += len;
4829                         len = 0;
4830                 }
4831         }
4832 #ifdef DEBUG_LOG_INCLUDED
4833         for (i = 0; i < debug_log_pos; i++) {
4834                 len += sprintf(page + len, "%-4i %lu.%lu ", i, debug_log[i].time, timer_data_to_ns(debug_log[i].timer_data));
4835                 len += sprintf(page + len, debug_log[i].string, debug_log[i].value);
4836                 if (len+begin > off+count)
4837                         goto done;
4838                 if (len+begin < off) {
4839                         begin += len;
4840                         len = 0;
4841                 }
4842         }
4843         len += sprintf(page + len, "debug_log %i/%i  %li bytes\n",
4844                        i, DEBUG_LOG_SIZE, begin+len);
4845         debug_log_pos = 0;
4846 #endif
4847
4848         *eof = 1;
4849 done:
4850         if (off >= len+begin)
4851                 return 0;
4852         *start = page + (off-begin);
4853         return ((count < begin+len-off) ? count : begin+len-off);
4854 }
4855
4856 /* Finally, routines used to initialize the serial driver. */
4857
4858 static void
4859 show_serial_version(void)
4860 {
4861         printk(KERN_INFO
4862                "ETRAX 100LX serial-driver %s, (c) 2000-2004 Axis Communications AB\r\n",
4863                &serial_version[11]); /* "$Revision: x.yy" */
4864 }
4865
4866 /* rs_init inits the driver at boot (using the module_init chain) */
4867
4868 static struct tty_operations rs_ops = {
4869         .open = rs_open,
4870         .close = rs_close,
4871         .write = rs_write,
4872         .flush_chars = rs_flush_chars,
4873         .write_room = rs_write_room,
4874         .chars_in_buffer = rs_chars_in_buffer,
4875         .flush_buffer = rs_flush_buffer,
4876         .ioctl = rs_ioctl,
4877         .throttle = rs_throttle,
4878         .unthrottle = rs_unthrottle,
4879         .set_termios = rs_set_termios,
4880         .stop = rs_stop,
4881         .start = rs_start,
4882         .hangup = rs_hangup,
4883         .break_ctl = rs_break,
4884         .send_xchar = rs_send_xchar,
4885         .wait_until_sent = rs_wait_until_sent,
4886         .read_proc = rs_read_proc,
4887 };
4888
4889 static int __init
4890 rs_init(void)
4891 {
4892         int i;
4893         struct e100_serial *info;
4894         struct tty_driver *driver = alloc_tty_driver(NR_PORTS);
4895
4896         if (!driver)
4897                 return -ENOMEM;
4898
4899         show_serial_version();
4900
4901         /* Setup the timed flush handler system */
4902
4903 #if !defined(CONFIG_ETRAX_SERIAL_FAST_TIMER)
4904         init_timer(&flush_timer);
4905         flush_timer.function = timed_flush_handler;
4906         mod_timer(&flush_timer, jiffies + CONFIG_ETRAX_SERIAL_RX_TIMEOUT_TICKS);
4907 #endif
4908
4909         /* Initialize the tty_driver structure */
4910
4911         driver->driver_name = "serial";
4912         driver->name = "ttyS";
4913         driver->major = TTY_MAJOR;
4914         driver->minor_start = 64;
4915         driver->type = TTY_DRIVER_TYPE_SERIAL;
4916         driver->subtype = SERIAL_TYPE_NORMAL;
4917         driver->init_termios = tty_std_termios;
4918         driver->init_termios.c_cflag =
4919                 B115200 | CS8 | CREAD | HUPCL | CLOCAL; /* is normally B9600 default... */
4920         driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
4921         driver->termios = serial_termios;
4922         driver->termios_locked = serial_termios_locked;
4923
4924         tty_set_operations(driver, &rs_ops);
4925         serial_driver = driver;
4926         if (tty_register_driver(driver))
4927                 panic("Couldn't register serial driver\n");
4928         /* do some initializing for the separate ports */
4929
4930         for (i = 0, info = rs_table; i < NR_PORTS; i++,info++) {
4931                 info->uses_dma_in = 0;
4932                 info->uses_dma_out = 0;
4933                 info->line = i;
4934                 info->tty = 0;
4935                 info->type = PORT_ETRAX;
4936                 info->tr_running = 0;
4937                 info->forced_eop = 0;
4938                 info->baud_base = DEF_BAUD_BASE;
4939                 info->custom_divisor = 0;
4940                 info->flags = 0;
4941                 info->close_delay = 5*HZ/10;
4942                 info->closing_wait = 30*HZ;
4943                 info->x_char = 0;
4944                 info->event = 0;
4945                 info->count = 0;
4946                 info->blocked_open = 0;
4947                 info->normal_termios = driver->init_termios;
4948                 init_waitqueue_head(&info->open_wait);
4949                 init_waitqueue_head(&info->close_wait);
4950                 info->xmit.buf = NULL;
4951                 info->xmit.tail = info->xmit.head = 0;
4952                 info->first_recv_buffer = info->last_recv_buffer = NULL;
4953                 info->recv_cnt = info->max_recv_cnt = 0;
4954                 info->last_tx_active_usec = 0;
4955                 info->last_tx_active = 0;
4956
4957 #if defined(CONFIG_ETRAX_RS485)
4958                 /* Set sane defaults */
4959                 info->rs485.rts_on_send = 0;
4960                 info->rs485.rts_after_sent = 1;
4961                 info->rs485.delay_rts_before_send = 0;
4962                 info->rs485.enabled = 0;
4963 #endif
4964                 INIT_WORK(&info->work, do_softint, info);
4965
4966                 if (info->enabled) {
4967                         printk(KERN_INFO "%s%d at 0x%x is a builtin UART with DMA\n",
4968                                serial_driver->name, info->line, (unsigned int)info->port);
4969                 }
4970         }
4971 #ifdef CONFIG_ETRAX_FAST_TIMER
4972 #ifdef CONFIG_ETRAX_SERIAL_FAST_TIMER
4973         memset(fast_timers, 0, sizeof(fast_timers));
4974 #endif
4975 #ifdef CONFIG_ETRAX_RS485
4976         memset(fast_timers_rs485, 0, sizeof(fast_timers_rs485));
4977 #endif
4978         fast_timer_init();
4979 #endif
4980
4981 #ifndef CONFIG_SVINTO_SIM
4982         /* Not needed in simulator.  May only complicate stuff. */
4983         /* hook the irq's for DMA channel 6 and 7, serial output and input, and some more... */
4984
4985         if (request_irq(SERIAL_IRQ_NBR, ser_interrupt, SA_SHIRQ | SA_INTERRUPT, "serial ", NULL))
4986                 panic("irq8");
4987
4988 #ifdef CONFIG_ETRAX_SERIAL_PORT0
4989 #ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA6_OUT
4990         if (request_irq(SER0_DMA_TX_IRQ_NBR, tr_interrupt, SA_INTERRUPT, "serial 0 dma tr", NULL))
4991                 panic("irq22");
4992 #endif
4993 #ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA7_IN
4994         if (request_irq(SER0_DMA_RX_IRQ_NBR, rec_interrupt, SA_INTERRUPT, "serial 0 dma rec", NULL))
4995                 panic("irq23");
4996 #endif
4997 #endif
4998
4999 #ifdef CONFIG_ETRAX_SERIAL_PORT1
5000 #ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA8_OUT
5001         if (request_irq(SER1_DMA_TX_IRQ_NBR, tr_interrupt, SA_INTERRUPT, "serial 1 dma tr", NULL))
5002                 panic("irq24");
5003 #endif
5004 #ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA9_IN
5005         if (request_irq(SER1_DMA_RX_IRQ_NBR, rec_interrupt, SA_INTERRUPT, "serial 1 dma rec", NULL))
5006                 panic("irq25");
5007 #endif
5008 #endif
5009 #ifdef CONFIG_ETRAX_SERIAL_PORT2
5010         /* DMA Shared with par0 (and SCSI0 and ATA) */
5011 #ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA2_OUT
5012         if (request_irq(SER2_DMA_TX_IRQ_NBR, tr_interrupt, SA_SHIRQ | SA_INTERRUPT, "serial 2 dma tr", NULL))
5013                 panic("irq18");
5014 #endif
5015 #ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA3_IN
5016         if (request_irq(SER2_DMA_RX_IRQ_NBR, rec_interrupt, SA_SHIRQ | SA_INTERRUPT, "serial 2 dma rec", NULL))
5017                 panic("irq19");
5018 #endif
5019 #endif
5020 #ifdef CONFIG_ETRAX_SERIAL_PORT3
5021         /* DMA Shared with par1 (and SCSI1 and Extern DMA 0) */
5022 #ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA4_OUT
5023         if (request_irq(SER3_DMA_TX_IRQ_NBR, tr_interrupt, SA_SHIRQ | SA_INTERRUPT, "serial 3 dma tr", NULL))
5024                 panic("irq20");
5025 #endif
5026 #ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA5_IN
5027         if (request_irq(SER3_DMA_RX_IRQ_NBR, rec_interrupt, SA_SHIRQ | SA_INTERRUPT, "serial 3 dma rec", NULL))
5028                 panic("irq21");
5029 #endif
5030 #endif
5031
5032 #ifdef CONFIG_ETRAX_SERIAL_FLUSH_DMA_FAST
5033         if (request_irq(TIMER1_IRQ_NBR, timeout_interrupt, SA_SHIRQ | SA_INTERRUPT,
5034                        "fast serial dma timeout", NULL)) {
5035                 printk(KERN_CRIT "err: timer1 irq\n");
5036         }
5037 #endif
5038 #endif /* CONFIG_SVINTO_SIM */
5039         debug_write_function = rs_debug_write_function;
5040         return 0;
5041 }
5042
5043 /* this makes sure that rs_init is called during kernel boot */
5044
5045 module_init(rs_init);
5046
5047 /*
5048  * register_serial and unregister_serial allows for serial ports to be
5049  * configured at run-time, to support PCMCIA modems.
5050  */
5051 int
5052 register_serial(struct serial_struct *req)
5053 {
5054         return -1;
5055 }
5056
5057 void unregister_serial(int line)
5058 {
5059 }