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 set_current_state(TASK_INTERRUPTIBLE);
3762 schedule_timeout((info->rs485.delay_rts_before_send * HZ)/1000);
3763 }
3764 }
3765 #endif /* CONFIG_ETRAX_RS485 */
3766
3767 count = rs_raw_write(tty, from_user, buf, count);
3768
3769 #if defined(CONFIG_ETRAX_RS485)
3770 if (info->rs485.enabled)
3771 {
3772 unsigned int val;
3773 /* If we are in RS-485 mode the following has to be done:
3774 * wait until DMA is ready
3775 * wait on transmit shift register
3776 * toggle RTS
3777 * enable the receiver
3778 */
3779
3780 /* Sleep until all sent */
3781 tty_wait_until_sent(tty, 0);
3782 #ifdef CONFIG_ETRAX_FAST_TIMER
3783 /* Now sleep a little more so that shift register is empty */
3784 schedule_usleep(info->char_time_usec * 2);
3785 #endif
3786 /* wait on transmit shift register */
3787 do{
3788 get_lsr_info(info, &val);
3789 }while (!(val & TIOCSER_TEMT));
3790
3791 e100_rts(info, info->rs485.rts_after_sent);
3792
3793 #if defined(CONFIG_ETRAX_RS485_DISABLE_RECEIVER)
3794 e100_enable_rx(info);
3795 e100_enable_rxdma_irq(info);
3796 #endif
3797 }
3798 #endif /* CONFIG_ETRAX_RS485 */
3799
3800 return count;
3801 } /* rs_write */
3802
3803
3804 /* how much space is available in the xmit buffer? */
3805
3806 static int
3807 rs_write_room(struct tty_struct *tty)
3808 {
3809 struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3810
3811 return CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
3812 }
3813
3814 /* How many chars are in the xmit buffer?
3815 * This does not include any chars in the transmitter FIFO.
3816 * Use wait_until_sent for waiting for FIFO drain.
3817 */
3818
3819 static int
3820 rs_chars_in_buffer(struct tty_struct *tty)
3821 {
3822 struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3823
3824 return CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
3825 }
3826
3827 /* discard everything in the xmit buffer */
3828
3829 static void
3830 rs_flush_buffer(struct tty_struct *tty)
3831 {
3832 struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3833 unsigned long flags;
3834
3835 save_flags(flags);
3836 cli();
3837 info->xmit.head = info->xmit.tail = 0;
3838 restore_flags(flags);
3839
3840 wake_up_interruptible(&tty->write_wait);
3841
3842 if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
3843 tty->ldisc.write_wakeup)
3844 (tty->ldisc.write_wakeup)(tty);
3845 }
3846
3847 /*
3848 * This function is used to send a high-priority XON/XOFF character to
3849 * the device
3850 *
3851 * Since we use DMA we don't check for info->x_char in transmit_chars_dma(),
3852 * but we do it in handle_ser_tx_interrupt().
3853 * We disable DMA channel and enable tx ready interrupt and write the
3854 * character when possible.
3855 */
3856 static void rs_send_xchar(struct tty_struct *tty, char ch)
3857 {
3858 struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3859 unsigned long flags;
3860 save_flags(flags); cli();
3861 if (info->uses_dma_out) {
3862 /* Put the DMA on hold and disable the channel */
3863 *info->ocmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, hold);
3864 while (IO_EXTRACT(R_DMA_CH6_CMD, cmd, *info->ocmdadr) !=
3865 IO_STATE_VALUE(R_DMA_CH6_CMD, cmd, hold));
3866 e100_disable_txdma_channel(info);
3867 }
3868
3869 /* Must make sure transmitter is not stopped before we can transmit */
3870 if (tty->stopped)
3871 rs_start(tty);
3872
3873 /* Enable manual transmit interrupt and send from there */
3874 DFLOW(DEBUG_LOG(info->line, "rs_send_xchar 0x%02X\n", ch));
3875 info->x_char = ch;
3876 e100_enable_serial_tx_ready_irq(info);
3877 restore_flags(flags);
3878 }
3879
3880 /*
3881 * ------------------------------------------------------------
3882 * rs_throttle()
3883 *
3884 * This routine is called by the upper-layer tty layer to signal that
3885 * incoming characters should be throttled.
3886 * ------------------------------------------------------------
3887 */
3888 static void
3889 rs_throttle(struct tty_struct * tty)
3890 {
3891 struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3892 #ifdef SERIAL_DEBUG_THROTTLE
3893 char buf[64];
3894
3895 printk("throttle %s: %lu....\n", tty_name(tty, buf),
3896 (unsigned long)tty->ldisc.chars_in_buffer(tty));
3897 #endif
3898 DFLOW(DEBUG_LOG(info->line,"rs_throttle %lu\n", tty->ldisc.chars_in_buffer(tty)));
3899
3900 /* Do RTS before XOFF since XOFF might take some time */
3901 if (tty->termios->c_cflag & CRTSCTS) {
3902 /* Turn off RTS line */
3903 e100_rts(info, 0);
3904 }
3905 if (I_IXOFF(tty))
3906 rs_send_xchar(tty, STOP_CHAR(tty));
3907
3908 }
3909
3910 static void
3911 rs_unthrottle(struct tty_struct * tty)
3912 {
3913 struct e100_serial *info = (struct e100_serial *)tty->driver_data;
3914 #ifdef SERIAL_DEBUG_THROTTLE
3915 char buf[64];
3916
3917 printk("unthrottle %s: %lu....\n", tty_name(tty, buf),
3918 (unsigned long)tty->ldisc.chars_in_buffer(tty));
3919 #endif
3920 DFLOW(DEBUG_LOG(info->line,"rs_unthrottle ldisc %d\n", tty->ldisc.chars_in_buffer(tty)));
3921 DFLOW(DEBUG_LOG(info->line,"rs_unthrottle flip.count: %i\n", tty->flip.count));
3922 /* Do RTS before XOFF since XOFF might take some time */
3923 if (tty->termios->c_cflag & CRTSCTS) {
3924 /* Assert RTS line */
3925 e100_rts(info, 1);
3926 }
3927
3928 if (I_IXOFF(tty)) {
3929 if (info->x_char)
3930 info->x_char = 0;
3931 else
3932 rs_send_xchar(tty, START_CHAR(tty));
3933 }
3934
3935 }
3936
3937 /*
3938 * ------------------------------------------------------------
3939 * rs_ioctl() and friends
3940 * ------------------------------------------------------------
3941 */
3942
3943 static int
3944 get_serial_info(struct e100_serial * info,
3945 struct serial_struct * retinfo)
3946 {
3947 struct serial_struct tmp;
3948
3949 /* this is all probably wrong, there are a lot of fields
3950 * here that we don't have in e100_serial and maybe we
3951 * should set them to something else than 0.
3952 */
3953
3954 if (!retinfo)
3955 return -EFAULT;
3956 memset(&tmp, 0, sizeof(tmp));
3957 tmp.type = info->type;
3958 tmp.line = info->line;
3959 tmp.port = (int)info->port;
3960 tmp.irq = info->irq;
3961 tmp.flags = info->flags;
3962 tmp.baud_base = info->baud_base;
3963 tmp.close_delay = info->close_delay;
3964 tmp.closing_wait = info->closing_wait;
3965 tmp.custom_divisor = info->custom_divisor;
3966 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
3967 return -EFAULT;
3968 return 0;
3969 }
3970
3971 static int
3972 set_serial_info(struct e100_serial *info,
3973 struct serial_struct *new_info)
3974 {
3975 struct serial_struct new_serial;
3976 struct e100_serial old_info;
3977 int retval = 0;
3978
3979 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
3980 return -EFAULT;
3981
3982 old_info = *info;
3983
3984 if (!capable(CAP_SYS_ADMIN)) {
3985 if ((new_serial.type != info->type) ||
3986 (new_serial.close_delay != info->close_delay) ||
3987 ((new_serial.flags & ~ASYNC_USR_MASK) !=
3988 (info->flags & ~ASYNC_USR_MASK)))
3989 return -EPERM;
3990 info->flags = ((info->flags & ~ASYNC_USR_MASK) |
3991 (new_serial.flags & ASYNC_USR_MASK));
3992 goto check_and_exit;
3993 }
3994
3995 if (info->count > 1)
3996 return -EBUSY;
3997
3998 /*
3999 * OK, past this point, all the error checking has been done.
4000 * At this point, we start making changes.....
4001 */
4002
4003 info->baud_base = new_serial.baud_base;
4004 info->flags = ((info->flags & ~ASYNC_FLAGS) |
4005 (new_serial.flags & ASYNC_FLAGS));
4006 info->custom_divisor = new_serial.custom_divisor;
4007 info->type = new_serial.type;
4008 info->close_delay = new_serial.close_delay;
4009 info->closing_wait = new_serial.closing_wait;
4010 info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
4011
4012 check_and_exit:
4013 if (info->flags & ASYNC_INITIALIZED) {
4014 change_speed(info);
4015 } else
4016 retval = startup(info);
4017 return retval;
4018 }
4019
4020 /*
4021 * get_lsr_info - get line status register info
4022 *
4023 * Purpose: Let user call ioctl() to get info when the UART physically
4024 * is emptied. On bus types like RS485, the transmitter must
4025 * release the bus after transmitting. This must be done when
4026 * the transmit shift register is empty, not be done when the
4027 * transmit holding register is empty. This functionality
4028 * allows an RS485 driver to be written in user space.
4029 */
4030 static int
4031 get_lsr_info(struct e100_serial * info, unsigned int *value)
4032 {
4033 unsigned int result = TIOCSER_TEMT;
4034 #ifndef CONFIG_SVINTO_SIM
4035 unsigned long curr_time = jiffies;
4036 unsigned long curr_time_usec = GET_JIFFIES_USEC();
4037 unsigned long elapsed_usec =
4038 (curr_time - info->last_tx_active) * 1000000/HZ +
4039 curr_time_usec - info->last_tx_active_usec;
4040
4041 if (info->xmit.head != info->xmit.tail ||
4042 elapsed_usec < 2*info->char_time_usec) {
4043 result = 0;
4044 }
4045 #endif
4046
4047 if (copy_to_user(value, &result, sizeof(int)))
4048 return -EFAULT;
4049 return 0;
4050 }
4051
4052 #ifdef SERIAL_DEBUG_IO
4053 struct state_str
4054 {
4055 int state;
4056 const char *str;
4057 };
4058
4059 const struct state_str control_state_str[] = {
4060 {TIOCM_DTR, "DTR" },
4061 {TIOCM_RTS, "RTS"},
4062 {TIOCM_ST, "ST?" },
4063 {TIOCM_SR, "SR?" },
4064 {TIOCM_CTS, "CTS" },
4065 {TIOCM_CD, "CD" },
4066 {TIOCM_RI, "RI" },
4067 {TIOCM_DSR, "DSR" },
4068 {0, NULL }
4069 };
4070
4071 char *get_control_state_str(int MLines, char *s)
4072 {
4073 int i = 0;
4074
4075 s[0]='\0';
4076 while (control_state_str[i].str != NULL) {
4077 if (MLines & control_state_str[i].state) {
4078 if (s[0] != '\0') {
4079 strcat(s, ", ");
4080 }
4081 strcat(s, control_state_str[i].str);
4082 }
4083 i++;
4084 }
4085 return s;
4086 }
4087 #endif
4088
4089 static int
4090 get_modem_info(struct e100_serial * info, unsigned int *value)
4091 {
4092 unsigned int result;
4093 /* Polarity isn't verified */
4094 #if 0 /*def SERIAL_DEBUG_IO */
4095
4096 printk("get_modem_info: RTS: %i DTR: %i CD: %i RI: %i DSR: %i CTS: %i\n",
4097 E100_RTS_GET(info),
4098 E100_DTR_GET(info),
4099 E100_CD_GET(info),
4100 E100_RI_GET(info),
4101 E100_DSR_GET(info),
4102 E100_CTS_GET(info));
4103 #endif
4104
4105 result =
4106 (!E100_RTS_GET(info) ? TIOCM_RTS : 0)
4107 | (!E100_DTR_GET(info) ? TIOCM_DTR : 0)
4108 | (!E100_RI_GET(info) ? TIOCM_RNG : 0)
4109 | (!E100_DSR_GET(info) ? TIOCM_DSR : 0)
4110 | (!E100_CD_GET(info) ? TIOCM_CAR : 0)
4111 | (!E100_CTS_GET(info) ? TIOCM_CTS : 0);
4112
4113 #ifdef SERIAL_DEBUG_IO
4114 printk("e100ser: modem state: %i 0x%08X\n", result, result);
4115 {
4116 char s[100];
4117
4118 get_control_state_str(result, s);
4119 printk("state: %s\n", s);
4120 }
4121 #endif
4122 if (copy_to_user(value, &result, sizeof(int)))
4123 return -EFAULT;
4124 return 0;
4125 }
4126
4127
4128 static int
4129 set_modem_info(struct e100_serial * info, unsigned int cmd,
4130 unsigned int *value)
4131 {
4132 unsigned int arg;
4133
4134 if (copy_from_user(&arg, value, sizeof(int)))
4135 return -EFAULT;
4136
4137 switch (cmd) {
4138 case TIOCMBIS:
4139 if (arg & TIOCM_RTS) {
4140 e100_rts(info, 1);
4141 }
4142 if (arg & TIOCM_DTR) {
4143 e100_dtr(info, 1);
4144 }
4145 /* Handle FEMALE behaviour */
4146 if (arg & TIOCM_RI) {
4147 e100_ri_out(info, 1);
4148 }
4149 if (arg & TIOCM_CD) {
4150 e100_cd_out(info, 1);
4151 }
4152 break;
4153 case TIOCMBIC:
4154 if (arg & TIOCM_RTS) {
4155 e100_rts(info, 0);
4156 }
4157 if (arg & TIOCM_DTR) {
4158 e100_dtr(info, 0);
4159 }
4160 /* Handle FEMALE behaviour */
4161 if (arg & TIOCM_RI) {
4162 e100_ri_out(info, 0);
4163 }
4164 if (arg & TIOCM_CD) {
4165 e100_cd_out(info, 0);
4166 }
4167 break;
4168 case TIOCMSET:
4169 e100_rts(info, arg & TIOCM_RTS);
4170 e100_dtr(info, arg & TIOCM_DTR);
4171 /* Handle FEMALE behaviour */
4172 e100_ri_out(info, arg & TIOCM_RI);
4173 e100_cd_out(info, arg & TIOCM_CD);
4174 break;
4175 default:
4176 return -EINVAL;
4177 }
4178 return 0;
4179 }
4180
4181
4182 static void
4183 rs_break(struct tty_struct *tty, int break_state)
4184 {
4185 struct e100_serial * info = (struct e100_serial *)tty->driver_data;
4186 unsigned long flags;
4187
4188 if (!info->port)
4189 return;
4190
4191 save_flags(flags);
4192 cli();
4193 if (break_state == -1) {
4194 /* Go to manual mode and set the txd pin to 0 */
4195 info->tx_ctrl &= 0x3F; /* Clear bit 7 (txd) and 6 (tr_enable) */
4196 } else {
4197 info->tx_ctrl |= (0x80 | 0x40); /* Set bit 7 (txd) and 6 (tr_enable) */
4198 }
4199 info->port[REG_TR_CTRL] = info->tx_ctrl;
4200 restore_flags(flags);
4201 }
4202
4203 static int
4204 rs_ioctl(struct tty_struct *tty, struct file * file,
4205 unsigned int cmd, unsigned long arg)
4206 {
4207 struct e100_serial * info = (struct e100_serial *)tty->driver_data;
4208
4209 if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
4210 (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD) &&
4211 (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
4212 if (tty->flags & (1 << TTY_IO_ERROR))
4213 return -EIO;
4214 }
4215
4216 switch (cmd) {
4217 case TIOCMGET:
4218 return get_modem_info(info, (unsigned int *) arg);
4219 case TIOCMBIS:
4220 case TIOCMBIC:
4221 case TIOCMSET:
4222 return set_modem_info(info, cmd, (unsigned int *) arg);
4223 case TIOCGSERIAL:
4224 return get_serial_info(info,
4225 (struct serial_struct *) arg);
4226 case TIOCSSERIAL:
4227 return set_serial_info(info,
4228 (struct serial_struct *) arg);
4229 case TIOCSERGETLSR: /* Get line status register */
4230 return get_lsr_info(info, (unsigned int *) arg);
4231
4232 case TIOCSERGSTRUCT:
4233 if (copy_to_user((struct e100_serial *) arg,
4234 info, sizeof(struct e100_serial)))
4235 return -EFAULT;
4236 return 0;
4237
4238 #if defined(CONFIG_ETRAX_RS485)
4239 case TIOCSERSETRS485:
4240 {
4241 struct rs485_control rs485ctrl;
4242 if (copy_from_user(&rs485ctrl, (struct rs485_control*)arg, sizeof(rs485ctrl)))
4243 return -EFAULT;
4244
4245 return e100_enable_rs485(tty, &rs485ctrl);
4246 }
4247
4248 case TIOCSERWRRS485:
4249 {
4250 struct rs485_write rs485wr;
4251 if (copy_from_user(&rs485wr, (struct rs485_write*)arg, sizeof(rs485wr)))
4252 return -EFAULT;
4253
4254 return e100_write_rs485(tty, 1, rs485wr.outc, rs485wr.outc_size);
4255 }
4256 #endif
4257
4258 default:
4259 return -ENOIOCTLCMD;
4260 }
4261 return 0;
4262 }
4263
4264 static void
4265 rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
4266 {
4267 struct e100_serial *info = (struct e100_serial *)tty->driver_data;
4268
4269 if (tty->termios->c_cflag == old_termios->c_cflag &&
4270 tty->termios->c_iflag == old_termios->c_iflag)
4271 return;
4272
4273 change_speed(info);
4274
4275 /* Handle turning off CRTSCTS */
4276 if ((old_termios->c_cflag & CRTSCTS) &&
4277 !(tty->termios->c_cflag & CRTSCTS)) {
4278 tty->hw_stopped = 0;
4279 rs_start(tty);
4280 }
4281
4282 }
4283
4284 /* In debugport.c - register a console write function that uses the normal
4285 * serial driver
4286 */
4287 typedef int (*debugport_write_function)(int i, const char *buf, unsigned int len);
4288
4289 extern debugport_write_function debug_write_function;
4290
4291 static int rs_debug_write_function(int i, const char *buf, unsigned int len)
4292 {
4293 int cnt;
4294 int written = 0;
4295 struct tty_struct *tty;
4296 static int recurse_cnt = 0;
4297
4298 tty = rs_table[i].tty;
4299 if (tty) {
4300 unsigned long flags;
4301 if (recurse_cnt > 5) /* We skip this debug output */
4302 return 1;
4303
4304 local_irq_save(flags);
4305 recurse_cnt++;
4306 local_irq_restore(flags);
4307 do {
4308 cnt = rs_write(tty, 0, buf + written, len);
4309 if (cnt >= 0) {
4310 written += cnt;
4311 buf += cnt;
4312 len -= cnt;
4313 } else
4314 len = cnt;
4315 } while(len > 0);
4316 local_irq_save(flags);
4317 recurse_cnt--;
4318 local_irq_restore(flags);
4319 return 1;
4320 }
4321 return 0;
4322 }
4323
4324 /*
4325 * ------------------------------------------------------------
4326 * rs_close()
4327 *
4328 * This routine is called when the serial port gets closed. First, we
4329 * wait for the last remaining data to be sent. Then, we unlink its
4330 * S structure from the interrupt chain if necessary, and we free
4331 * that IRQ if nothing is left in the chain.
4332 * ------------------------------------------------------------
4333 */
4334 static void
4335 rs_close(struct tty_struct *tty, struct file * filp)
4336 {
4337 struct e100_serial * info = (struct e100_serial *)tty->driver_data;
4338 unsigned long flags;
4339
4340 if (!info)
4341 return;
4342
4343 /* interrupts are disabled for this entire function */
4344
4345 save_flags(flags);
4346 cli();
4347
4348 if (tty_hung_up_p(filp)) {
4349 restore_flags(flags);
4350 return;
4351 }
4352
4353 #ifdef SERIAL_DEBUG_OPEN
4354 printk("[%d] rs_close ttyS%d, count = %d\n", current->pid,
4355 info->line, info->count);
4356 #endif
4357 if ((tty->count == 1) && (info->count != 1)) {
4358 /*
4359 * Uh, oh. tty->count is 1, which means that the tty
4360 * structure will be freed. Info->count should always
4361 * be one in these conditions. If it's greater than
4362 * one, we've got real problems, since it means the
4363 * serial port won't be shutdown.
4364 */
4365 printk(KERN_CRIT
4366 "rs_close: bad serial port count; tty->count is 1, "
4367 "info->count is %d\n", info->count);
4368 info->count = 1;
4369 }
4370 if (--info->count < 0) {
4371 printk(KERN_CRIT "rs_close: bad serial port count for ttyS%d: %d\n",
4372 info->line, info->count);
4373 info->count = 0;
4374 }
4375 if (info->count) {
4376 restore_flags(flags);
4377 return;
4378 }
4379 info->flags |= ASYNC_CLOSING;
4380 /*
4381 * Save the termios structure, since this port may have
4382 * separate termios for callout and dialin.
4383 */
4384 if (info->flags & ASYNC_NORMAL_ACTIVE)
4385 info->normal_termios = *tty->termios;
4386 /*
4387 * Now we wait for the transmit buffer to clear; and we notify
4388 * the line discipline to only process XON/XOFF characters.
4389 */
4390 tty->closing = 1;
4391 if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE)
4392 tty_wait_until_sent(tty, info->closing_wait);
4393 /*
4394 * At this point we stop accepting input. To do this, we
4395 * disable the serial receiver and the DMA receive interrupt.
4396 */
4397 #ifdef SERIAL_HANDLE_EARLY_ERRORS
4398 e100_disable_serial_data_irq(info);
4399 #endif
4400
4401 #ifndef CONFIG_SVINTO_SIM
4402 e100_disable_rx(info);
4403 e100_disable_rx_irq(info);
4404
4405 if (info->flags & ASYNC_INITIALIZED) {
4406 /*
4407 * Before we drop DTR, make sure the UART transmitter
4408 * has completely drained; this is especially
4409 * important as we have a transmit FIFO!
4410 */
4411 rs_wait_until_sent(tty, HZ);
4412 }
4413 #endif
4414
4415 shutdown(info);
4416 if (tty->driver->flush_buffer)
4417 tty->driver->flush_buffer(tty);
4418 if (tty->ldisc.flush_buffer)
4419 tty->ldisc.flush_buffer(tty);
4420 tty->closing = 0;
4421 info->event = 0;
4422 info->tty = 0;
4423 if (info->blocked_open) {
4424 if (info->close_delay) {
4425 set_current_state(TASK_INTERRUPTIBLE);
4426 schedule_timeout(info->close_delay);
4427 }
4428 wake_up_interruptible(&info->open_wait);
4429 }
4430 info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
4431 wake_up_interruptible(&info->close_wait);
4432 restore_flags(flags);
4433
4434 /* port closed */
4435
4436 #if defined(CONFIG_ETRAX_RS485)
4437 if (info->rs485.enabled) {
4438 info->rs485.enabled = 0;
4439 #if defined(CONFIG_ETRAX_RS485_ON_PA)
4440 *R_PORT_PA_DATA = port_pa_data_shadow &= ~(1 << rs485_pa_bit);
4441 #endif
4442 #if defined(CONFIG_ETRAX_RS485_ON_PORT_G)
4443 REG_SHADOW_SET(R_PORT_G_DATA, port_g_data_shadow,
4444 rs485_port_g_bit, 0);
4445 #endif
4446 #if defined(CONFIG_ETRAX_RS485_LTC1387)
4447 REG_SHADOW_SET(R_PORT_G_DATA, port_g_data_shadow,
4448 CONFIG_ETRAX_RS485_LTC1387_DXEN_PORT_G_BIT, 0);
4449 REG_SHADOW_SET(R_PORT_G_DATA, port_g_data_shadow,
4450 CONFIG_ETRAX_RS485_LTC1387_RXEN_PORT_G_BIT, 0);
4451 #endif
4452 }
4453 #endif
4454 }
4455
4456 /*
4457 * rs_wait_until_sent() --- wait until the transmitter is empty
4458 */
4459 static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
4460 {
4461 unsigned long orig_jiffies;
4462 struct e100_serial *info = (struct e100_serial *)tty->driver_data;
4463 unsigned long curr_time = jiffies;
4464 unsigned long curr_time_usec = GET_JIFFIES_USEC();
4465 long elapsed_usec =
4466 (curr_time - info->last_tx_active) * (1000000/HZ) +
4467 curr_time_usec - info->last_tx_active_usec;
4468
4469 /*
4470 * Check R_DMA_CHx_STATUS bit 0-6=number of available bytes in FIFO
4471 * R_DMA_CHx_HWSW bit 31-16=nbr of bytes left in DMA buffer (0=64k)
4472 */
4473 orig_jiffies = jiffies;
4474 while (info->xmit.head != info->xmit.tail || /* More in send queue */
4475 (*info->ostatusadr & 0x007f) || /* more in FIFO */
4476 (elapsed_usec < 2*info->char_time_usec)) {
4477 set_current_state(TASK_INTERRUPTIBLE);
4478 schedule_timeout(1);
4479 if (signal_pending(current))
4480 break;
4481 if (timeout && time_after(jiffies, orig_jiffies + timeout))
4482 break;
4483 curr_time = jiffies;
4484 curr_time_usec = GET_JIFFIES_USEC();
4485 elapsed_usec =
4486 (curr_time - info->last_tx_active) * (1000000/HZ) +
4487 curr_time_usec - info->last_tx_active_usec;
4488 }
4489 set_current_state(TASK_RUNNING);
4490 }
4491
4492 /*
4493 * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
4494 */
4495 void
4496 rs_hangup(struct tty_struct *tty)
4497 {
4498 struct e100_serial * info = (struct e100_serial *)tty->driver_data;
4499
4500 rs_flush_buffer(tty);
4501 shutdown(info);
4502 info->event = 0;
4503 info->count = 0;
4504 info->flags &= ~ASYNC_NORMAL_ACTIVE;
4505 info->tty = 0;
4506 wake_up_interruptible(&info->open_wait);
4507 }
4508
4509 /*
4510 * ------------------------------------------------------------
4511 * rs_open() and friends
4512 * ------------------------------------------------------------
4513 */
4514 static int
4515 block_til_ready(struct tty_struct *tty, struct file * filp,
4516 struct e100_serial *info)
4517 {
4518 DECLARE_WAITQUEUE(wait, current);
4519 unsigned long flags;
4520 int retval;
4521 int do_clocal = 0, extra_count = 0;
4522
4523 /*
4524 * If the device is in the middle of being closed, then block
4525 * until it's done, and then try again.
4526 */
4527 if (tty_hung_up_p(filp) ||
4528 (info->flags & ASYNC_CLOSING)) {
4529 if (info->flags & ASYNC_CLOSING)
4530 interruptible_sleep_on(&info->close_wait);
4531 #ifdef SERIAL_DO_RESTART
4532 if (info->flags & ASYNC_HUP_NOTIFY)
4533 return -EAGAIN;
4534 else
4535 return -ERESTARTSYS;
4536 #else
4537 return -EAGAIN;
4538 #endif
4539 }
4540
4541 /*
4542 * If non-blocking mode is set, or the port is not enabled,
4543 * then make the check up front and then exit.
4544 */
4545 if ((filp->f_flags & O_NONBLOCK) ||
4546 (tty->flags & (1 << TTY_IO_ERROR))) {
4547 info->flags |= ASYNC_NORMAL_ACTIVE;
4548 return 0;
4549 }
4550
4551 if (tty->termios->c_cflag & CLOCAL) {
4552 do_clocal = 1;
4553 }
4554
4555 /*
4556 * Block waiting for the carrier detect and the line to become
4557 * free (i.e., not in use by the callout). While we are in
4558 * this loop, info->count is dropped by one, so that
4559 * rs_close() knows when to free things. We restore it upon
4560 * exit, either normal or abnormal.
4561 */
4562 retval = 0;
4563 add_wait_queue(&info->open_wait, &wait);
4564 #ifdef SERIAL_DEBUG_OPEN
4565 printk("block_til_ready before block: ttyS%d, count = %d\n",
4566 info->line, info->count);
4567 #endif
4568 save_flags(flags);
4569 cli();
4570 if (!tty_hung_up_p(filp)) {
4571 extra_count++;
4572 info->count--;
4573 }
4574 restore_flags(flags);
4575 info->blocked_open++;
4576 while (1) {
4577 save_flags(flags);
4578 cli();
4579 /* assert RTS and DTR */
4580 e100_rts(info, 1);
4581 e100_dtr(info, 1);
4582 restore_flags(flags);
4583 set_current_state(TASK_INTERRUPTIBLE);
4584 if (tty_hung_up_p(filp) ||
4585 !(info->flags & ASYNC_INITIALIZED)) {
4586 #ifdef SERIAL_DO_RESTART
4587 if (info->flags & ASYNC_HUP_NOTIFY)
4588 retval = -EAGAIN;
4589 else
4590 retval = -ERESTARTSYS;
4591 #else
4592 retval = -EAGAIN;
4593 #endif
4594 break;
4595 }
4596 if (!(info->flags & ASYNC_CLOSING) && do_clocal)
4597 /* && (do_clocal || DCD_IS_ASSERTED) */
4598 break;
4599 if (signal_pending(current)) {
4600 retval = -ERESTARTSYS;
4601 break;
4602 }
4603 #ifdef SERIAL_DEBUG_OPEN
4604 printk("block_til_ready blocking: ttyS%d, count = %d\n",
4605 info->line, info->count);
4606 #endif
4607 schedule();
4608 }
4609 set_current_state(TASK_RUNNING);
4610 remove_wait_queue(&info->open_wait, &wait);
4611 if (extra_count)
4612 info->count++;
4613 info->blocked_open--;
4614 #ifdef SERIAL_DEBUG_OPEN
4615 printk("block_til_ready after blocking: ttyS%d, count = %d\n",
4616 info->line, info->count);
4617 #endif
4618 if (retval)
4619 return retval;
4620 info->flags |= ASYNC_NORMAL_ACTIVE;
4621 return 0;
4622 }
4623
4624 /*
4625 * This routine is called whenever a serial port is opened.
4626 * It performs the serial-specific initialization for the tty structure.
4627 */
4628 static int
4629 rs_open(struct tty_struct *tty, struct file * filp)
4630 {
4631 struct e100_serial *info;
4632 int retval, line;
4633 unsigned long page;
4634
4635 /* find which port we want to open */
4636
4637 line = tty->index;
4638
4639 if (line < 0 || line >= NR_PORTS)
4640 return -ENODEV;
4641
4642 /* find the corresponding e100_serial struct in the table */
4643 info = rs_table + line;
4644
4645 /* don't allow the opening of ports that are not enabled in the HW config */
4646 if (!info->enabled)
4647 return -ENODEV;
4648
4649 #ifdef SERIAL_DEBUG_OPEN
4650 printk("[%d] rs_open %s, count = %d\n", current->pid, tty->name,
4651 info->count);
4652 #endif
4653
4654 info->count++;
4655 tty->driver_data = info;
4656 info->tty = tty;
4657
4658 info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
4659
4660 if (!tmp_buf) {
4661 page = get_zeroed_page(GFP_KERNEL);
4662 if (!page) {
4663 return -ENOMEM;
4664 }
4665 if (tmp_buf)
4666 free_page(page);
4667 else
4668 tmp_buf = (unsigned char *) page;
4669 }
4670
4671 /*
4672 * If the port is in the middle of closing, bail out now
4673 */
4674 if (tty_hung_up_p(filp) ||
4675 (info->flags & ASYNC_CLOSING)) {
4676 if (info->flags & ASYNC_CLOSING)
4677 interruptible_sleep_on(&info->close_wait);
4678 #ifdef SERIAL_DO_RESTART
4679 return ((info->flags & ASYNC_HUP_NOTIFY) ?
4680 -EAGAIN : -ERESTARTSYS);
4681 #else
4682 return -EAGAIN;
4683 #endif
4684 }
4685
4686 /*
4687 * Start up the serial port
4688 */
4689
4690 retval = startup(info);
4691 if (retval)
4692 return retval;
4693
4694 retval = block_til_ready(tty, filp, info);
4695 if (retval) {
4696 #ifdef SERIAL_DEBUG_OPEN
4697 printk("rs_open returning after block_til_ready with %d\n",
4698 retval);
4699 #endif
4700 return retval;
4701 }
4702
4703 if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
4704 *tty->termios = info->normal_termios;
4705 change_speed(info);
4706 }
4707
4708 #ifdef SERIAL_DEBUG_OPEN
4709 printk("rs_open ttyS%d successful...\n", info->line);
4710 #endif
4711 DLOG_INT_TRIG( log_int_pos = 0);
4712
4713 DFLIP( if (info->line == SERIAL_DEBUG_LINE) {
4714 info->icount.rx = 0;
4715 } );
4716
4717 return 0;
4718 }
4719
4720 /*
4721 * /proc fs routines....
4722 */
4723
4724 extern _INLINE_ int line_info(char *buf, struct e100_serial *info)
4725 {
4726 char stat_buf[30];
4727 int ret;
4728 unsigned long tmp;
4729
4730 ret = sprintf(buf, "%d: uart:E100 port:%lX irq:%d",
4731 info->line, (unsigned long)info->port, info->irq);
4732
4733 if (!info->port || (info->type == PORT_UNKNOWN)) {
4734 ret += sprintf(buf+ret, "\n");
4735 return ret;
4736 }
4737
4738 stat_buf[0] = 0;
4739 stat_buf[1] = 0;
4740 if (!E100_RTS_GET(info))
4741 strcat(stat_buf, "|RTS");
4742 if (!E100_CTS_GET(info))
4743 strcat(stat_buf, "|CTS");
4744 if (!E100_DTR_GET(info))
4745 strcat(stat_buf, "|DTR");
4746 if (!E100_DSR_GET(info))
4747 strcat(stat_buf, "|DSR");
4748 if (!E100_CD_GET(info))
4749 strcat(stat_buf, "|CD");
4750 if (!E100_RI_GET(info))
4751 strcat(stat_buf, "|RI");
4752
4753 ret += sprintf(buf+ret, " baud:%d", info->baud);
4754
4755 ret += sprintf(buf+ret, " tx:%lu rx:%lu",
4756 (unsigned long)info->icount.tx,
4757 (unsigned long)info->icount.rx);
4758 tmp = CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
4759 if (tmp) {
4760 ret += sprintf(buf+ret, " tx_pend:%lu/%lu",
4761 (unsigned long)tmp,
4762 (unsigned long)SERIAL_XMIT_SIZE);
4763 }
4764
4765 ret += sprintf(buf+ret, " rx_pend:%lu/%lu",
4766 (unsigned long)info->recv_cnt,
4767 (unsigned long)info->max_recv_cnt);
4768
4769 #if 1
4770 if (info->tty) {
4771
4772 if (info->tty->stopped)
4773 ret += sprintf(buf+ret, " stopped:%i",
4774 (int)info->tty->stopped);
4775 if (info->tty->hw_stopped)
4776 ret += sprintf(buf+ret, " hw_stopped:%i",
4777 (int)info->tty->hw_stopped);
4778 }
4779
4780 {
4781 unsigned char rstat = info->port[REG_STATUS];
4782 if (rstat & IO_MASK(R_SERIAL0_STATUS, xoff_detect) )
4783 ret += sprintf(buf+ret, " xoff_detect:1");
4784 }
4785
4786 #endif
4787
4788
4789
4790
4791 if (info->icount.frame)
4792 ret += sprintf(buf+ret, " fe:%lu",
4793 (unsigned long)info->icount.frame);
4794
4795 if (info->icount.parity)
4796 ret += sprintf(buf+ret, " pe:%lu",
4797 (unsigned long)info->icount.parity);
4798
4799 if (info->icount.brk)
4800 ret += sprintf(buf+ret, " brk:%lu",
4801 (unsigned long)info->icount.brk);
4802
4803 if (info->icount.overrun)
4804 ret += sprintf(buf+ret, " oe:%lu",
4805 (unsigned long)info->icount.overrun);
4806
4807 /*
4808 * Last thing is the RS-232 status lines
4809 */
4810 ret += sprintf(buf+ret, " %s\n", stat_buf+1);
4811 return ret;
4812 }
4813
4814 int rs_read_proc(char *page, char **start, off_t off, int count,
4815 int *eof, void *data)
4816 {
4817 int i, len = 0, l;
4818 off_t begin = 0;
4819
4820 len += sprintf(page, "serinfo:1.0 driver:%s\n",
4821 serial_version);
4822 for (i = 0; i < NR_PORTS && len < 4000; i++) {
4823 if (!rs_table[i].enabled)
4824 continue;
4825 l = line_info(page + len, &rs_table[i]);
4826 len += l;
4827 if (len+begin > off+count)
4828 goto done;
4829 if (len+begin < off) {
4830 begin += len;
4831 len = 0;
4832 }
4833 }
4834 #ifdef DEBUG_LOG_INCLUDED
4835 for (i = 0; i < debug_log_pos; i++) {
4836 len += sprintf(page + len, "%-4i %lu.%lu ", i, debug_log[i].time, timer_data_to_ns(debug_log[i].timer_data));
4837 len += sprintf(page + len, debug_log[i].string, debug_log[i].value);
4838 if (len+begin > off+count)
4839 goto done;
4840 if (len+begin < off) {
4841 begin += len;
4842 len = 0;
4843 }
4844 }
4845 len += sprintf(page + len, "debug_log %i/%i %li bytes\n",
4846 i, DEBUG_LOG_SIZE, begin+len);
4847 debug_log_pos = 0;
4848 #endif
4849
4850 *eof = 1;
4851 done:
4852 if (off >= len+begin)
4853 return 0;
4854 *start = page + (off-begin);
4855 return ((count < begin+len-off) ? count : begin+len-off);
4856 }
4857
4858 /* Finally, routines used to initialize the serial driver. */
4859
4860 static void
4861 show_serial_version(void)
4862 {
4863 printk(KERN_INFO
4864 "ETRAX 100LX serial-driver %s, (c) 2000-2004 Axis Communications AB\r\n",
4865 &serial_version[11]); /* "$Revision: x.yy" */
4866 }
4867
4868 /* rs_init inits the driver at boot (using the module_init chain) */
4869
4870 static struct tty_operations rs_ops = {
4871 .open = rs_open,
4872 .close = rs_close,
4873 .write = rs_write,
4874 .flush_chars = rs_flush_chars,
4875 .write_room = rs_write_room,
4876 .chars_in_buffer = rs_chars_in_buffer,
4877 .flush_buffer = rs_flush_buffer,
4878 .ioctl = rs_ioctl,
4879 .throttle = rs_throttle,
4880 .unthrottle = rs_unthrottle,
4881 .set_termios = rs_set_termios,
4882 .stop = rs_stop,
4883 .start = rs_start,
4884 .hangup = rs_hangup,
4885 .break_ctl = rs_break,
4886 .send_xchar = rs_send_xchar,
4887 .wait_until_sent = rs_wait_until_sent,
4888 .read_proc = rs_read_proc,
4889 };
4890
4891 static int __init
4892 rs_init(void)
4893 {
4894 int i;
4895 struct e100_serial *info;
4896 struct tty_driver *driver = alloc_tty_driver(NR_PORTS);
4897
4898 if (!driver)
4899 return -ENOMEM;
4900
4901 show_serial_version();
4902
4903 /* Setup the timed flush handler system */
4904
4905 #if !defined(CONFIG_ETRAX_SERIAL_FAST_TIMER)
4906 init_timer(&flush_timer);
4907 flush_timer.function = timed_flush_handler;
4908 mod_timer(&flush_timer, jiffies + CONFIG_ETRAX_SERIAL_RX_TIMEOUT_TICKS);
4909 #endif
4910
4911 /* Initialize the tty_driver structure */
4912
4913 driver->driver_name = "serial";
4914 driver->name = "ttyS";
4915 driver->major = TTY_MAJOR;
4916 driver->minor_start = 64;
4917 driver->type = TTY_DRIVER_TYPE_SERIAL;
4918 driver->subtype = SERIAL_TYPE_NORMAL;
4919 driver->init_termios = tty_std_termios;
4920 driver->init_termios.c_cflag =
4921 B115200 | CS8 | CREAD | HUPCL | CLOCAL; /* is normally B9600 default... */
4922 driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
4923 driver->termios = serial_termios;
4924 driver->termios_locked = serial_termios_locked;
4925
4926 tty_set_operations(driver, &rs_ops);
4927 serial_driver = driver;
4928 if (tty_register_driver(driver))
4929 panic("Couldn't register serial driver\n");
4930 /* do some initializing for the separate ports */
4931
4932 for (i = 0, info = rs_table; i < NR_PORTS; i++,info++) {
4933 info->uses_dma_in = 0;
4934 info->uses_dma_out = 0;
4935 info->line = i;
4936 info->tty = 0;
4937 info->type = PORT_ETRAX;
4938 info->tr_running = 0;
4939 info->forced_eop = 0;
4940 info->baud_base = DEF_BAUD_BASE;
4941 info->custom_divisor = 0;
4942 info->flags = 0;
4943 info->close_delay = 5*HZ/10;
4944 info->closing_wait = 30*HZ;
4945 info->x_char = 0;
4946 info->event = 0;
4947 info->count = 0;
4948 info->blocked_open = 0;
4949 info->normal_termios = driver->init_termios;
4950 init_waitqueue_head(&info->open_wait);
4951 init_waitqueue_head(&info->close_wait);
4952 info->xmit.buf = NULL;
4953 info->xmit.tail = info->xmit.head = 0;
4954 info->first_recv_buffer = info->last_recv_buffer = NULL;
4955 info->recv_cnt = info->max_recv_cnt = 0;
4956 info->last_tx_active_usec = 0;
4957 info->last_tx_active = 0;
4958
4959 #if defined(CONFIG_ETRAX_RS485)
4960 /* Set sane defaults */
4961 info->rs485.rts_on_send = 0;
4962 info->rs485.rts_after_sent = 1;
4963 info->rs485.delay_rts_before_send = 0;
4964 info->rs485.enabled = 0;
4965 #endif
4966 INIT_WORK(&info->work, do_softint, info);
4967
4968 if (info->enabled) {
4969 printk(KERN_INFO "%s%d at 0x%x is a builtin UART with DMA\n",
4970 serial_driver->name, info->line, (unsigned int)info->port);
4971 }
4972 }
4973 #ifdef CONFIG_ETRAX_FAST_TIMER
4974 #ifdef CONFIG_ETRAX_SERIAL_FAST_TIMER
4975 memset(fast_timers, 0, sizeof(fast_timers));
4976 #endif
4977 #ifdef CONFIG_ETRAX_RS485
4978 memset(fast_timers_rs485, 0, sizeof(fast_timers_rs485));
4979 #endif
4980 fast_timer_init();
4981 #endif
4982
4983 #ifndef CONFIG_SVINTO_SIM
4984 /* Not needed in simulator. May only complicate stuff. */
4985 /* hook the irq's for DMA channel 6 and 7, serial output and input, and some more... */
4986
4987 if (request_irq(SERIAL_IRQ_NBR, ser_interrupt, SA_SHIRQ | SA_INTERRUPT, "serial ", NULL))
4988 panic("irq8");
4989
4990 #ifdef CONFIG_ETRAX_SERIAL_PORT0
4991 #ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA6_OUT
4992 if (request_irq(SER0_DMA_TX_IRQ_NBR, tr_interrupt, SA_INTERRUPT, "serial 0 dma tr", NULL))
4993 panic("irq22");
4994 #endif
4995 #ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA7_IN
4996 if (request_irq(SER0_DMA_RX_IRQ_NBR, rec_interrupt, SA_INTERRUPT, "serial 0 dma rec", NULL))
4997 panic("irq23");
4998 #endif
4999 #endif
5000
5001 #ifdef CONFIG_ETRAX_SERIAL_PORT1
5002 #ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA8_OUT
5003 if (request_irq(SER1_DMA_TX_IRQ_NBR, tr_interrupt, SA_INTERRUPT, "serial 1 dma tr", NULL))
5004 panic("irq24");
5005 #endif
5006 #ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA9_IN
5007 if (request_irq(SER1_DMA_RX_IRQ_NBR, rec_interrupt, SA_INTERRUPT, "serial 1 dma rec", NULL))
5008 panic("irq25");
5009 #endif
5010 #endif
5011 #ifdef CONFIG_ETRAX_SERIAL_PORT2
5012 /* DMA Shared with par0 (and SCSI0 and ATA) */
5013 #ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA2_OUT
5014 if (request_irq(SER2_DMA_TX_IRQ_NBR, tr_interrupt, SA_SHIRQ | SA_INTERRUPT, "serial 2 dma tr", NULL))
5015 panic("irq18");
5016 #endif
5017 #ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA3_IN
5018 if (request_irq(SER2_DMA_RX_IRQ_NBR, rec_interrupt, SA_SHIRQ | SA_INTERRUPT, "serial 2 dma rec", NULL))
5019 panic("irq19");
5020 #endif
5021 #endif
5022 #ifdef CONFIG_ETRAX_SERIAL_PORT3
5023 /* DMA Shared with par1 (and SCSI1 and Extern DMA 0) */
5024 #ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA4_OUT
5025 if (request_irq(SER3_DMA_TX_IRQ_NBR, tr_interrupt, SA_SHIRQ | SA_INTERRUPT, "serial 3 dma tr", NULL))
5026 panic("irq20");
5027 #endif
5028 #ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA5_IN
5029 if (request_irq(SER3_DMA_RX_IRQ_NBR, rec_interrupt, SA_SHIRQ | SA_INTERRUPT, "serial 3 dma rec", NULL))
5030 panic("irq21");
5031 #endif
5032 #endif
5033
5034 #ifdef CONFIG_ETRAX_SERIAL_FLUSH_DMA_FAST
5035 if (request_irq(TIMER1_IRQ_NBR, timeout_interrupt, SA_SHIRQ | SA_INTERRUPT,
5036 "fast serial dma timeout", NULL)) {
5037 printk(KERN_CRIT "err: timer1 irq\n");
5038 }
5039 #endif
5040 #endif /* CONFIG_SVINTO_SIM */
5041 debug_write_function = rs_debug_write_function;
5042 return 0;
5043 }
5044
5045 /* this makes sure that rs_init is called during kernel boot */
5046
5047 module_init(rs_init);
5048
5049 /*
5050 * register_serial and unregister_serial allows for serial ports to be
5051 * configured at run-time, to support PCMCIA modems.
5052 */
5053 int
5054 register_serial(struct serial_struct *req)
5055 {
5056 return -1;
5057 }
5058
5059 void unregister_serial(int line)
5060 {
5061 }
5062
|
This page was automatically generated by the
LXR engine.
|