ia64/linux-2.6.18-xen.hg

view drivers/char/specialix.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
1 /*
2 * specialix.c -- specialix IO8+ multiport serial driver.
3 *
4 * Copyright (C) 1997 Roger Wolff (R.E.Wolff@BitWizard.nl)
5 * Copyright (C) 1994-1996 Dmitry Gorodchanin (pgmdsg@ibi.com)
6 *
7 * Specialix pays for the development and support of this driver.
8 * Please DO contact io8-linux@specialix.co.uk if you require
9 * support. But please read the documentation (specialix.txt)
10 * first.
11 *
12 * This driver was developped in the BitWizard linux device
13 * driver service. If you require a linux device driver for your
14 * product, please contact devices@BitWizard.nl for a quote.
15 *
16 * This code is firmly based on the riscom/8 serial driver,
17 * written by Dmitry Gorodchanin. The specialix IO8+ card
18 * programming information was obtained from the CL-CD1865 Data
19 * Book, and Specialix document number 6200059: IO8+ Hardware
20 * Functional Specification.
21 *
22 * This program is free software; you can redistribute it and/or
23 * modify it under the terms of the GNU General Public License as
24 * published by the Free Software Foundation; either version 2 of
25 * the License, or (at your option) any later version.
26 *
27 * This program is distributed in the hope that it will be
28 * useful, but WITHOUT ANY WARRANTY; without even the implied
29 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
30 * PURPOSE. See the GNU General Public License for more details.
31 *
32 * You should have received a copy of the GNU General Public
33 * License along with this program; if not, write to the Free
34 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
35 * USA.
36 *
37 * Revision history:
38 *
39 * Revision 1.0: April 1st 1997.
40 * Initial release for alpha testing.
41 * Revision 1.1: April 14th 1997.
42 * Incorporated Richard Hudsons suggestions,
43 * removed some debugging printk's.
44 * Revision 1.2: April 15th 1997.
45 * Ported to 2.1.x kernels.
46 * Revision 1.3: April 17th 1997
47 * Backported to 2.0. (Compatibility macros).
48 * Revision 1.4: April 18th 1997
49 * Fixed DTR/RTS bug that caused the card to indicate
50 * "don't send data" to a modem after the password prompt.
51 * Fixed bug for premature (fake) interrupts.
52 * Revision 1.5: April 19th 1997
53 * fixed a minor typo in the header file, cleanup a little.
54 * performance warnings are now MAXed at once per minute.
55 * Revision 1.6: May 23 1997
56 * Changed the specialix=... format to include interrupt.
57 * Revision 1.7: May 27 1997
58 * Made many more debug printk's a compile time option.
59 * Revision 1.8: Jul 1 1997
60 * port to linux-2.1.43 kernel.
61 * Revision 1.9: Oct 9 1998
62 * Added stuff for the IO8+/PCI version.
63 * Revision 1.10: Oct 22 1999 / Jan 21 2000.
64 * Added stuff for setserial.
65 * Nicolas Mailhot (Nicolas.Mailhot@email.enst.fr)
66 *
67 */
69 #define VERSION "1.11"
72 /*
73 * There is a bunch of documentation about the card, jumpers, config
74 * settings, restrictions, cables, device names and numbers in
75 * Documentation/specialix.txt
76 */
78 #include <linux/module.h>
80 #include <asm/io.h>
81 #include <linux/kernel.h>
82 #include <linux/sched.h>
83 #include <linux/ioport.h>
84 #include <linux/interrupt.h>
85 #include <linux/errno.h>
86 #include <linux/tty.h>
87 #include <linux/tty_flip.h>
88 #include <linux/mm.h>
89 #include <linux/serial.h>
90 #include <linux/fcntl.h>
91 #include <linux/major.h>
92 #include <linux/delay.h>
93 #include <linux/pci.h>
94 #include <linux/init.h>
95 #include <asm/uaccess.h>
97 #include "specialix_io8.h"
98 #include "cd1865.h"
101 /*
102 This driver can spew a whole lot of debugging output at you. If you
103 need maximum performance, you should disable the DEBUG define. To
104 aid in debugging in the field, I'm leaving the compile-time debug
105 features enabled, and disable them "runtime". That allows me to
106 instruct people with problems to enable debugging without requiring
107 them to recompile...
108 */
109 #define DEBUG
111 static int sx_debug;
112 static int sx_rxfifo = SPECIALIX_RXFIFO;
114 #ifdef DEBUG
115 #define dprintk(f, str...) if (sx_debug & f) printk (str)
116 #else
117 #define dprintk(f, str...) /* nothing */
118 #endif
120 #define SX_DEBUG_FLOW 0x0001
121 #define SX_DEBUG_DATA 0x0002
122 #define SX_DEBUG_PROBE 0x0004
123 #define SX_DEBUG_CHAN 0x0008
124 #define SX_DEBUG_INIT 0x0010
125 #define SX_DEBUG_RX 0x0020
126 #define SX_DEBUG_TX 0x0040
127 #define SX_DEBUG_IRQ 0x0080
128 #define SX_DEBUG_OPEN 0x0100
129 #define SX_DEBUG_TERMIOS 0x0200
130 #define SX_DEBUG_SIGNALS 0x0400
131 #define SX_DEBUG_FIFO 0x0800
134 #define func_enter() dprintk (SX_DEBUG_FLOW, "io8: enter %s\n",__FUNCTION__)
135 #define func_exit() dprintk (SX_DEBUG_FLOW, "io8: exit %s\n", __FUNCTION__)
137 #define jiffies_from_ms(a) ((((a) * HZ)/1000)+1)
140 /* Configurable options: */
142 /* Am I paranoid or not ? ;-) */
143 #define SPECIALIX_PARANOIA_CHECK
145 /* Do I trust the IRQ from the card? (enabeling it doesn't seem to help)
146 When the IRQ routine leaves the chip in a state that is keeps on
147 requiring attention, the timer doesn't help either. */
148 #undef SPECIALIX_TIMER
150 #ifdef SPECIALIX_TIMER
151 static int sx_poll = HZ;
152 #endif
156 /*
157 * The following defines are mostly for testing purposes. But if you need
158 * some nice reporting in your syslog, you can define them also.
159 */
160 #undef SX_REPORT_FIFO
161 #undef SX_REPORT_OVERRUN
165 #ifdef CONFIG_SPECIALIX_RTSCTS
166 #define SX_CRTSCTS(bla) 1
167 #else
168 #define SX_CRTSCTS(tty) C_CRTSCTS(tty)
169 #endif
172 /* Used to be outb (0xff, 0x80); */
173 #define short_pause() udelay (1)
176 #define SPECIALIX_LEGAL_FLAGS \
177 (ASYNC_HUP_NOTIFY | ASYNC_SAK | ASYNC_SPLIT_TERMIOS | \
178 ASYNC_SPD_HI | ASYNC_SPEED_VHI | ASYNC_SESSION_LOCKOUT | \
179 ASYNC_PGRP_LOCKOUT | ASYNC_CALLOUT_NOHUP)
181 #undef RS_EVENT_WRITE_WAKEUP
182 #define RS_EVENT_WRITE_WAKEUP 0
184 static struct tty_driver *specialix_driver;
185 static unsigned char * tmp_buf;
187 static unsigned long baud_table[] = {
188 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
189 9600, 19200, 38400, 57600, 115200, 0,
190 };
192 static struct specialix_board sx_board[SX_NBOARD] = {
193 { 0, SX_IOBASE1, 9, },
194 { 0, SX_IOBASE2, 11, },
195 { 0, SX_IOBASE3, 12, },
196 { 0, SX_IOBASE4, 15, },
197 };
199 static struct specialix_port sx_port[SX_NBOARD * SX_NPORT];
202 #ifdef SPECIALIX_TIMER
203 static struct timer_list missed_irq_timer;
204 static irqreturn_t sx_interrupt(int irq, void * dev_id, struct pt_regs * regs);
205 #endif
209 static inline int sx_paranoia_check(struct specialix_port const * port,
210 char *name, const char *routine)
211 {
212 #ifdef SPECIALIX_PARANOIA_CHECK
213 static const char *badmagic =
214 KERN_ERR "sx: Warning: bad specialix port magic number for device %s in %s\n";
215 static const char *badinfo =
216 KERN_ERR "sx: Warning: null specialix port for device %s in %s\n";
218 if (!port) {
219 printk(badinfo, name, routine);
220 return 1;
221 }
222 if (port->magic != SPECIALIX_MAGIC) {
223 printk(badmagic, name, routine);
224 return 1;
225 }
226 #endif
227 return 0;
228 }
231 /*
232 *
233 * Service functions for specialix IO8+ driver.
234 *
235 */
237 /* Get board number from pointer */
238 static inline int board_No (struct specialix_board * bp)
239 {
240 return bp - sx_board;
241 }
244 /* Get port number from pointer */
245 static inline int port_No (struct specialix_port const * port)
246 {
247 return SX_PORT(port - sx_port);
248 }
251 /* Get pointer to board from pointer to port */
252 static inline struct specialix_board * port_Board(struct specialix_port const * port)
253 {
254 return &sx_board[SX_BOARD(port - sx_port)];
255 }
258 /* Input Byte from CL CD186x register */
259 static inline unsigned char sx_in(struct specialix_board * bp, unsigned short reg)
260 {
261 bp->reg = reg | 0x80;
262 outb (reg | 0x80, bp->base + SX_ADDR_REG);
263 return inb (bp->base + SX_DATA_REG);
264 }
267 /* Output Byte to CL CD186x register */
268 static inline void sx_out(struct specialix_board * bp, unsigned short reg,
269 unsigned char val)
270 {
271 bp->reg = reg | 0x80;
272 outb (reg | 0x80, bp->base + SX_ADDR_REG);
273 outb (val, bp->base + SX_DATA_REG);
274 }
277 /* Input Byte from CL CD186x register */
278 static inline unsigned char sx_in_off(struct specialix_board * bp, unsigned short reg)
279 {
280 bp->reg = reg;
281 outb (reg, bp->base + SX_ADDR_REG);
282 return inb (bp->base + SX_DATA_REG);
283 }
286 /* Output Byte to CL CD186x register */
287 static inline void sx_out_off(struct specialix_board * bp, unsigned short reg,
288 unsigned char val)
289 {
290 bp->reg = reg;
291 outb (reg, bp->base + SX_ADDR_REG);
292 outb (val, bp->base + SX_DATA_REG);
293 }
296 /* Wait for Channel Command Register ready */
297 static inline void sx_wait_CCR(struct specialix_board * bp)
298 {
299 unsigned long delay, flags;
300 unsigned char ccr;
302 for (delay = SX_CCR_TIMEOUT; delay; delay--) {
303 spin_lock_irqsave(&bp->lock, flags);
304 ccr = sx_in(bp, CD186x_CCR);
305 spin_unlock_irqrestore(&bp->lock, flags);
306 if (!ccr)
307 return;
308 udelay (1);
309 }
311 printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
312 }
315 /* Wait for Channel Command Register ready */
316 static inline void sx_wait_CCR_off(struct specialix_board * bp)
317 {
318 unsigned long delay;
319 unsigned char crr;
320 unsigned long flags;
322 for (delay = SX_CCR_TIMEOUT; delay; delay--) {
323 spin_lock_irqsave(&bp->lock, flags);
324 crr = sx_in_off(bp, CD186x_CCR);
325 spin_unlock_irqrestore(&bp->lock, flags);
326 if (!crr)
327 return;
328 udelay (1);
329 }
331 printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
332 }
335 /*
336 * specialix IO8+ IO range functions.
337 */
339 static inline int sx_request_io_range(struct specialix_board * bp)
340 {
341 return request_region(bp->base,
342 bp->flags & SX_BOARD_IS_PCI ? SX_PCI_IO_SPACE : SX_IO_SPACE,
343 "specialix IO8+") == NULL;
344 }
347 static inline void sx_release_io_range(struct specialix_board * bp)
348 {
349 release_region(bp->base,
350 bp->flags&SX_BOARD_IS_PCI?SX_PCI_IO_SPACE:SX_IO_SPACE);
351 }
354 /* Must be called with enabled interrupts */
355 /* Ugly. Very ugly. Don't use this for anything else than initialization
356 code */
357 static inline void sx_long_delay(unsigned long delay)
358 {
359 unsigned long i;
361 for (i = jiffies + delay; time_after(i, jiffies); ) ;
362 }
366 /* Set the IRQ using the RTS lines that run to the PAL on the board.... */
367 static int sx_set_irq ( struct specialix_board *bp)
368 {
369 int virq;
370 int i;
371 unsigned long flags;
373 if (bp->flags & SX_BOARD_IS_PCI)
374 return 1;
375 switch (bp->irq) {
376 /* In the same order as in the docs... */
377 case 15: virq = 0;break;
378 case 12: virq = 1;break;
379 case 11: virq = 2;break;
380 case 9: virq = 3;break;
381 default: printk (KERN_ERR "Speclialix: cannot set irq to %d.\n", bp->irq);
382 return 0;
383 }
384 spin_lock_irqsave(&bp->lock, flags);
385 for (i=0;i<2;i++) {
386 sx_out(bp, CD186x_CAR, i);
387 sx_out(bp, CD186x_MSVRTS, ((virq >> i) & 0x1)? MSVR_RTS:0);
388 }
389 spin_unlock_irqrestore(&bp->lock, flags);
390 return 1;
391 }
394 /* Reset and setup CD186x chip */
395 static int sx_init_CD186x(struct specialix_board * bp)
396 {
397 unsigned long flags;
398 int scaler;
399 int rv = 1;
401 func_enter();
402 sx_wait_CCR_off(bp); /* Wait for CCR ready */
403 spin_lock_irqsave(&bp->lock, flags);
404 sx_out_off(bp, CD186x_CCR, CCR_HARDRESET); /* Reset CD186x chip */
405 spin_unlock_irqrestore(&bp->lock, flags);
406 sx_long_delay(HZ/20); /* Delay 0.05 sec */
407 spin_lock_irqsave(&bp->lock, flags);
408 sx_out_off(bp, CD186x_GIVR, SX_ID); /* Set ID for this chip */
409 sx_out_off(bp, CD186x_GICR, 0); /* Clear all bits */
410 sx_out_off(bp, CD186x_PILR1, SX_ACK_MINT); /* Prio for modem intr */
411 sx_out_off(bp, CD186x_PILR2, SX_ACK_TINT); /* Prio for transmitter intr */
412 sx_out_off(bp, CD186x_PILR3, SX_ACK_RINT); /* Prio for receiver intr */
413 /* Set RegAckEn */
414 sx_out_off(bp, CD186x_SRCR, sx_in (bp, CD186x_SRCR) | SRCR_REGACKEN);
416 /* Setting up prescaler. We need 4 ticks per 1 ms */
417 scaler = SX_OSCFREQ/SPECIALIX_TPS;
419 sx_out_off(bp, CD186x_PPRH, scaler >> 8);
420 sx_out_off(bp, CD186x_PPRL, scaler & 0xff);
421 spin_unlock_irqrestore(&bp->lock, flags);
423 if (!sx_set_irq (bp)) {
424 /* Figure out how to pass this along... */
425 printk (KERN_ERR "Cannot set irq to %d.\n", bp->irq);
426 rv = 0;
427 }
429 func_exit();
430 return rv;
431 }
434 static int read_cross_byte (struct specialix_board *bp, int reg, int bit)
435 {
436 int i;
437 int t;
438 unsigned long flags;
440 spin_lock_irqsave(&bp->lock, flags);
441 for (i=0, t=0;i<8;i++) {
442 sx_out_off (bp, CD186x_CAR, i);
443 if (sx_in_off (bp, reg) & bit)
444 t |= 1 << i;
445 }
446 spin_unlock_irqrestore(&bp->lock, flags);
448 return t;
449 }
452 #ifdef SPECIALIX_TIMER
453 void missed_irq (unsigned long data)
454 {
455 unsigned char irq;
456 unsigned long flags;
457 struct specialix_board *bp = (struct specialix_board *)data;
459 spin_lock_irqsave(&bp->lock, flags);
460 irq = sx_in ((struct specialix_board *)data, CD186x_SRSR) &
461 (SRSR_RREQint |
462 SRSR_TREQint |
463 SRSR_MREQint);
464 spin_unlock_irqrestore(&bp->lock, flags);
465 if (irq) {
466 printk (KERN_INFO "Missed interrupt... Calling int from timer. \n");
467 sx_interrupt (((struct specialix_board *)data)->irq,
468 (void*)data, NULL);
469 }
470 missed_irq_timer.expires = jiffies + sx_poll;
471 add_timer (&missed_irq_timer);
472 }
473 #endif
477 /* Main probing routine, also sets irq. */
478 static int sx_probe(struct specialix_board *bp)
479 {
480 unsigned char val1, val2;
481 #if 0
482 int irqs = 0;
483 int retries;
484 #endif
485 int rev;
486 int chip;
488 func_enter();
490 if (sx_request_io_range(bp)) {
491 func_exit();
492 return 1;
493 }
495 /* Are the I/O ports here ? */
496 sx_out_off(bp, CD186x_PPRL, 0x5a);
497 short_pause ();
498 val1 = sx_in_off(bp, CD186x_PPRL);
500 sx_out_off(bp, CD186x_PPRL, 0xa5);
501 short_pause ();
502 val2 = sx_in_off(bp, CD186x_PPRL);
505 if ((val1 != 0x5a) || (val2 != 0xa5)) {
506 printk(KERN_INFO "sx%d: specialix IO8+ Board at 0x%03x not found.\n",
507 board_No(bp), bp->base);
508 sx_release_io_range(bp);
509 func_exit();
510 return 1;
511 }
513 /* Check the DSR lines that Specialix uses as board
514 identification */
515 val1 = read_cross_byte (bp, CD186x_MSVR, MSVR_DSR);
516 val2 = read_cross_byte (bp, CD186x_MSVR, MSVR_RTS);
517 dprintk (SX_DEBUG_INIT, "sx%d: DSR lines are: %02x, rts lines are: %02x\n",
518 board_No(bp), val1, val2);
520 /* They managed to switch the bit order between the docs and
521 the IO8+ card. The new PCI card now conforms to old docs.
522 They changed the PCI docs to reflect the situation on the
523 old card. */
524 val2 = (bp->flags & SX_BOARD_IS_PCI)?0x4d : 0xb2;
525 if (val1 != val2) {
526 printk(KERN_INFO "sx%d: specialix IO8+ ID %02x at 0x%03x not found (%02x).\n",
527 board_No(bp), val2, bp->base, val1);
528 sx_release_io_range(bp);
529 func_exit();
530 return 1;
531 }
534 #if 0
535 /* It's time to find IRQ for this board */
536 for (retries = 0; retries < 5 && irqs <= 0; retries++) {
537 irqs = probe_irq_on();
538 sx_init_CD186x(bp); /* Reset CD186x chip */
539 sx_out(bp, CD186x_CAR, 2); /* Select port 2 */
540 sx_wait_CCR(bp);
541 sx_out(bp, CD186x_CCR, CCR_TXEN); /* Enable transmitter */
542 sx_out(bp, CD186x_IER, IER_TXRDY); /* Enable tx empty intr */
543 sx_long_delay(HZ/20);
544 irqs = probe_irq_off(irqs);
546 dprintk (SX_DEBUG_INIT, "SRSR = %02x, ", sx_in(bp, CD186x_SRSR));
547 dprintk (SX_DEBUG_INIT, "TRAR = %02x, ", sx_in(bp, CD186x_TRAR));
548 dprintk (SX_DEBUG_INIT, "GIVR = %02x, ", sx_in(bp, CD186x_GIVR));
549 dprintk (SX_DEBUG_INIT, "GICR = %02x, ", sx_in(bp, CD186x_GICR));
550 dprintk (SX_DEBUG_INIT, "\n");
552 /* Reset CD186x again */
553 if (!sx_init_CD186x(bp)) {
554 /* Hmmm. This is dead code anyway. */
555 }
557 dprintk (SX_DEBUG_INIT "val1 = %02x, val2 = %02x, val3 = %02x.\n",
558 val1, val2, val3);
560 }
562 #if 0
563 if (irqs <= 0) {
564 printk(KERN_ERR "sx%d: Can't find IRQ for specialix IO8+ board at 0x%03x.\n",
565 board_No(bp), bp->base);
566 sx_release_io_range(bp);
567 func_exit();
568 return 1;
569 }
570 #endif
571 printk (KERN_INFO "Started with irq=%d, but now have irq=%d.\n", bp->irq, irqs);
572 if (irqs > 0)
573 bp->irq = irqs;
574 #endif
575 /* Reset CD186x again */
576 if (!sx_init_CD186x(bp)) {
577 sx_release_io_range(bp);
578 func_exit();
579 return 1;
580 }
582 sx_request_io_range(bp);
583 bp->flags |= SX_BOARD_PRESENT;
585 /* Chip revcode pkgtype
586 GFRCR SRCR bit 7
587 CD180 rev B 0x81 0
588 CD180 rev C 0x82 0
589 CD1864 rev A 0x82 1
590 CD1865 rev A 0x83 1 -- Do not use!!! Does not work.
591 CD1865 rev B 0x84 1
592 -- Thanks to Gwen Wang, Cirrus Logic.
593 */
595 switch (sx_in_off(bp, CD186x_GFRCR)) {
596 case 0x82:chip = 1864;rev='A';break;
597 case 0x83:chip = 1865;rev='A';break;
598 case 0x84:chip = 1865;rev='B';break;
599 case 0x85:chip = 1865;rev='C';break; /* Does not exist at this time */
600 default:chip=-1;rev='x';
601 }
603 dprintk (SX_DEBUG_INIT, " GFCR = 0x%02x\n", sx_in_off(bp, CD186x_GFRCR) );
605 #ifdef SPECIALIX_TIMER
606 init_timer (&missed_irq_timer);
607 missed_irq_timer.function = missed_irq;
608 missed_irq_timer.data = (unsigned long) bp;
609 missed_irq_timer.expires = jiffies + sx_poll;
610 add_timer (&missed_irq_timer);
611 #endif
613 printk(KERN_INFO"sx%d: specialix IO8+ board detected at 0x%03x, IRQ %d, CD%d Rev. %c.\n",
614 board_No(bp),
615 bp->base, bp->irq,
616 chip, rev);
618 func_exit();
619 return 0;
620 }
622 /*
623 *
624 * Interrupt processing routines.
625 * */
627 static inline void sx_mark_event(struct specialix_port * port, int event)
628 {
629 func_enter();
631 set_bit(event, &port->event);
632 schedule_work(&port->tqueue);
634 func_exit();
635 }
638 static inline struct specialix_port * sx_get_port(struct specialix_board * bp,
639 unsigned char const * what)
640 {
641 unsigned char channel;
642 struct specialix_port * port = NULL;
644 channel = sx_in(bp, CD186x_GICR) >> GICR_CHAN_OFF;
645 dprintk (SX_DEBUG_CHAN, "channel: %d\n", channel);
646 if (channel < CD186x_NCH) {
647 port = &sx_port[board_No(bp) * SX_NPORT + channel];
648 dprintk (SX_DEBUG_CHAN, "port: %d %p flags: 0x%x\n",board_No(bp) * SX_NPORT + channel, port, port->flags & ASYNC_INITIALIZED);
650 if (port->flags & ASYNC_INITIALIZED) {
651 dprintk (SX_DEBUG_CHAN, "port: %d %p\n", channel, port);
652 func_exit();
653 return port;
654 }
655 }
656 printk(KERN_INFO "sx%d: %s interrupt from invalid port %d\n",
657 board_No(bp), what, channel);
658 return NULL;
659 }
662 static inline void sx_receive_exc(struct specialix_board * bp)
663 {
664 struct specialix_port *port;
665 struct tty_struct *tty;
666 unsigned char status;
667 unsigned char ch, flag;
669 func_enter();
671 port = sx_get_port(bp, "Receive");
672 if (!port) {
673 dprintk (SX_DEBUG_RX, "Hmm, couldn't find port.\n");
674 func_exit();
675 return;
676 }
677 tty = port->tty;
679 status = sx_in(bp, CD186x_RCSR);
681 dprintk (SX_DEBUG_RX, "status: 0x%x\n", status);
682 if (status & RCSR_OE) {
683 port->overrun++;
684 dprintk(SX_DEBUG_FIFO, "sx%d: port %d: Overrun. Total %ld overruns.\n",
685 board_No(bp), port_No(port), port->overrun);
686 }
687 status &= port->mark_mask;
689 /* This flip buffer check needs to be below the reading of the
690 status register to reset the chip's IRQ.... */
691 if (tty_buffer_request_room(tty, 1) == 0) {
692 dprintk(SX_DEBUG_FIFO, "sx%d: port %d: Working around flip buffer overflow.\n",
693 board_No(bp), port_No(port));
694 func_exit();
695 return;
696 }
698 ch = sx_in(bp, CD186x_RDR);
699 if (!status) {
700 func_exit();
701 return;
702 }
703 if (status & RCSR_TOUT) {
704 printk(KERN_INFO "sx%d: port %d: Receiver timeout. Hardware problems ?\n",
705 board_No(bp), port_No(port));
706 func_exit();
707 return;
709 } else if (status & RCSR_BREAK) {
710 dprintk(SX_DEBUG_RX, "sx%d: port %d: Handling break...\n",
711 board_No(bp), port_No(port));
712 flag = TTY_BREAK;
713 if (port->flags & ASYNC_SAK)
714 do_SAK(tty);
716 } else if (status & RCSR_PE)
717 flag = TTY_PARITY;
719 else if (status & RCSR_FE)
720 flag = TTY_FRAME;
722 else if (status & RCSR_OE)
723 flag = TTY_OVERRUN;
725 else
726 flag = TTY_NORMAL;
728 if(tty_insert_flip_char(tty, ch, flag))
729 tty_flip_buffer_push(tty);
730 func_exit();
731 }
734 static inline void sx_receive(struct specialix_board * bp)
735 {
736 struct specialix_port *port;
737 struct tty_struct *tty;
738 unsigned char count;
740 func_enter();
742 if (!(port = sx_get_port(bp, "Receive"))) {
743 dprintk (SX_DEBUG_RX, "Hmm, couldn't find port.\n");
744 func_exit();
745 return;
746 }
747 tty = port->tty;
749 count = sx_in(bp, CD186x_RDCR);
750 dprintk (SX_DEBUG_RX, "port: %p: count: %d\n", port, count);
751 port->hits[count > 8 ? 9 : count]++;
753 tty_buffer_request_room(tty, count);
755 while (count--)
756 tty_insert_flip_char(tty, sx_in(bp, CD186x_RDR), TTY_NORMAL);
757 tty_flip_buffer_push(tty);
758 func_exit();
759 }
762 static inline void sx_transmit(struct specialix_board * bp)
763 {
764 struct specialix_port *port;
765 struct tty_struct *tty;
766 unsigned char count;
768 func_enter();
769 if (!(port = sx_get_port(bp, "Transmit"))) {
770 func_exit();
771 return;
772 }
773 dprintk (SX_DEBUG_TX, "port: %p\n", port);
774 tty = port->tty;
776 if (port->IER & IER_TXEMPTY) {
777 /* FIFO drained */
778 sx_out(bp, CD186x_CAR, port_No(port));
779 port->IER &= ~IER_TXEMPTY;
780 sx_out(bp, CD186x_IER, port->IER);
781 func_exit();
782 return;
783 }
785 if ((port->xmit_cnt <= 0 && !port->break_length)
786 || tty->stopped || tty->hw_stopped) {
787 sx_out(bp, CD186x_CAR, port_No(port));
788 port->IER &= ~IER_TXRDY;
789 sx_out(bp, CD186x_IER, port->IER);
790 func_exit();
791 return;
792 }
794 if (port->break_length) {
795 if (port->break_length > 0) {
796 if (port->COR2 & COR2_ETC) {
797 sx_out(bp, CD186x_TDR, CD186x_C_ESC);
798 sx_out(bp, CD186x_TDR, CD186x_C_SBRK);
799 port->COR2 &= ~COR2_ETC;
800 }
801 count = min_t(int, port->break_length, 0xff);
802 sx_out(bp, CD186x_TDR, CD186x_C_ESC);
803 sx_out(bp, CD186x_TDR, CD186x_C_DELAY);
804 sx_out(bp, CD186x_TDR, count);
805 if (!(port->break_length -= count))
806 port->break_length--;
807 } else {
808 sx_out(bp, CD186x_TDR, CD186x_C_ESC);
809 sx_out(bp, CD186x_TDR, CD186x_C_EBRK);
810 sx_out(bp, CD186x_COR2, port->COR2);
811 sx_wait_CCR(bp);
812 sx_out(bp, CD186x_CCR, CCR_CORCHG2);
813 port->break_length = 0;
814 }
816 func_exit();
817 return;
818 }
820 count = CD186x_NFIFO;
821 do {
822 sx_out(bp, CD186x_TDR, port->xmit_buf[port->xmit_tail++]);
823 port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
824 if (--port->xmit_cnt <= 0)
825 break;
826 } while (--count > 0);
828 if (port->xmit_cnt <= 0) {
829 sx_out(bp, CD186x_CAR, port_No(port));
830 port->IER &= ~IER_TXRDY;
831 sx_out(bp, CD186x_IER, port->IER);
832 }
833 if (port->xmit_cnt <= port->wakeup_chars)
834 sx_mark_event(port, RS_EVENT_WRITE_WAKEUP);
836 func_exit();
837 }
840 static inline void sx_check_modem(struct specialix_board * bp)
841 {
842 struct specialix_port *port;
843 struct tty_struct *tty;
844 unsigned char mcr;
845 int msvr_cd;
847 dprintk (SX_DEBUG_SIGNALS, "Modem intr. ");
848 if (!(port = sx_get_port(bp, "Modem")))
849 return;
851 tty = port->tty;
853 mcr = sx_in(bp, CD186x_MCR);
854 printk ("mcr = %02x.\n", mcr);
856 if ((mcr & MCR_CDCHG)) {
857 dprintk (SX_DEBUG_SIGNALS, "CD just changed... ");
858 msvr_cd = sx_in(bp, CD186x_MSVR) & MSVR_CD;
859 if (msvr_cd) {
860 dprintk (SX_DEBUG_SIGNALS, "Waking up guys in open.\n");
861 wake_up_interruptible(&port->open_wait);
862 } else {
863 dprintk (SX_DEBUG_SIGNALS, "Sending HUP.\n");
864 schedule_work(&port->tqueue_hangup);
865 }
866 }
868 #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
869 if (mcr & MCR_CTSCHG) {
870 if (sx_in(bp, CD186x_MSVR) & MSVR_CTS) {
871 tty->hw_stopped = 0;
872 port->IER |= IER_TXRDY;
873 if (port->xmit_cnt <= port->wakeup_chars)
874 sx_mark_event(port, RS_EVENT_WRITE_WAKEUP);
875 } else {
876 tty->hw_stopped = 1;
877 port->IER &= ~IER_TXRDY;
878 }
879 sx_out(bp, CD186x_IER, port->IER);
880 }
881 if (mcr & MCR_DSSXHG) {
882 if (sx_in(bp, CD186x_MSVR) & MSVR_DSR) {
883 tty->hw_stopped = 0;
884 port->IER |= IER_TXRDY;
885 if (port->xmit_cnt <= port->wakeup_chars)
886 sx_mark_event(port, RS_EVENT_WRITE_WAKEUP);
887 } else {
888 tty->hw_stopped = 1;
889 port->IER &= ~IER_TXRDY;
890 }
891 sx_out(bp, CD186x_IER, port->IER);
892 }
893 #endif /* SPECIALIX_BRAIN_DAMAGED_CTS */
895 /* Clear change bits */
896 sx_out(bp, CD186x_MCR, 0);
897 }
900 /* The main interrupt processing routine */
901 static irqreturn_t sx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
902 {
903 unsigned char status;
904 unsigned char ack;
905 struct specialix_board *bp;
906 unsigned long loop = 0;
907 int saved_reg;
908 unsigned long flags;
910 func_enter();
912 bp = dev_id;
913 spin_lock_irqsave(&bp->lock, flags);
915 dprintk (SX_DEBUG_FLOW, "enter %s port %d room: %ld\n", __FUNCTION__, port_No(sx_get_port(bp, "INT")), SERIAL_XMIT_SIZE - sx_get_port(bp, "ITN")->xmit_cnt - 1);
916 if (!bp || !(bp->flags & SX_BOARD_ACTIVE)) {
917 dprintk (SX_DEBUG_IRQ, "sx: False interrupt. irq %d.\n", irq);
918 spin_unlock_irqrestore(&bp->lock, flags);
919 func_exit();
920 return IRQ_NONE;
921 }
923 saved_reg = bp->reg;
925 while ((++loop < 16) && (status = (sx_in(bp, CD186x_SRSR) &
926 (SRSR_RREQint |
927 SRSR_TREQint |
928 SRSR_MREQint)))) {
929 if (status & SRSR_RREQint) {
930 ack = sx_in(bp, CD186x_RRAR);
932 if (ack == (SX_ID | GIVR_IT_RCV))
933 sx_receive(bp);
934 else if (ack == (SX_ID | GIVR_IT_REXC))
935 sx_receive_exc(bp);
936 else
937 printk(KERN_ERR "sx%d: status: 0x%x Bad receive ack 0x%02x.\n",
938 board_No(bp), status, ack);
940 } else if (status & SRSR_TREQint) {
941 ack = sx_in(bp, CD186x_TRAR);
943 if (ack == (SX_ID | GIVR_IT_TX))
944 sx_transmit(bp);
945 else
946 printk(KERN_ERR "sx%d: status: 0x%x Bad transmit ack 0x%02x. port: %d\n",
947 board_No(bp), status, ack, port_No (sx_get_port (bp, "Int")));
948 } else if (status & SRSR_MREQint) {
949 ack = sx_in(bp, CD186x_MRAR);
951 if (ack == (SX_ID | GIVR_IT_MODEM))
952 sx_check_modem(bp);
953 else
954 printk(KERN_ERR "sx%d: status: 0x%x Bad modem ack 0x%02x.\n",
955 board_No(bp), status, ack);
957 }
959 sx_out(bp, CD186x_EOIR, 0); /* Mark end of interrupt */
960 }
961 bp->reg = saved_reg;
962 outb (bp->reg, bp->base + SX_ADDR_REG);
963 spin_unlock_irqrestore(&bp->lock, flags);
964 func_exit();
965 return IRQ_HANDLED;
966 }
969 /*
970 * Routines for open & close processing.
971 */
973 static void turn_ints_off (struct specialix_board *bp)
974 {
975 unsigned long flags;
977 func_enter();
978 if (bp->flags & SX_BOARD_IS_PCI) {
979 /* This was intended for enabeling the interrupt on the
980 * PCI card. However it seems that it's already enabled
981 * and as PCI interrupts can be shared, there is no real
982 * reason to have to turn it off. */
983 }
985 spin_lock_irqsave(&bp->lock, flags);
986 (void) sx_in_off (bp, 0); /* Turn off interrupts. */
987 spin_unlock_irqrestore(&bp->lock, flags);
989 func_exit();
990 }
992 static void turn_ints_on (struct specialix_board *bp)
993 {
994 unsigned long flags;
996 func_enter();
998 if (bp->flags & SX_BOARD_IS_PCI) {
999 /* play with the PCI chip. See comment above. */
1001 spin_lock_irqsave(&bp->lock, flags);
1002 (void) sx_in (bp, 0); /* Turn ON interrupts. */
1003 spin_unlock_irqrestore(&bp->lock, flags);
1005 func_exit();
1009 /* Called with disabled interrupts */
1010 static inline int sx_setup_board(struct specialix_board * bp)
1012 int error;
1014 if (bp->flags & SX_BOARD_ACTIVE)
1015 return 0;
1017 if (bp->flags & SX_BOARD_IS_PCI)
1018 error = request_irq(bp->irq, sx_interrupt, IRQF_DISABLED | IRQF_SHARED, "specialix IO8+", bp);
1019 else
1020 error = request_irq(bp->irq, sx_interrupt, IRQF_DISABLED, "specialix IO8+", bp);
1022 if (error)
1023 return error;
1025 turn_ints_on (bp);
1026 bp->flags |= SX_BOARD_ACTIVE;
1028 return 0;
1032 /* Called with disabled interrupts */
1033 static inline void sx_shutdown_board(struct specialix_board *bp)
1035 func_enter();
1037 if (!(bp->flags & SX_BOARD_ACTIVE)) {
1038 func_exit();
1039 return;
1042 bp->flags &= ~SX_BOARD_ACTIVE;
1044 dprintk (SX_DEBUG_IRQ, "Freeing IRQ%d for board %d.\n",
1045 bp->irq, board_No (bp));
1046 free_irq(bp->irq, bp);
1048 turn_ints_off (bp);
1051 func_exit();
1055 /*
1056 * Setting up port characteristics.
1057 * Must be called with disabled interrupts
1058 */
1059 static void sx_change_speed(struct specialix_board *bp, struct specialix_port *port)
1061 struct tty_struct *tty;
1062 unsigned long baud;
1063 long tmp;
1064 unsigned char cor1 = 0, cor3 = 0;
1065 unsigned char mcor1 = 0, mcor2 = 0;
1066 static unsigned long again;
1067 unsigned long flags;
1069 func_enter();
1071 if (!(tty = port->tty) || !tty->termios) {
1072 func_exit();
1073 return;
1076 port->IER = 0;
1077 port->COR2 = 0;
1078 /* Select port on the board */
1079 spin_lock_irqsave(&bp->lock, flags);
1080 sx_out(bp, CD186x_CAR, port_No(port));
1082 /* The Specialix board doens't implement the RTS lines.
1083 They are used to set the IRQ level. Don't touch them. */
1084 if (SX_CRTSCTS(tty))
1085 port->MSVR = MSVR_DTR | (sx_in(bp, CD186x_MSVR) & MSVR_RTS);
1086 else
1087 port->MSVR = (sx_in(bp, CD186x_MSVR) & MSVR_RTS);
1088 spin_unlock_irqrestore(&bp->lock, flags);
1089 dprintk (SX_DEBUG_TERMIOS, "sx: got MSVR=%02x.\n", port->MSVR);
1090 baud = C_BAUD(tty);
1092 if (baud & CBAUDEX) {
1093 baud &= ~CBAUDEX;
1094 if (baud < 1 || baud > 2)
1095 port->tty->termios->c_cflag &= ~CBAUDEX;
1096 else
1097 baud += 15;
1099 if (baud == 15) {
1100 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1101 baud ++;
1102 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1103 baud += 2;
1107 if (!baud_table[baud]) {
1108 /* Drop DTR & exit */
1109 dprintk (SX_DEBUG_TERMIOS, "Dropping DTR... Hmm....\n");
1110 if (!SX_CRTSCTS (tty)) {
1111 port -> MSVR &= ~ MSVR_DTR;
1112 spin_lock_irqsave(&bp->lock, flags);
1113 sx_out(bp, CD186x_MSVR, port->MSVR );
1114 spin_unlock_irqrestore(&bp->lock, flags);
1116 else
1117 dprintk (SX_DEBUG_TERMIOS, "Can't drop DTR: no DTR.\n");
1118 return;
1119 } else {
1120 /* Set DTR on */
1121 if (!SX_CRTSCTS (tty)) {
1122 port ->MSVR |= MSVR_DTR;
1126 /*
1127 * Now we must calculate some speed depended things
1128 */
1130 /* Set baud rate for port */
1131 tmp = port->custom_divisor ;
1132 if ( tmp )
1133 printk (KERN_INFO "sx%d: Using custom baud rate divisor %ld. \n"
1134 "This is an untested option, please be carefull.\n",
1135 port_No (port), tmp);
1136 else
1137 tmp = (((SX_OSCFREQ + baud_table[baud]/2) / baud_table[baud] +
1138 CD186x_TPC/2) / CD186x_TPC);
1140 if ((tmp < 0x10) && time_before(again, jiffies)) {
1141 again = jiffies + HZ * 60;
1142 /* Page 48 of version 2.0 of the CL-CD1865 databook */
1143 if (tmp >= 12) {
1144 printk (KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
1145 "Performance degradation is possible.\n"
1146 "Read specialix.txt for more info.\n",
1147 port_No (port), tmp);
1148 } else {
1149 printk (KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
1150 "Warning: overstressing Cirrus chip. "
1151 "This might not work.\n"
1152 "Read specialix.txt for more info.\n",
1153 port_No (port), tmp);
1156 spin_lock_irqsave(&bp->lock, flags);
1157 sx_out(bp, CD186x_RBPRH, (tmp >> 8) & 0xff);
1158 sx_out(bp, CD186x_TBPRH, (tmp >> 8) & 0xff);
1159 sx_out(bp, CD186x_RBPRL, tmp & 0xff);
1160 sx_out(bp, CD186x_TBPRL, tmp & 0xff);
1161 spin_unlock_irqrestore(&bp->lock, flags);
1162 if (port->custom_divisor) {
1163 baud = (SX_OSCFREQ + port->custom_divisor/2) / port->custom_divisor;
1164 baud = ( baud + 5 ) / 10;
1165 } else
1166 baud = (baud_table[baud] + 5) / 10; /* Estimated CPS */
1168 /* Two timer ticks seems enough to wakeup something like SLIP driver */
1169 tmp = ((baud + HZ/2) / HZ) * 2 - CD186x_NFIFO;
1170 port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
1171 SERIAL_XMIT_SIZE - 1 : tmp);
1173 /* Receiver timeout will be transmission time for 1.5 chars */
1174 tmp = (SPECIALIX_TPS + SPECIALIX_TPS/2 + baud/2) / baud;
1175 tmp = (tmp > 0xff) ? 0xff : tmp;
1176 spin_lock_irqsave(&bp->lock, flags);
1177 sx_out(bp, CD186x_RTPR, tmp);
1178 spin_unlock_irqrestore(&bp->lock, flags);
1179 switch (C_CSIZE(tty)) {
1180 case CS5:
1181 cor1 |= COR1_5BITS;
1182 break;
1183 case CS6:
1184 cor1 |= COR1_6BITS;
1185 break;
1186 case CS7:
1187 cor1 |= COR1_7BITS;
1188 break;
1189 case CS8:
1190 cor1 |= COR1_8BITS;
1191 break;
1194 if (C_CSTOPB(tty))
1195 cor1 |= COR1_2SB;
1197 cor1 |= COR1_IGNORE;
1198 if (C_PARENB(tty)) {
1199 cor1 |= COR1_NORMPAR;
1200 if (C_PARODD(tty))
1201 cor1 |= COR1_ODDP;
1202 if (I_INPCK(tty))
1203 cor1 &= ~COR1_IGNORE;
1205 /* Set marking of some errors */
1206 port->mark_mask = RCSR_OE | RCSR_TOUT;
1207 if (I_INPCK(tty))
1208 port->mark_mask |= RCSR_FE | RCSR_PE;
1209 if (I_BRKINT(tty) || I_PARMRK(tty))
1210 port->mark_mask |= RCSR_BREAK;
1211 if (I_IGNPAR(tty))
1212 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
1213 if (I_IGNBRK(tty)) {
1214 port->mark_mask &= ~RCSR_BREAK;
1215 if (I_IGNPAR(tty))
1216 /* Real raw mode. Ignore all */
1217 port->mark_mask &= ~RCSR_OE;
1219 /* Enable Hardware Flow Control */
1220 if (C_CRTSCTS(tty)) {
1221 #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
1222 port->IER |= IER_DSR | IER_CTS;
1223 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
1224 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
1225 spin_lock_irqsave(&bp->lock, flags);
1226 tty->hw_stopped = !(sx_in(bp, CD186x_MSVR) & (MSVR_CTS|MSVR_DSR));
1227 spin_unlock_irqrestore(&bp->lock, flags);
1228 #else
1229 port->COR2 |= COR2_CTSAE;
1230 #endif
1232 /* Enable Software Flow Control. FIXME: I'm not sure about this */
1233 /* Some people reported that it works, but I still doubt it */
1234 if (I_IXON(tty)) {
1235 port->COR2 |= COR2_TXIBE;
1236 cor3 |= (COR3_FCT | COR3_SCDE);
1237 if (I_IXANY(tty))
1238 port->COR2 |= COR2_IXM;
1239 spin_lock_irqsave(&bp->lock, flags);
1240 sx_out(bp, CD186x_SCHR1, START_CHAR(tty));
1241 sx_out(bp, CD186x_SCHR2, STOP_CHAR(tty));
1242 sx_out(bp, CD186x_SCHR3, START_CHAR(tty));
1243 sx_out(bp, CD186x_SCHR4, STOP_CHAR(tty));
1244 spin_unlock_irqrestore(&bp->lock, flags);
1246 if (!C_CLOCAL(tty)) {
1247 /* Enable CD check */
1248 port->IER |= IER_CD;
1249 mcor1 |= MCOR1_CDZD;
1250 mcor2 |= MCOR2_CDOD;
1253 if (C_CREAD(tty))
1254 /* Enable receiver */
1255 port->IER |= IER_RXD;
1257 /* Set input FIFO size (1-8 bytes) */
1258 cor3 |= sx_rxfifo;
1259 /* Setting up CD186x channel registers */
1260 spin_lock_irqsave(&bp->lock, flags);
1261 sx_out(bp, CD186x_COR1, cor1);
1262 sx_out(bp, CD186x_COR2, port->COR2);
1263 sx_out(bp, CD186x_COR3, cor3);
1264 spin_unlock_irqrestore(&bp->lock, flags);
1265 /* Make CD186x know about registers change */
1266 sx_wait_CCR(bp);
1267 spin_lock_irqsave(&bp->lock, flags);
1268 sx_out(bp, CD186x_CCR, CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3);
1269 /* Setting up modem option registers */
1270 dprintk (SX_DEBUG_TERMIOS, "Mcor1 = %02x, mcor2 = %02x.\n", mcor1, mcor2);
1271 sx_out(bp, CD186x_MCOR1, mcor1);
1272 sx_out(bp, CD186x_MCOR2, mcor2);
1273 spin_unlock_irqrestore(&bp->lock, flags);
1274 /* Enable CD186x transmitter & receiver */
1275 sx_wait_CCR(bp);
1276 spin_lock_irqsave(&bp->lock, flags);
1277 sx_out(bp, CD186x_CCR, CCR_TXEN | CCR_RXEN);
1278 /* Enable interrupts */
1279 sx_out(bp, CD186x_IER, port->IER);
1280 /* And finally set the modem lines... */
1281 sx_out(bp, CD186x_MSVR, port->MSVR);
1282 spin_unlock_irqrestore(&bp->lock, flags);
1284 func_exit();
1288 /* Must be called with interrupts enabled */
1289 static int sx_setup_port(struct specialix_board *bp, struct specialix_port *port)
1291 unsigned long flags;
1293 func_enter();
1295 if (port->flags & ASYNC_INITIALIZED) {
1296 func_exit();
1297 return 0;
1300 if (!port->xmit_buf) {
1301 /* We may sleep in get_zeroed_page() */
1302 unsigned long tmp;
1304 if (!(tmp = get_zeroed_page(GFP_KERNEL))) {
1305 func_exit();
1306 return -ENOMEM;
1309 if (port->xmit_buf) {
1310 free_page(tmp);
1311 func_exit();
1312 return -ERESTARTSYS;
1314 port->xmit_buf = (unsigned char *) tmp;
1317 spin_lock_irqsave(&port->lock, flags);
1319 if (port->tty)
1320 clear_bit(TTY_IO_ERROR, &port->tty->flags);
1322 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1323 sx_change_speed(bp, port);
1324 port->flags |= ASYNC_INITIALIZED;
1326 spin_unlock_irqrestore(&port->lock, flags);
1329 func_exit();
1330 return 0;
1334 /* Must be called with interrupts disabled */
1335 static void sx_shutdown_port(struct specialix_board *bp, struct specialix_port *port)
1337 struct tty_struct *tty;
1338 int i;
1339 unsigned long flags;
1341 func_enter();
1343 if (!(port->flags & ASYNC_INITIALIZED)) {
1344 func_exit();
1345 return;
1348 if (sx_debug & SX_DEBUG_FIFO) {
1349 dprintk(SX_DEBUG_FIFO, "sx%d: port %d: %ld overruns, FIFO hits [ ",
1350 board_No(bp), port_No(port), port->overrun);
1351 for (i = 0; i < 10; i++) {
1352 dprintk(SX_DEBUG_FIFO, "%ld ", port->hits[i]);
1354 dprintk(SX_DEBUG_FIFO, "].\n");
1357 if (port->xmit_buf) {
1358 free_page((unsigned long) port->xmit_buf);
1359 port->xmit_buf = NULL;
1362 /* Select port */
1363 spin_lock_irqsave(&bp->lock, flags);
1364 sx_out(bp, CD186x_CAR, port_No(port));
1366 if (!(tty = port->tty) || C_HUPCL(tty)) {
1367 /* Drop DTR */
1368 sx_out(bp, CD186x_MSVDTR, 0);
1370 spin_unlock_irqrestore(&bp->lock, flags);
1371 /* Reset port */
1372 sx_wait_CCR(bp);
1373 spin_lock_irqsave(&bp->lock, flags);
1374 sx_out(bp, CD186x_CCR, CCR_SOFTRESET);
1375 /* Disable all interrupts from this port */
1376 port->IER = 0;
1377 sx_out(bp, CD186x_IER, port->IER);
1378 spin_unlock_irqrestore(&bp->lock, flags);
1379 if (tty)
1380 set_bit(TTY_IO_ERROR, &tty->flags);
1381 port->flags &= ~ASYNC_INITIALIZED;
1383 if (!bp->count)
1384 sx_shutdown_board(bp);
1385 func_exit();
1389 static int block_til_ready(struct tty_struct *tty, struct file * filp,
1390 struct specialix_port *port)
1392 DECLARE_WAITQUEUE(wait, current);
1393 struct specialix_board *bp = port_Board(port);
1394 int retval;
1395 int do_clocal = 0;
1396 int CD;
1397 unsigned long flags;
1399 func_enter();
1401 /*
1402 * If the device is in the middle of being closed, then block
1403 * until it's done, and then try again.
1404 */
1405 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
1406 interruptible_sleep_on(&port->close_wait);
1407 if (port->flags & ASYNC_HUP_NOTIFY) {
1408 func_exit();
1409 return -EAGAIN;
1410 } else {
1411 func_exit();
1412 return -ERESTARTSYS;
1416 /*
1417 * If non-blocking mode is set, or the port is not enabled,
1418 * then make the check up front and then exit.
1419 */
1420 if ((filp->f_flags & O_NONBLOCK) ||
1421 (tty->flags & (1 << TTY_IO_ERROR))) {
1422 port->flags |= ASYNC_NORMAL_ACTIVE;
1423 func_exit();
1424 return 0;
1427 if (C_CLOCAL(tty))
1428 do_clocal = 1;
1430 /*
1431 * Block waiting for the carrier detect and the line to become
1432 * free (i.e., not in use by the callout). While we are in
1433 * this loop, info->count is dropped by one, so that
1434 * rs_close() knows when to free things. We restore it upon
1435 * exit, either normal or abnormal.
1436 */
1437 retval = 0;
1438 add_wait_queue(&port->open_wait, &wait);
1439 spin_lock_irqsave(&port->lock, flags);
1440 if (!tty_hung_up_p(filp)) {
1441 port->count--;
1443 spin_unlock_irqrestore(&port->lock, flags);
1444 port->blocked_open++;
1445 while (1) {
1446 spin_lock_irqsave(&bp->lock, flags);
1447 sx_out(bp, CD186x_CAR, port_No(port));
1448 CD = sx_in(bp, CD186x_MSVR) & MSVR_CD;
1449 if (SX_CRTSCTS (tty)) {
1450 /* Activate RTS */
1451 port->MSVR |= MSVR_DTR; /* WTF? */
1452 sx_out (bp, CD186x_MSVR, port->MSVR);
1453 } else {
1454 /* Activate DTR */
1455 port->MSVR |= MSVR_DTR;
1456 sx_out (bp, CD186x_MSVR, port->MSVR);
1458 spin_unlock_irqrestore(&bp->lock, flags);
1459 set_current_state(TASK_INTERRUPTIBLE);
1460 if (tty_hung_up_p(filp) ||
1461 !(port->flags & ASYNC_INITIALIZED)) {
1462 if (port->flags & ASYNC_HUP_NOTIFY)
1463 retval = -EAGAIN;
1464 else
1465 retval = -ERESTARTSYS;
1466 break;
1468 if (!(port->flags & ASYNC_CLOSING) &&
1469 (do_clocal || CD))
1470 break;
1471 if (signal_pending(current)) {
1472 retval = -ERESTARTSYS;
1473 break;
1475 schedule();
1478 set_current_state(TASK_RUNNING);
1479 remove_wait_queue(&port->open_wait, &wait);
1480 spin_lock_irqsave(&port->lock, flags);
1481 if (!tty_hung_up_p(filp)) {
1482 port->count++;
1484 port->blocked_open--;
1485 spin_unlock_irqrestore(&port->lock, flags);
1486 if (retval) {
1487 func_exit();
1488 return retval;
1491 port->flags |= ASYNC_NORMAL_ACTIVE;
1492 func_exit();
1493 return 0;
1497 static int sx_open(struct tty_struct * tty, struct file * filp)
1499 int board;
1500 int error;
1501 struct specialix_port * port;
1502 struct specialix_board * bp;
1503 int i;
1504 unsigned long flags;
1506 func_enter();
1508 board = SX_BOARD(tty->index);
1510 if (board >= SX_NBOARD || !(sx_board[board].flags & SX_BOARD_PRESENT)) {
1511 func_exit();
1512 return -ENODEV;
1515 bp = &sx_board[board];
1516 port = sx_port + board * SX_NPORT + SX_PORT(tty->index);
1517 port->overrun = 0;
1518 for (i = 0; i < 10; i++)
1519 port->hits[i]=0;
1521 dprintk (SX_DEBUG_OPEN, "Board = %d, bp = %p, port = %p, portno = %d.\n",
1522 board, bp, port, SX_PORT(tty->index));
1524 if (sx_paranoia_check(port, tty->name, "sx_open")) {
1525 func_enter();
1526 return -ENODEV;
1529 if ((error = sx_setup_board(bp))) {
1530 func_exit();
1531 return error;
1534 spin_lock_irqsave(&bp->lock, flags);
1535 port->count++;
1536 bp->count++;
1537 tty->driver_data = port;
1538 port->tty = tty;
1539 spin_unlock_irqrestore(&bp->lock, flags);
1541 if ((error = sx_setup_port(bp, port))) {
1542 func_enter();
1543 return error;
1546 if ((error = block_til_ready(tty, filp, port))) {
1547 func_enter();
1548 return error;
1551 func_exit();
1552 return 0;
1556 static void sx_close(struct tty_struct * tty, struct file * filp)
1558 struct specialix_port *port = (struct specialix_port *) tty->driver_data;
1559 struct specialix_board *bp;
1560 unsigned long flags;
1561 unsigned long timeout;
1563 func_enter();
1564 if (!port || sx_paranoia_check(port, tty->name, "close")) {
1565 func_exit();
1566 return;
1568 spin_lock_irqsave(&port->lock, flags);
1570 if (tty_hung_up_p(filp)) {
1571 spin_unlock_irqrestore(&port->lock, flags);
1572 func_exit();
1573 return;
1576 bp = port_Board(port);
1577 if ((tty->count == 1) && (port->count != 1)) {
1578 printk(KERN_ERR "sx%d: sx_close: bad port count;"
1579 " tty->count is 1, port count is %d\n",
1580 board_No(bp), port->count);
1581 port->count = 1;
1584 if (port->count > 1) {
1585 port->count--;
1586 bp->count--;
1588 spin_unlock_irqrestore(&port->lock, flags);
1590 func_exit();
1591 return;
1593 port->flags |= ASYNC_CLOSING;
1594 /*
1595 * Now we wait for the transmit buffer to clear; and we notify
1596 * the line discipline to only process XON/XOFF characters.
1597 */
1598 tty->closing = 1;
1599 spin_unlock_irqrestore(&port->lock, flags);
1600 dprintk (SX_DEBUG_OPEN, "Closing\n");
1601 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE) {
1602 tty_wait_until_sent(tty, port->closing_wait);
1604 /*
1605 * At this point we stop accepting input. To do this, we
1606 * disable the receive line status interrupts, and tell the
1607 * interrupt driver to stop checking the data ready bit in the
1608 * line status register.
1609 */
1610 dprintk (SX_DEBUG_OPEN, "Closed\n");
1611 port->IER &= ~IER_RXD;
1612 if (port->flags & ASYNC_INITIALIZED) {
1613 port->IER &= ~IER_TXRDY;
1614 port->IER |= IER_TXEMPTY;
1615 spin_lock_irqsave(&bp->lock, flags);
1616 sx_out(bp, CD186x_CAR, port_No(port));
1617 sx_out(bp, CD186x_IER, port->IER);
1618 spin_unlock_irqrestore(&bp->lock, flags);
1619 /*
1620 * Before we drop DTR, make sure the UART transmitter
1621 * has completely drained; this is especially
1622 * important if there is a transmit FIFO!
1623 */
1624 timeout = jiffies+HZ;
1625 while(port->IER & IER_TXEMPTY) {
1626 set_current_state (TASK_INTERRUPTIBLE);
1627 msleep_interruptible(jiffies_to_msecs(port->timeout));
1628 if (time_after(jiffies, timeout)) {
1629 printk (KERN_INFO "Timeout waiting for close\n");
1630 break;
1636 if (--bp->count < 0) {
1637 printk(KERN_ERR "sx%d: sx_shutdown_port: bad board count: %d port: %d\n",
1638 board_No(bp), bp->count, tty->index);
1639 bp->count = 0;
1641 if (--port->count < 0) {
1642 printk(KERN_ERR "sx%d: sx_close: bad port count for tty%d: %d\n",
1643 board_No(bp), port_No(port), port->count);
1644 port->count = 0;
1647 sx_shutdown_port(bp, port);
1648 if (tty->driver->flush_buffer)
1649 tty->driver->flush_buffer(tty);
1650 tty_ldisc_flush(tty);
1651 spin_lock_irqsave(&port->lock, flags);
1652 tty->closing = 0;
1653 port->event = 0;
1654 port->tty = NULL;
1655 spin_unlock_irqrestore(&port->lock, flags);
1656 if (port->blocked_open) {
1657 if (port->close_delay) {
1658 msleep_interruptible(jiffies_to_msecs(port->close_delay));
1660 wake_up_interruptible(&port->open_wait);
1662 port->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1663 wake_up_interruptible(&port->close_wait);
1665 func_exit();
1669 static int sx_write(struct tty_struct * tty,
1670 const unsigned char *buf, int count)
1672 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1673 struct specialix_board *bp;
1674 int c, total = 0;
1675 unsigned long flags;
1677 func_enter();
1678 if (sx_paranoia_check(port, tty->name, "sx_write")) {
1679 func_exit();
1680 return 0;
1683 bp = port_Board(port);
1685 if (!port->xmit_buf || !tmp_buf) {
1686 func_exit();
1687 return 0;
1690 while (1) {
1691 spin_lock_irqsave(&port->lock, flags);
1692 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1693 SERIAL_XMIT_SIZE - port->xmit_head));
1694 if (c <= 0) {
1695 spin_unlock_irqrestore(&port->lock, flags);
1696 break;
1698 memcpy(port->xmit_buf + port->xmit_head, buf, c);
1699 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1700 port->xmit_cnt += c;
1701 spin_unlock_irqrestore(&port->lock, flags);
1703 buf += c;
1704 count -= c;
1705 total += c;
1708 spin_lock_irqsave(&bp->lock, flags);
1709 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1710 !(port->IER & IER_TXRDY)) {
1711 port->IER |= IER_TXRDY;
1712 sx_out(bp, CD186x_CAR, port_No(port));
1713 sx_out(bp, CD186x_IER, port->IER);
1715 spin_unlock_irqrestore(&bp->lock, flags);
1716 func_exit();
1718 return total;
1722 static void sx_put_char(struct tty_struct * tty, unsigned char ch)
1724 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1725 unsigned long flags;
1726 struct specialix_board * bp;
1728 func_enter();
1730 if (sx_paranoia_check(port, tty->name, "sx_put_char")) {
1731 func_exit();
1732 return;
1734 dprintk (SX_DEBUG_TX, "check tty: %p %p\n", tty, port->xmit_buf);
1735 if (!port->xmit_buf) {
1736 func_exit();
1737 return;
1739 bp = port_Board(port);
1740 spin_lock_irqsave(&port->lock, flags);
1742 dprintk (SX_DEBUG_TX, "xmit_cnt: %d xmit_buf: %p\n", port->xmit_cnt, port->xmit_buf);
1743 if ((port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) || (!port->xmit_buf)) {
1744 spin_unlock_irqrestore(&port->lock, flags);
1745 dprintk (SX_DEBUG_TX, "Exit size\n");
1746 func_exit();
1747 return;
1749 dprintk (SX_DEBUG_TX, "Handle xmit: %p %p\n", port, port->xmit_buf);
1750 port->xmit_buf[port->xmit_head++] = ch;
1751 port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1752 port->xmit_cnt++;
1753 spin_unlock_irqrestore(&port->lock, flags);
1755 func_exit();
1759 static void sx_flush_chars(struct tty_struct * tty)
1761 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1762 unsigned long flags;
1763 struct specialix_board * bp = port_Board(port);
1765 func_enter();
1767 if (sx_paranoia_check(port, tty->name, "sx_flush_chars")) {
1768 func_exit();
1769 return;
1771 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1772 !port->xmit_buf) {
1773 func_exit();
1774 return;
1776 spin_lock_irqsave(&bp->lock, flags);
1777 port->IER |= IER_TXRDY;
1778 sx_out(port_Board(port), CD186x_CAR, port_No(port));
1779 sx_out(port_Board(port), CD186x_IER, port->IER);
1780 spin_unlock_irqrestore(&bp->lock, flags);
1782 func_exit();
1786 static int sx_write_room(struct tty_struct * tty)
1788 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1789 int ret;
1791 func_enter();
1793 if (sx_paranoia_check(port, tty->name, "sx_write_room")) {
1794 func_exit();
1795 return 0;
1798 ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1799 if (ret < 0)
1800 ret = 0;
1802 func_exit();
1803 return ret;
1807 static int sx_chars_in_buffer(struct tty_struct *tty)
1809 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1811 func_enter();
1813 if (sx_paranoia_check(port, tty->name, "sx_chars_in_buffer")) {
1814 func_exit();
1815 return 0;
1817 func_exit();
1818 return port->xmit_cnt;
1822 static void sx_flush_buffer(struct tty_struct *tty)
1824 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1825 unsigned long flags;
1826 struct specialix_board * bp;
1828 func_enter();
1830 if (sx_paranoia_check(port, tty->name, "sx_flush_buffer")) {
1831 func_exit();
1832 return;
1835 bp = port_Board(port);
1836 spin_lock_irqsave(&port->lock, flags);
1837 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1838 spin_unlock_irqrestore(&port->lock, flags);
1839 tty_wakeup(tty);
1841 func_exit();
1845 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1847 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1848 struct specialix_board * bp;
1849 unsigned char status;
1850 unsigned int result;
1851 unsigned long flags;
1853 func_enter();
1855 if (sx_paranoia_check(port, tty->name, __FUNCTION__)) {
1856 func_exit();
1857 return -ENODEV;
1860 bp = port_Board(port);
1861 spin_lock_irqsave (&bp->lock, flags);
1862 sx_out(bp, CD186x_CAR, port_No(port));
1863 status = sx_in(bp, CD186x_MSVR);
1864 spin_unlock_irqrestore(&bp->lock, flags);
1865 dprintk (SX_DEBUG_INIT, "Got msvr[%d] = %02x, car = %d.\n",
1866 port_No(port), status, sx_in (bp, CD186x_CAR));
1867 dprintk (SX_DEBUG_INIT, "sx_port = %p, port = %p\n", sx_port, port);
1868 if (SX_CRTSCTS(port->tty)) {
1869 result = /* (status & MSVR_RTS) ? */ TIOCM_DTR /* : 0) */
1870 | ((status & MSVR_DTR) ? TIOCM_RTS : 0)
1871 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1872 |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
1873 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1874 } else {
1875 result = /* (status & MSVR_RTS) ? */ TIOCM_RTS /* : 0) */
1876 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1877 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1878 |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
1879 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1882 func_exit();
1884 return result;
1888 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1889 unsigned int set, unsigned int clear)
1891 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1892 unsigned long flags;
1893 struct specialix_board *bp;
1895 func_enter();
1897 if (sx_paranoia_check(port, tty->name, __FUNCTION__)) {
1898 func_exit();
1899 return -ENODEV;
1902 bp = port_Board(port);
1904 spin_lock_irqsave(&port->lock, flags);
1905 /* if (set & TIOCM_RTS)
1906 port->MSVR |= MSVR_RTS; */
1907 /* if (set & TIOCM_DTR)
1908 port->MSVR |= MSVR_DTR; */
1910 if (SX_CRTSCTS(port->tty)) {
1911 if (set & TIOCM_RTS)
1912 port->MSVR |= MSVR_DTR;
1913 } else {
1914 if (set & TIOCM_DTR)
1915 port->MSVR |= MSVR_DTR;
1918 /* if (clear & TIOCM_RTS)
1919 port->MSVR &= ~MSVR_RTS; */
1920 /* if (clear & TIOCM_DTR)
1921 port->MSVR &= ~MSVR_DTR; */
1922 if (SX_CRTSCTS(port->tty)) {
1923 if (clear & TIOCM_RTS)
1924 port->MSVR &= ~MSVR_DTR;
1925 } else {
1926 if (clear & TIOCM_DTR)
1927 port->MSVR &= ~MSVR_DTR;
1929 spin_lock_irqsave(&bp->lock, flags);
1930 sx_out(bp, CD186x_CAR, port_No(port));
1931 sx_out(bp, CD186x_MSVR, port->MSVR);
1932 spin_unlock_irqrestore(&bp->lock, flags);
1933 spin_unlock_irqrestore(&port->lock, flags);
1934 func_exit();
1935 return 0;
1939 static inline void sx_send_break(struct specialix_port * port, unsigned long length)
1941 struct specialix_board *bp = port_Board(port);
1942 unsigned long flags;
1944 func_enter();
1946 spin_lock_irqsave (&port->lock, flags);
1947 port->break_length = SPECIALIX_TPS / HZ * length;
1948 port->COR2 |= COR2_ETC;
1949 port->IER |= IER_TXRDY;
1950 spin_lock_irqsave(&bp->lock, flags);
1951 sx_out(bp, CD186x_CAR, port_No(port));
1952 sx_out(bp, CD186x_COR2, port->COR2);
1953 sx_out(bp, CD186x_IER, port->IER);
1954 spin_unlock_irqrestore(&bp->lock, flags);
1955 spin_unlock_irqrestore (&port->lock, flags);
1956 sx_wait_CCR(bp);
1957 spin_lock_irqsave(&bp->lock, flags);
1958 sx_out(bp, CD186x_CCR, CCR_CORCHG2);
1959 spin_unlock_irqrestore(&bp->lock, flags);
1960 sx_wait_CCR(bp);
1962 func_exit();
1966 static inline int sx_set_serial_info(struct specialix_port * port,
1967 struct serial_struct __user * newinfo)
1969 struct serial_struct tmp;
1970 struct specialix_board *bp = port_Board(port);
1971 int change_speed;
1973 func_enter();
1974 /*
1975 if (!access_ok(VERIFY_READ, (void *) newinfo, sizeof(tmp))) {
1976 func_exit();
1977 return -EFAULT;
1979 */
1980 if (copy_from_user(&tmp, newinfo, sizeof(tmp))) {
1981 func_enter();
1982 return -EFAULT;
1985 #if 0
1986 if ((tmp.irq != bp->irq) ||
1987 (tmp.port != bp->base) ||
1988 (tmp.type != PORT_CIRRUS) ||
1989 (tmp.baud_base != (SX_OSCFREQ + CD186x_TPC/2) / CD186x_TPC) ||
1990 (tmp.custom_divisor != 0) ||
1991 (tmp.xmit_fifo_size != CD186x_NFIFO) ||
1992 (tmp.flags & ~SPECIALIX_LEGAL_FLAGS)) {
1993 func_exit();
1994 return -EINVAL;
1996 #endif
1998 change_speed = ((port->flags & ASYNC_SPD_MASK) !=
1999 (tmp.flags & ASYNC_SPD_MASK));
2000 change_speed |= (tmp.custom_divisor != port->custom_divisor);
2002 if (!capable(CAP_SYS_ADMIN)) {
2003 if ((tmp.close_delay != port->close_delay) ||
2004 (tmp.closing_wait != port->closing_wait) ||
2005 ((tmp.flags & ~ASYNC_USR_MASK) !=
2006 (port->flags & ~ASYNC_USR_MASK))) {
2007 func_exit();
2008 return -EPERM;
2010 port->flags = ((port->flags & ~ASYNC_USR_MASK) |
2011 (tmp.flags & ASYNC_USR_MASK));
2012 port->custom_divisor = tmp.custom_divisor;
2013 } else {
2014 port->flags = ((port->flags & ~ASYNC_FLAGS) |
2015 (tmp.flags & ASYNC_FLAGS));
2016 port->close_delay = tmp.close_delay;
2017 port->closing_wait = tmp.closing_wait;
2018 port->custom_divisor = tmp.custom_divisor;
2020 if (change_speed) {
2021 sx_change_speed(bp, port);
2023 func_exit();
2024 return 0;
2028 static inline int sx_get_serial_info(struct specialix_port * port,
2029 struct serial_struct __user *retinfo)
2031 struct serial_struct tmp;
2032 struct specialix_board *bp = port_Board(port);
2034 func_enter();
2036 /*
2037 if (!access_ok(VERIFY_WRITE, (void *) retinfo, sizeof(tmp)))
2038 return -EFAULT;
2039 */
2041 memset(&tmp, 0, sizeof(tmp));
2042 tmp.type = PORT_CIRRUS;
2043 tmp.line = port - sx_port;
2044 tmp.port = bp->base;
2045 tmp.irq = bp->irq;
2046 tmp.flags = port->flags;
2047 tmp.baud_base = (SX_OSCFREQ + CD186x_TPC/2) / CD186x_TPC;
2048 tmp.close_delay = port->close_delay * HZ/100;
2049 tmp.closing_wait = port->closing_wait * HZ/100;
2050 tmp.custom_divisor = port->custom_divisor;
2051 tmp.xmit_fifo_size = CD186x_NFIFO;
2052 if (copy_to_user(retinfo, &tmp, sizeof(tmp))) {
2053 func_exit();
2054 return -EFAULT;
2057 func_exit();
2058 return 0;
2062 static int sx_ioctl(struct tty_struct * tty, struct file * filp,
2063 unsigned int cmd, unsigned long arg)
2065 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2066 int retval;
2067 void __user *argp = (void __user *)arg;
2069 func_enter();
2071 if (sx_paranoia_check(port, tty->name, "sx_ioctl")) {
2072 func_exit();
2073 return -ENODEV;
2076 switch (cmd) {
2077 case TCSBRK: /* SVID version: non-zero arg --> no break */
2078 retval = tty_check_change(tty);
2079 if (retval) {
2080 func_exit();
2081 return retval;
2083 tty_wait_until_sent(tty, 0);
2084 if (!arg)
2085 sx_send_break(port, HZ/4); /* 1/4 second */
2086 return 0;
2087 case TCSBRKP: /* support for POSIX tcsendbreak() */
2088 retval = tty_check_change(tty);
2089 if (retval) {
2090 func_exit();
2091 return retval;
2093 tty_wait_until_sent(tty, 0);
2094 sx_send_break(port, arg ? arg*(HZ/10) : HZ/4);
2095 func_exit();
2096 return 0;
2097 case TIOCGSOFTCAR:
2098 if (put_user(C_CLOCAL(tty)?1:0, (unsigned long __user *)argp)) {
2099 func_exit();
2100 return -EFAULT;
2102 func_exit();
2103 return 0;
2104 case TIOCSSOFTCAR:
2105 if (get_user(arg, (unsigned long __user *) argp)) {
2106 func_exit();
2107 return -EFAULT;
2109 tty->termios->c_cflag =
2110 ((tty->termios->c_cflag & ~CLOCAL) |
2111 (arg ? CLOCAL : 0));
2112 func_exit();
2113 return 0;
2114 case TIOCGSERIAL:
2115 func_exit();
2116 return sx_get_serial_info(port, argp);
2117 case TIOCSSERIAL:
2118 func_exit();
2119 return sx_set_serial_info(port, argp);
2120 default:
2121 func_exit();
2122 return -ENOIOCTLCMD;
2124 func_exit();
2125 return 0;
2129 static void sx_throttle(struct tty_struct * tty)
2131 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2132 struct specialix_board *bp;
2133 unsigned long flags;
2135 func_enter();
2137 if (sx_paranoia_check(port, tty->name, "sx_throttle")) {
2138 func_exit();
2139 return;
2142 bp = port_Board(port);
2144 /* Use DTR instead of RTS ! */
2145 if (SX_CRTSCTS (tty))
2146 port->MSVR &= ~MSVR_DTR;
2147 else {
2148 /* Auch!!! I think the system shouldn't call this then. */
2149 /* Or maybe we're supposed (allowed?) to do our side of hw
2150 handshake anyway, even when hardware handshake is off.
2151 When you see this in your logs, please report.... */
2152 printk (KERN_ERR "sx%d: Need to throttle, but can't (hardware hs is off)\n",
2153 port_No (port));
2155 spin_lock_irqsave(&bp->lock, flags);
2156 sx_out(bp, CD186x_CAR, port_No(port));
2157 spin_unlock_irqrestore(&bp->lock, flags);
2158 if (I_IXOFF(tty)) {
2159 spin_unlock_irqrestore(&bp->lock, flags);
2160 sx_wait_CCR(bp);
2161 spin_lock_irqsave(&bp->lock, flags);
2162 sx_out(bp, CD186x_CCR, CCR_SSCH2);
2163 spin_unlock_irqrestore(&bp->lock, flags);
2164 sx_wait_CCR(bp);
2166 spin_lock_irqsave(&bp->lock, flags);
2167 sx_out(bp, CD186x_MSVR, port->MSVR);
2168 spin_unlock_irqrestore(&bp->lock, flags);
2170 func_exit();
2174 static void sx_unthrottle(struct tty_struct * tty)
2176 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2177 struct specialix_board *bp;
2178 unsigned long flags;
2180 func_enter();
2182 if (sx_paranoia_check(port, tty->name, "sx_unthrottle")) {
2183 func_exit();
2184 return;
2187 bp = port_Board(port);
2189 spin_lock_irqsave(&port->lock, flags);
2190 /* XXXX Use DTR INSTEAD???? */
2191 if (SX_CRTSCTS(tty)) {
2192 port->MSVR |= MSVR_DTR;
2193 } /* Else clause: see remark in "sx_throttle"... */
2194 spin_lock_irqsave(&bp->lock, flags);
2195 sx_out(bp, CD186x_CAR, port_No(port));
2196 spin_unlock_irqrestore(&bp->lock, flags);
2197 if (I_IXOFF(tty)) {
2198 spin_unlock_irqrestore(&port->lock, flags);
2199 sx_wait_CCR(bp);
2200 spin_lock_irqsave(&bp->lock, flags);
2201 sx_out(bp, CD186x_CCR, CCR_SSCH1);
2202 spin_unlock_irqrestore(&bp->lock, flags);
2203 sx_wait_CCR(bp);
2204 spin_lock_irqsave(&port->lock, flags);
2206 spin_lock_irqsave(&bp->lock, flags);
2207 sx_out(bp, CD186x_MSVR, port->MSVR);
2208 spin_unlock_irqrestore(&bp->lock, flags);
2209 spin_unlock_irqrestore(&port->lock, flags);
2211 func_exit();
2215 static void sx_stop(struct tty_struct * tty)
2217 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2218 struct specialix_board *bp;
2219 unsigned long flags;
2221 func_enter();
2223 if (sx_paranoia_check(port, tty->name, "sx_stop")) {
2224 func_exit();
2225 return;
2228 bp = port_Board(port);
2230 spin_lock_irqsave(&port->lock, flags);
2231 port->IER &= ~IER_TXRDY;
2232 spin_lock_irqsave(&bp->lock, flags);
2233 sx_out(bp, CD186x_CAR, port_No(port));
2234 sx_out(bp, CD186x_IER, port->IER);
2235 spin_unlock_irqrestore(&bp->lock, flags);
2236 spin_unlock_irqrestore(&port->lock, flags);
2238 func_exit();
2242 static void sx_start(struct tty_struct * tty)
2244 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2245 struct specialix_board *bp;
2246 unsigned long flags;
2248 func_enter();
2250 if (sx_paranoia_check(port, tty->name, "sx_start")) {
2251 func_exit();
2252 return;
2255 bp = port_Board(port);
2257 spin_lock_irqsave(&port->lock, flags);
2258 if (port->xmit_cnt && port->xmit_buf && !(port->IER & IER_TXRDY)) {
2259 port->IER |= IER_TXRDY;
2260 spin_lock_irqsave(&bp->lock, flags);
2261 sx_out(bp, CD186x_CAR, port_No(port));
2262 sx_out(bp, CD186x_IER, port->IER);
2263 spin_unlock_irqrestore(&bp->lock, flags);
2265 spin_unlock_irqrestore(&port->lock, flags);
2267 func_exit();
2271 /*
2272 * This routine is called from the work-queue when the interrupt
2273 * routine has signalled that a hangup has occurred. The path of
2274 * hangup processing is:
2276 * serial interrupt routine -> (workqueue) ->
2277 * do_sx_hangup() -> tty->hangup() -> sx_hangup()
2279 */
2280 static void do_sx_hangup(void *private_)
2282 struct specialix_port *port = (struct specialix_port *) private_;
2283 struct tty_struct *tty;
2285 func_enter();
2287 tty = port->tty;
2288 if (tty)
2289 tty_hangup(tty); /* FIXME: module removal race here */
2291 func_exit();
2295 static void sx_hangup(struct tty_struct * tty)
2297 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2298 struct specialix_board *bp;
2299 unsigned long flags;
2301 func_enter();
2303 if (sx_paranoia_check(port, tty->name, "sx_hangup")) {
2304 func_exit();
2305 return;
2308 bp = port_Board(port);
2310 sx_shutdown_port(bp, port);
2311 spin_lock_irqsave(&port->lock, flags);
2312 port->event = 0;
2313 bp->count -= port->count;
2314 if (bp->count < 0) {
2315 printk(KERN_ERR "sx%d: sx_hangup: bad board count: %d port: %d\n",
2316 board_No(bp), bp->count, tty->index);
2317 bp->count = 0;
2319 port->count = 0;
2320 port->flags &= ~ASYNC_NORMAL_ACTIVE;
2321 port->tty = NULL;
2322 spin_unlock_irqrestore(&port->lock, flags);
2323 wake_up_interruptible(&port->open_wait);
2325 func_exit();
2329 static void sx_set_termios(struct tty_struct * tty, struct termios * old_termios)
2331 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2332 unsigned long flags;
2333 struct specialix_board * bp;
2335 if (sx_paranoia_check(port, tty->name, "sx_set_termios"))
2336 return;
2338 if (tty->termios->c_cflag == old_termios->c_cflag &&
2339 tty->termios->c_iflag == old_termios->c_iflag)
2340 return;
2342 bp = port_Board(port);
2343 spin_lock_irqsave(&port->lock, flags);
2344 sx_change_speed(port_Board(port), port);
2345 spin_unlock_irqrestore(&port->lock, flags);
2347 if ((old_termios->c_cflag & CRTSCTS) &&
2348 !(tty->termios->c_cflag & CRTSCTS)) {
2349 tty->hw_stopped = 0;
2350 sx_start(tty);
2355 static void do_softint(void *private_)
2357 struct specialix_port *port = (struct specialix_port *) private_;
2358 struct tty_struct *tty;
2360 func_enter();
2362 if(!(tty = port->tty)) {
2363 func_exit();
2364 return;
2367 if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &port->event)) {
2368 tty_wakeup(tty);
2369 //wake_up_interruptible(&tty->write_wait);
2372 func_exit();
2375 static struct tty_operations sx_ops = {
2376 .open = sx_open,
2377 .close = sx_close,
2378 .write = sx_write,
2379 .put_char = sx_put_char,
2380 .flush_chars = sx_flush_chars,
2381 .write_room = sx_write_room,
2382 .chars_in_buffer = sx_chars_in_buffer,
2383 .flush_buffer = sx_flush_buffer,
2384 .ioctl = sx_ioctl,
2385 .throttle = sx_throttle,
2386 .unthrottle = sx_unthrottle,
2387 .set_termios = sx_set_termios,
2388 .stop = sx_stop,
2389 .start = sx_start,
2390 .hangup = sx_hangup,
2391 .tiocmget = sx_tiocmget,
2392 .tiocmset = sx_tiocmset,
2393 };
2395 static int sx_init_drivers(void)
2397 int error;
2398 int i;
2400 func_enter();
2402 specialix_driver = alloc_tty_driver(SX_NBOARD * SX_NPORT);
2403 if (!specialix_driver) {
2404 printk(KERN_ERR "sx: Couldn't allocate tty_driver.\n");
2405 func_exit();
2406 return 1;
2409 if (!(tmp_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL))) {
2410 printk(KERN_ERR "sx: Couldn't get free page.\n");
2411 put_tty_driver(specialix_driver);
2412 func_exit();
2413 return 1;
2415 specialix_driver->owner = THIS_MODULE;
2416 specialix_driver->name = "ttyW";
2417 specialix_driver->major = SPECIALIX_NORMAL_MAJOR;
2418 specialix_driver->type = TTY_DRIVER_TYPE_SERIAL;
2419 specialix_driver->subtype = SERIAL_TYPE_NORMAL;
2420 specialix_driver->init_termios = tty_std_termios;
2421 specialix_driver->init_termios.c_cflag =
2422 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2423 specialix_driver->flags = TTY_DRIVER_REAL_RAW;
2424 tty_set_operations(specialix_driver, &sx_ops);
2426 if ((error = tty_register_driver(specialix_driver))) {
2427 put_tty_driver(specialix_driver);
2428 free_page((unsigned long)tmp_buf);
2429 printk(KERN_ERR "sx: Couldn't register specialix IO8+ driver, error = %d\n",
2430 error);
2431 func_exit();
2432 return 1;
2434 memset(sx_port, 0, sizeof(sx_port));
2435 for (i = 0; i < SX_NPORT * SX_NBOARD; i++) {
2436 sx_port[i].magic = SPECIALIX_MAGIC;
2437 INIT_WORK(&sx_port[i].tqueue, do_softint, &sx_port[i]);
2438 INIT_WORK(&sx_port[i].tqueue_hangup, do_sx_hangup, &sx_port[i]);
2439 sx_port[i].close_delay = 50 * HZ/100;
2440 sx_port[i].closing_wait = 3000 * HZ/100;
2441 init_waitqueue_head(&sx_port[i].open_wait);
2442 init_waitqueue_head(&sx_port[i].close_wait);
2443 spin_lock_init(&sx_port[i].lock);
2446 func_exit();
2447 return 0;
2450 static void sx_release_drivers(void)
2452 func_enter();
2454 free_page((unsigned long)tmp_buf);
2455 tty_unregister_driver(specialix_driver);
2456 put_tty_driver(specialix_driver);
2457 func_exit();
2460 /*
2461 * This routine must be called by kernel at boot time
2462 */
2463 static int __init specialix_init(void)
2465 int i;
2466 int found = 0;
2468 func_enter();
2470 printk(KERN_INFO "sx: Specialix IO8+ driver v" VERSION ", (c) R.E.Wolff 1997/1998.\n");
2471 printk(KERN_INFO "sx: derived from work (c) D.Gorodchanin 1994-1996.\n");
2472 #ifdef CONFIG_SPECIALIX_RTSCTS
2473 printk (KERN_INFO "sx: DTR/RTS pin is always RTS.\n");
2474 #else
2475 printk (KERN_INFO "sx: DTR/RTS pin is RTS when CRTSCTS is on.\n");
2476 #endif
2478 for (i = 0; i < SX_NBOARD; i++)
2479 spin_lock_init(&sx_board[i].lock);
2481 if (sx_init_drivers()) {
2482 func_exit();
2483 return -EIO;
2486 for (i = 0; i < SX_NBOARD; i++)
2487 if (sx_board[i].base && !sx_probe(&sx_board[i]))
2488 found++;
2490 #ifdef CONFIG_PCI
2492 struct pci_dev *pdev = NULL;
2494 i=0;
2495 while (i < SX_NBOARD) {
2496 if (sx_board[i].flags & SX_BOARD_PRESENT) {
2497 i++;
2498 continue;
2500 pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX,
2501 PCI_DEVICE_ID_SPECIALIX_IO8,
2502 pdev);
2503 if (!pdev) break;
2505 if (pci_enable_device(pdev))
2506 continue;
2508 sx_board[i].irq = pdev->irq;
2510 sx_board[i].base = pci_resource_start (pdev, 2);
2512 sx_board[i].flags |= SX_BOARD_IS_PCI;
2513 if (!sx_probe(&sx_board[i]))
2514 found ++;
2517 #endif
2519 if (!found) {
2520 sx_release_drivers();
2521 printk(KERN_INFO "sx: No specialix IO8+ boards detected.\n");
2522 func_exit();
2523 return -EIO;
2526 func_exit();
2527 return 0;
2530 static int iobase[SX_NBOARD] = {0,};
2532 static int irq [SX_NBOARD] = {0,};
2534 module_param_array(iobase, int, NULL, 0);
2535 module_param_array(irq, int, NULL, 0);
2536 module_param(sx_debug, int, 0);
2537 module_param(sx_rxfifo, int, 0);
2538 #ifdef SPECIALIX_TIMER
2539 module_param(sx_poll, int, 0);
2540 #endif
2542 /*
2543 * You can setup up to 4 boards.
2544 * by specifying "iobase=0xXXX,0xXXX ..." as insmod parameter.
2545 * You should specify the IRQs too in that case "irq=....,...".
2547 * More than 4 boards in one computer is not possible, as the card can
2548 * only use 4 different interrupts.
2550 */
2551 static int __init specialix_init_module(void)
2553 int i;
2555 func_enter();
2557 if (iobase[0] || iobase[1] || iobase[2] || iobase[3]) {
2558 for(i = 0; i < SX_NBOARD; i++) {
2559 sx_board[i].base = iobase[i];
2560 sx_board[i].irq = irq[i];
2561 sx_board[i].count= 0;
2565 func_exit();
2567 return specialix_init();
2570 static void __exit specialix_exit_module(void)
2572 int i;
2574 func_enter();
2576 sx_release_drivers();
2577 for (i = 0; i < SX_NBOARD; i++)
2578 if (sx_board[i].flags & SX_BOARD_PRESENT)
2579 sx_release_io_range(&sx_board[i]);
2580 #ifdef SPECIALIX_TIMER
2581 del_timer (&missed_irq_timer);
2582 #endif
2584 func_exit();
2587 static struct pci_device_id specialx_pci_tbl[] __devinitdata = {
2588 { PCI_DEVICE(PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_IO8) },
2589 { }
2590 };
2591 MODULE_DEVICE_TABLE(pci, specialx_pci_tbl);
2593 module_init(specialix_init_module);
2594 module_exit(specialix_exit_module);
2596 MODULE_LICENSE("GPL");