projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
tty/serial: lay the foundations for the next set of reworks
[deliverable/linux.git] / drivers / char / specialix.c
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 */
68
69 #define VERSION "1.11"
70
71
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 */
77
78 #include <linux/module.h>
79
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>
96
97 #include "specialix_io8.h"
98 #include "cd1865.h"
99
100
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
110
111 static int sx_debug;
112 static int sx_rxfifo = SPECIALIX_RXFIFO;
113
114 #ifdef DEBUG
115 #define dprintk(f, str...) if (sx_debug & f) printk (str)
116 #else
117 #define dprintk(f, str...) /* nothing */
118 #endif
119
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
132
133
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__)
136
137 #define jiffies_from_ms(a) ((((a) * HZ)/1000)+1)
138
139
140 /* Configurable options: */
141
142 /* Am I paranoid or not ? ;-) */
143 #define SPECIALIX_PARANOIA_CHECK
144
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
149
150 #ifdef SPECIALIX_TIMER
151 static int sx_poll = HZ;
152 #endif
153
154
155
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
162
163
164
165 #ifdef CONFIG_SPECIALIX_RTSCTS
166 #define SX_CRTSCTS(bla) 1
167 #else
168 #define SX_CRTSCTS(tty) C_CRTSCTS(tty)
169 #endif
170
171
172 /* Used to be outb (0xff, 0x80); */
173 #define short_pause() udelay (1)
174
175
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)
180
181 static struct tty_driver *specialix_driver;
182
183 static struct specialix_board sx_board[SX_NBOARD] = {
184 { 0, SX_IOBASE1, 9, },
185 { 0, SX_IOBASE2, 11, },
186 { 0, SX_IOBASE3, 12, },
187 { 0, SX_IOBASE4, 15, },
188 };
189
190 static struct specialix_port sx_port[SX_NBOARD * SX_NPORT];
191
192
193 #ifdef SPECIALIX_TIMER
194 static struct timer_list missed_irq_timer;
195 static irqreturn_t sx_interrupt(int irq, void * dev_id);
196 #endif
197
198
199
200 static inline int sx_paranoia_check(struct specialix_port const * port,
201 char *name, const char *routine)
202 {
203 #ifdef SPECIALIX_PARANOIA_CHECK
204 static const char *badmagic =
205 KERN_ERR "sx: Warning: bad specialix port magic number for device %s in %s\n";
206 static const char *badinfo =
207 KERN_ERR "sx: Warning: null specialix port for device %s in %s\n";
208
209 if (!port) {
210 printk(badinfo, name, routine);
211 return 1;
212 }
213 if (port->magic != SPECIALIX_MAGIC) {
214 printk(badmagic, name, routine);
215 return 1;
216 }
217 #endif
218 return 0;
219 }
220
221
222 /*
223 *
224 * Service functions for specialix IO8+ driver.
225 *
226 */
227
228 /* Get board number from pointer */
229 static inline int board_No (struct specialix_board * bp)
230 {
231 return bp - sx_board;
232 }
233
234
235 /* Get port number from pointer */
236 static inline int port_No (struct specialix_port const * port)
237 {
238 return SX_PORT(port - sx_port);
239 }
240
241
242 /* Get pointer to board from pointer to port */
243 static inline struct specialix_board * port_Board(struct specialix_port const * port)
244 {
245 return &sx_board[SX_BOARD(port - sx_port)];
246 }
247
248
249 /* Input Byte from CL CD186x register */
250 static inline unsigned char sx_in(struct specialix_board * bp, unsigned short reg)
251 {
252 bp->reg = reg | 0x80;
253 outb (reg | 0x80, bp->base + SX_ADDR_REG);
254 return inb (bp->base + SX_DATA_REG);
255 }
256
257
258 /* Output Byte to CL CD186x register */
259 static inline void sx_out(struct specialix_board * bp, unsigned short reg,
260 unsigned char val)
261 {
262 bp->reg = reg | 0x80;
263 outb (reg | 0x80, bp->base + SX_ADDR_REG);
264 outb (val, bp->base + SX_DATA_REG);
265 }
266
267
268 /* Input Byte from CL CD186x register */
269 static inline unsigned char sx_in_off(struct specialix_board * bp, unsigned short reg)
270 {
271 bp->reg = reg;
272 outb (reg, bp->base + SX_ADDR_REG);
273 return inb (bp->base + SX_DATA_REG);
274 }
275
276
277 /* Output Byte to CL CD186x register */
278 static inline void sx_out_off(struct specialix_board * bp, unsigned short reg,
279 unsigned char val)
280 {
281 bp->reg = reg;
282 outb (reg, bp->base + SX_ADDR_REG);
283 outb (val, bp->base + SX_DATA_REG);
284 }
285
286
287 /* Wait for Channel Command Register ready */
288 static inline void sx_wait_CCR(struct specialix_board * bp)
289 {
290 unsigned long delay, flags;
291 unsigned char ccr;
292
293 for (delay = SX_CCR_TIMEOUT; delay; delay--) {
294 spin_lock_irqsave(&bp->lock, flags);
295 ccr = sx_in(bp, CD186x_CCR);
296 spin_unlock_irqrestore(&bp->lock, flags);
297 if (!ccr)
298 return;
299 udelay (1);
300 }
301
302 printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
303 }
304
305
306 /* Wait for Channel Command Register ready */
307 static inline void sx_wait_CCR_off(struct specialix_board * bp)
308 {
309 unsigned long delay;
310 unsigned char crr;
311 unsigned long flags;
312
313 for (delay = SX_CCR_TIMEOUT; delay; delay--) {
314 spin_lock_irqsave(&bp->lock, flags);
315 crr = sx_in_off(bp, CD186x_CCR);
316 spin_unlock_irqrestore(&bp->lock, flags);
317 if (!crr)
318 return;
319 udelay (1);
320 }
321
322 printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
323 }
324
325
326 /*
327 * specialix IO8+ IO range functions.
328 */
329
330 static inline int sx_request_io_range(struct specialix_board * bp)
331 {
332 return request_region(bp->base,
333 bp->flags & SX_BOARD_IS_PCI ? SX_PCI_IO_SPACE : SX_IO_SPACE,
334 "specialix IO8+") == NULL;
335 }
336
337
338 static inline void sx_release_io_range(struct specialix_board * bp)
339 {
340 release_region(bp->base,
341 bp->flags&SX_BOARD_IS_PCI?SX_PCI_IO_SPACE:SX_IO_SPACE);
342 }
343
344
345 /* Set the IRQ using the RTS lines that run to the PAL on the board.... */
346 static int sx_set_irq ( struct specialix_board *bp)
347 {
348 int virq;
349 int i;
350 unsigned long flags;
351
352 if (bp->flags & SX_BOARD_IS_PCI)
353 return 1;
354 switch (bp->irq) {
355 /* In the same order as in the docs... */
356 case 15: virq = 0;break;
357 case 12: virq = 1;break;
358 case 11: virq = 2;break;
359 case 9: virq = 3;break;
360 default: printk (KERN_ERR "Speclialix: cannot set irq to %d.\n", bp->irq);
361 return 0;
362 }
363 spin_lock_irqsave(&bp->lock, flags);
364 for (i=0;i<2;i++) {
365 sx_out(bp, CD186x_CAR, i);
366 sx_out(bp, CD186x_MSVRTS, ((virq >> i) & 0x1)? MSVR_RTS:0);
367 }
368 spin_unlock_irqrestore(&bp->lock, flags);
369 return 1;
370 }
371
372
373 /* Reset and setup CD186x chip */
374 static int sx_init_CD186x(struct specialix_board * bp)
375 {
376 unsigned long flags;
377 int scaler;
378 int rv = 1;
379
380 func_enter();
381 sx_wait_CCR_off(bp); /* Wait for CCR ready */
382 spin_lock_irqsave(&bp->lock, flags);
383 sx_out_off(bp, CD186x_CCR, CCR_HARDRESET); /* Reset CD186x chip */
384 spin_unlock_irqrestore(&bp->lock, flags);
385 msleep(50); /* Delay 0.05 sec */
386 spin_lock_irqsave(&bp->lock, flags);
387 sx_out_off(bp, CD186x_GIVR, SX_ID); /* Set ID for this chip */
388 sx_out_off(bp, CD186x_GICR, 0); /* Clear all bits */
389 sx_out_off(bp, CD186x_PILR1, SX_ACK_MINT); /* Prio for modem intr */
390 sx_out_off(bp, CD186x_PILR2, SX_ACK_TINT); /* Prio for transmitter intr */
391 sx_out_off(bp, CD186x_PILR3, SX_ACK_RINT); /* Prio for receiver intr */
392 /* Set RegAckEn */
393 sx_out_off(bp, CD186x_SRCR, sx_in (bp, CD186x_SRCR) | SRCR_REGACKEN);
394
395 /* Setting up prescaler. We need 4 ticks per 1 ms */
396 scaler = SX_OSCFREQ/SPECIALIX_TPS;
397
398 sx_out_off(bp, CD186x_PPRH, scaler >> 8);
399 sx_out_off(bp, CD186x_PPRL, scaler & 0xff);
400 spin_unlock_irqrestore(&bp->lock, flags);
401
402 if (!sx_set_irq (bp)) {
403 /* Figure out how to pass this along... */
404 printk (KERN_ERR "Cannot set irq to %d.\n", bp->irq);
405 rv = 0;
406 }
407
408 func_exit();
409 return rv;
410 }
411
412
413 static int read_cross_byte (struct specialix_board *bp, int reg, int bit)
414 {
415 int i;
416 int t;
417 unsigned long flags;
418
419 spin_lock_irqsave(&bp->lock, flags);
420 for (i=0, t=0;i<8;i++) {
421 sx_out_off (bp, CD186x_CAR, i);
422 if (sx_in_off (bp, reg) & bit)
423 t |= 1 << i;
424 }
425 spin_unlock_irqrestore(&bp->lock, flags);
426
427 return t;
428 }
429
430
431 #ifdef SPECIALIX_TIMER
432 void missed_irq (unsigned long data)
433 {
434 unsigned char irq;
435 unsigned long flags;
436 struct specialix_board *bp = (struct specialix_board *)data;
437
438 spin_lock_irqsave(&bp->lock, flags);
439 irq = sx_in ((struct specialix_board *)data, CD186x_SRSR) &
440 (SRSR_RREQint |
441 SRSR_TREQint |
442 SRSR_MREQint);
443 spin_unlock_irqrestore(&bp->lock, flags);
444 if (irq) {
445 printk (KERN_INFO "Missed interrupt... Calling int from timer. \n");
446 sx_interrupt (-1, bp);
447 }
448 mod_timer(&missed_irq_timer, jiffies + sx_poll);
449 }
450 #endif
451
452
453
454 /* Main probing routine, also sets irq. */
455 static int sx_probe(struct specialix_board *bp)
456 {
457 unsigned char val1, val2;
458 #if 0
459 int irqs = 0;
460 int retries;
461 #endif
462 int rev;
463 int chip;
464
465 func_enter();
466
467 if (sx_request_io_range(bp)) {
468 func_exit();
469 return 1;
470 }
471
472 /* Are the I/O ports here ? */
473 sx_out_off(bp, CD186x_PPRL, 0x5a);
474 short_pause ();
475 val1 = sx_in_off(bp, CD186x_PPRL);
476
477 sx_out_off(bp, CD186x_PPRL, 0xa5);
478 short_pause ();
479 val2 = sx_in_off(bp, CD186x_PPRL);
480
481
482 if ((val1 != 0x5a) || (val2 != 0xa5)) {
483 printk(KERN_INFO "sx%d: specialix IO8+ Board at 0x%03x not found.\n",
484 board_No(bp), bp->base);
485 sx_release_io_range(bp);
486 func_exit();
487 return 1;
488 }
489
490 /* Check the DSR lines that Specialix uses as board
491 identification */
492 val1 = read_cross_byte (bp, CD186x_MSVR, MSVR_DSR);
493 val2 = read_cross_byte (bp, CD186x_MSVR, MSVR_RTS);
494 dprintk (SX_DEBUG_INIT, "sx%d: DSR lines are: %02x, rts lines are: %02x\n",
495 board_No(bp), val1, val2);
496
497 /* They managed to switch the bit order between the docs and
498 the IO8+ card. The new PCI card now conforms to old docs.
499 They changed the PCI docs to reflect the situation on the
500 old card. */
501 val2 = (bp->flags & SX_BOARD_IS_PCI)?0x4d : 0xb2;
502 if (val1 != val2) {
503 printk(KERN_INFO "sx%d: specialix IO8+ ID %02x at 0x%03x not found (%02x).\n",
504 board_No(bp), val2, bp->base, val1);
505 sx_release_io_range(bp);
506 func_exit();
507 return 1;
508 }
509
510
511 #if 0
512 /* It's time to find IRQ for this board */
513 for (retries = 0; retries < 5 && irqs <= 0; retries++) {
514 irqs = probe_irq_on();
515 sx_init_CD186x(bp); /* Reset CD186x chip */
516 sx_out(bp, CD186x_CAR, 2); /* Select port 2 */
517 sx_wait_CCR(bp);
518 sx_out(bp, CD186x_CCR, CCR_TXEN); /* Enable transmitter */
519 sx_out(bp, CD186x_IER, IER_TXRDY); /* Enable tx empty intr */
520 msleep(50);
521 irqs = probe_irq_off(irqs);
522
523 dprintk (SX_DEBUG_INIT, "SRSR = %02x, ", sx_in(bp, CD186x_SRSR));
524 dprintk (SX_DEBUG_INIT, "TRAR = %02x, ", sx_in(bp, CD186x_TRAR));
525 dprintk (SX_DEBUG_INIT, "GIVR = %02x, ", sx_in(bp, CD186x_GIVR));
526 dprintk (SX_DEBUG_INIT, "GICR = %02x, ", sx_in(bp, CD186x_GICR));
527 dprintk (SX_DEBUG_INIT, "\n");
528
529 /* Reset CD186x again */
530 if (!sx_init_CD186x(bp)) {
531 /* Hmmm. This is dead code anyway. */
532 }
533
534 dprintk (SX_DEBUG_INIT "val1 = %02x, val2 = %02x, val3 = %02x.\n",
535 val1, val2, val3);
536
537 }
538
539 #if 0
540 if (irqs <= 0) {
541 printk(KERN_ERR "sx%d: Can't find IRQ for specialix IO8+ board at 0x%03x.\n",
542 board_No(bp), bp->base);
543 sx_release_io_range(bp);
544 func_exit();
545 return 1;
546 }
547 #endif
548 printk (KERN_INFO "Started with irq=%d, but now have irq=%d.\n", bp->irq, irqs);
549 if (irqs > 0)
550 bp->irq = irqs;
551 #endif
552 /* Reset CD186x again */
553 if (!sx_init_CD186x(bp)) {
554 sx_release_io_range(bp);
555 func_exit();
556 return 1;
557 }
558
559 sx_request_io_range(bp);
560 bp->flags |= SX_BOARD_PRESENT;
561
562 /* Chip revcode pkgtype
563 GFRCR SRCR bit 7
564 CD180 rev B 0x81 0
565 CD180 rev C 0x82 0
566 CD1864 rev A 0x82 1
567 CD1865 rev A 0x83 1 -- Do not use!!! Does not work.
568 CD1865 rev B 0x84 1
569 -- Thanks to Gwen Wang, Cirrus Logic.
570 */
571
572 switch (sx_in_off(bp, CD186x_GFRCR)) {
573 case 0x82:chip = 1864;rev='A';break;
574 case 0x83:chip = 1865;rev='A';break;
575 case 0x84:chip = 1865;rev='B';break;
576 case 0x85:chip = 1865;rev='C';break; /* Does not exist at this time */
577 default:chip=-1;rev='x';
578 }
579
580 dprintk (SX_DEBUG_INIT, " GFCR = 0x%02x\n", sx_in_off(bp, CD186x_GFRCR) );
581
582 #ifdef SPECIALIX_TIMER
583 setup_timer(&missed_irq_timer, missed_irq, (unsigned long)bp);
584 mod_timer(&missed_irq_timer, jiffies + sx_poll);
585 #endif
586
587 printk(KERN_INFO"sx%d: specialix IO8+ board detected at 0x%03x, IRQ %d, CD%d Rev. %c.\n",
588 board_No(bp),
589 bp->base, bp->irq,
590 chip, rev);
591
592 func_exit();
593 return 0;
594 }
595
596 /*
597 *
598 * Interrupt processing routines.
599 * */
600
601 static inline struct specialix_port * sx_get_port(struct specialix_board * bp,
602 unsigned char const * what)
603 {
604 unsigned char channel;
605 struct specialix_port * port = NULL;
606
607 channel = sx_in(bp, CD186x_GICR) >> GICR_CHAN_OFF;
608 dprintk (SX_DEBUG_CHAN, "channel: %d\n", channel);
609 if (channel < CD186x_NCH) {
610 port = &sx_port[board_No(bp) * SX_NPORT + channel];
611 dprintk (SX_DEBUG_CHAN, "port: %d %p flags: 0x%x\n",board_No(bp) * SX_NPORT + channel, port, port->flags & ASYNC_INITIALIZED);
612
613 if (port->flags & ASYNC_INITIALIZED) {
614 dprintk (SX_DEBUG_CHAN, "port: %d %p\n", channel, port);
615 func_exit();
616 return port;
617 }
618 }
619 printk(KERN_INFO "sx%d: %s interrupt from invalid port %d\n",
620 board_No(bp), what, channel);
621 return NULL;
622 }
623
624
625 static inline void sx_receive_exc(struct specialix_board * bp)
626 {
627 struct specialix_port *port;
628 struct tty_struct *tty;
629 unsigned char status;
630 unsigned char ch, flag;
631
632 func_enter();
633
634 port = sx_get_port(bp, "Receive");
635 if (!port) {
636 dprintk (SX_DEBUG_RX, "Hmm, couldn't find port.\n");
637 func_exit();
638 return;
639 }
640 tty = port->tty;
641
642 status = sx_in(bp, CD186x_RCSR);
643
644 dprintk (SX_DEBUG_RX, "status: 0x%x\n", status);
645 if (status & RCSR_OE) {
646 port->overrun++;
647 dprintk(SX_DEBUG_FIFO, "sx%d: port %d: Overrun. Total %ld overruns.\n",
648 board_No(bp), port_No(port), port->overrun);
649 }
650 status &= port->mark_mask;
651
652 /* This flip buffer check needs to be below the reading of the
653 status register to reset the chip's IRQ.... */
654 if (tty_buffer_request_room(tty, 1) == 0) {
655 dprintk(SX_DEBUG_FIFO, "sx%d: port %d: Working around flip buffer overflow.\n",
656 board_No(bp), port_No(port));
657 func_exit();
658 return;
659 }
660
661 ch = sx_in(bp, CD186x_RDR);
662 if (!status) {
663 func_exit();
664 return;
665 }
666 if (status & RCSR_TOUT) {
667 printk(KERN_INFO "sx%d: port %d: Receiver timeout. Hardware problems ?\n",
668 board_No(bp), port_No(port));
669 func_exit();
670 return;
671
672 } else if (status & RCSR_BREAK) {
673 dprintk(SX_DEBUG_RX, "sx%d: port %d: Handling break...\n",
674 board_No(bp), port_No(port));
675 flag = TTY_BREAK;
676 if (port->flags & ASYNC_SAK)
677 do_SAK(tty);
678
679 } else if (status & RCSR_PE)
680 flag = TTY_PARITY;
681
682 else if (status & RCSR_FE)
683 flag = TTY_FRAME;
684
685 else if (status & RCSR_OE)
686 flag = TTY_OVERRUN;
687
688 else
689 flag = TTY_NORMAL;
690
691 if(tty_insert_flip_char(tty, ch, flag))
692 tty_flip_buffer_push(tty);
693 func_exit();
694 }
695
696
697 static inline void sx_receive(struct specialix_board * bp)
698 {
699 struct specialix_port *port;
700 struct tty_struct *tty;
701 unsigned char count;
702
703 func_enter();
704
705 if (!(port = sx_get_port(bp, "Receive"))) {
706 dprintk (SX_DEBUG_RX, "Hmm, couldn't find port.\n");
707 func_exit();
708 return;
709 }
710 tty = port->tty;
711
712 count = sx_in(bp, CD186x_RDCR);
713 dprintk (SX_DEBUG_RX, "port: %p: count: %d\n", port, count);
714 port->hits[count > 8 ? 9 : count]++;
715
716 tty_buffer_request_room(tty, count);
717
718 while (count--)
719 tty_insert_flip_char(tty, sx_in(bp, CD186x_RDR), TTY_NORMAL);
720 tty_flip_buffer_push(tty);
721 func_exit();
722 }
723
724
725 static inline void sx_transmit(struct specialix_board * bp)
726 {
727 struct specialix_port *port;
728 struct tty_struct *tty;
729 unsigned char count;
730
731 func_enter();
732 if (!(port = sx_get_port(bp, "Transmit"))) {
733 func_exit();
734 return;
735 }
736 dprintk (SX_DEBUG_TX, "port: %p\n", port);
737 tty = port->tty;
738
739 if (port->IER & IER_TXEMPTY) {
740 /* FIFO drained */
741 sx_out(bp, CD186x_CAR, port_No(port));
742 port->IER &= ~IER_TXEMPTY;
743 sx_out(bp, CD186x_IER, port->IER);
744 func_exit();
745 return;
746 }
747
748 if ((port->xmit_cnt <= 0 && !port->break_length)
749 || tty->stopped || tty->hw_stopped) {
750 sx_out(bp, CD186x_CAR, port_No(port));
751 port->IER &= ~IER_TXRDY;
752 sx_out(bp, CD186x_IER, port->IER);
753 func_exit();
754 return;
755 }
756
757 if (port->break_length) {
758 if (port->break_length > 0) {
759 if (port->COR2 & COR2_ETC) {
760 sx_out(bp, CD186x_TDR, CD186x_C_ESC);
761 sx_out(bp, CD186x_TDR, CD186x_C_SBRK);
762 port->COR2 &= ~COR2_ETC;
763 }
764 count = min_t(int, port->break_length, 0xff);
765 sx_out(bp, CD186x_TDR, CD186x_C_ESC);
766 sx_out(bp, CD186x_TDR, CD186x_C_DELAY);
767 sx_out(bp, CD186x_TDR, count);
768 if (!(port->break_length -= count))
769 port->break_length--;
770 } else {
771 sx_out(bp, CD186x_TDR, CD186x_C_ESC);
772 sx_out(bp, CD186x_TDR, CD186x_C_EBRK);
773 sx_out(bp, CD186x_COR2, port->COR2);
774 sx_wait_CCR(bp);
775 sx_out(bp, CD186x_CCR, CCR_CORCHG2);
776 port->break_length = 0;
777 }
778
779 func_exit();
780 return;
781 }
782
783 count = CD186x_NFIFO;
784 do {
785 sx_out(bp, CD186x_TDR, port->xmit_buf[port->xmit_tail++]);
786 port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
787 if (--port->xmit_cnt <= 0)
788 break;
789 } while (--count > 0);
790
791 if (port->xmit_cnt <= 0) {
792 sx_out(bp, CD186x_CAR, port_No(port));
793 port->IER &= ~IER_TXRDY;
794 sx_out(bp, CD186x_IER, port->IER);
795 }
796 if (port->xmit_cnt <= port->wakeup_chars)
797 tty_wakeup(tty);
798
799 func_exit();
800 }
801
802
803 static inline void sx_check_modem(struct specialix_board * bp)
804 {
805 struct specialix_port *port;
806 struct tty_struct *tty;
807 unsigned char mcr;
808 int msvr_cd;
809
810 dprintk (SX_DEBUG_SIGNALS, "Modem intr. ");
811 if (!(port = sx_get_port(bp, "Modem")))
812 return;
813
814 tty = port->tty;
815
816 mcr = sx_in(bp, CD186x_MCR);
817 printk ("mcr = %02x.\n", mcr);
818
819 if ((mcr & MCR_CDCHG)) {
820 dprintk (SX_DEBUG_SIGNALS, "CD just changed... ");
821 msvr_cd = sx_in(bp, CD186x_MSVR) & MSVR_CD;
822 if (msvr_cd) {
823 dprintk (SX_DEBUG_SIGNALS, "Waking up guys in open.\n");
824 wake_up_interruptible(&port->open_wait);
825 } else {
826 dprintk (SX_DEBUG_SIGNALS, "Sending HUP.\n");
827 tty_hangup(tty);
828 }
829 }
830
831 #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
832 if (mcr & MCR_CTSCHG) {
833 if (sx_in(bp, CD186x_MSVR) & MSVR_CTS) {
834 tty->hw_stopped = 0;
835 port->IER |= IER_TXRDY;
836 if (port->xmit_cnt <= port->wakeup_chars)
837 tty_wakeup(tty);
838 } else {
839 tty->hw_stopped = 1;
840 port->IER &= ~IER_TXRDY;
841 }
842 sx_out(bp, CD186x_IER, port->IER);
843 }
844 if (mcr & MCR_DSSXHG) {
845 if (sx_in(bp, CD186x_MSVR) & MSVR_DSR) {
846 tty->hw_stopped = 0;
847 port->IER |= IER_TXRDY;
848 if (port->xmit_cnt <= port->wakeup_chars)
849 tty_wakeup(tty);
850 } else {
851 tty->hw_stopped = 1;
852 port->IER &= ~IER_TXRDY;
853 }
854 sx_out(bp, CD186x_IER, port->IER);
855 }
856 #endif /* SPECIALIX_BRAIN_DAMAGED_CTS */
857
858 /* Clear change bits */
859 sx_out(bp, CD186x_MCR, 0);
860 }
861
862
863 /* The main interrupt processing routine */
864 static irqreturn_t sx_interrupt(int dummy, void *dev_id)
865 {
866 unsigned char status;
867 unsigned char ack;
868 struct specialix_board *bp = dev_id;
869 unsigned long loop = 0;
870 int saved_reg;
871 unsigned long flags;
872
873 func_enter();
874
875 spin_lock_irqsave(&bp->lock, flags);
876
877 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);
878 if (!(bp->flags & SX_BOARD_ACTIVE)) {
879 dprintk (SX_DEBUG_IRQ, "sx: False interrupt. irq %d.\n", bp->irq);
880 spin_unlock_irqrestore(&bp->lock, flags);
881 func_exit();
882 return IRQ_NONE;
883 }
884
885 saved_reg = bp->reg;
886
887 while ((++loop < 16) && (status = (sx_in(bp, CD186x_SRSR) &
888 (SRSR_RREQint |
889 SRSR_TREQint |
890 SRSR_MREQint)))) {
891 if (status & SRSR_RREQint) {
892 ack = sx_in(bp, CD186x_RRAR);
893
894 if (ack == (SX_ID | GIVR_IT_RCV))
895 sx_receive(bp);
896 else if (ack == (SX_ID | GIVR_IT_REXC))
897 sx_receive_exc(bp);
898 else
899 printk(KERN_ERR "sx%d: status: 0x%x Bad receive ack 0x%02x.\n",
900 board_No(bp), status, ack);
901
902 } else if (status & SRSR_TREQint) {
903 ack = sx_in(bp, CD186x_TRAR);
904
905 if (ack == (SX_ID | GIVR_IT_TX))
906 sx_transmit(bp);
907 else
908 printk(KERN_ERR "sx%d: status: 0x%x Bad transmit ack 0x%02x. port: %d\n",
909 board_No(bp), status, ack, port_No (sx_get_port (bp, "Int")));
910 } else if (status & SRSR_MREQint) {
911 ack = sx_in(bp, CD186x_MRAR);
912
913 if (ack == (SX_ID | GIVR_IT_MODEM))
914 sx_check_modem(bp);
915 else
916 printk(KERN_ERR "sx%d: status: 0x%x Bad modem ack 0x%02x.\n",
917 board_No(bp), status, ack);
918
919 }
920
921 sx_out(bp, CD186x_EOIR, 0); /* Mark end of interrupt */
922 }
923 bp->reg = saved_reg;
924 outb (bp->reg, bp->base + SX_ADDR_REG);
925 spin_unlock_irqrestore(&bp->lock, flags);
926 func_exit();
927 return IRQ_HANDLED;
928 }
929
930
931 /*
932 * Routines for open & close processing.
933 */
934
935 static void turn_ints_off (struct specialix_board *bp)
936 {
937 unsigned long flags;
938
939 func_enter();
940 if (bp->flags & SX_BOARD_IS_PCI) {
941 /* This was intended for enabeling the interrupt on the
942 * PCI card. However it seems that it's already enabled
943 * and as PCI interrupts can be shared, there is no real
944 * reason to have to turn it off. */
945 }
946
947 spin_lock_irqsave(&bp->lock, flags);
948 (void) sx_in_off (bp, 0); /* Turn off interrupts. */
949 spin_unlock_irqrestore(&bp->lock, flags);
950
951 func_exit();
952 }
953
954 static void turn_ints_on (struct specialix_board *bp)
955 {
956 unsigned long flags;
957
958 func_enter();
959
960 if (bp->flags & SX_BOARD_IS_PCI) {
961 /* play with the PCI chip. See comment above. */
962 }
963 spin_lock_irqsave(&bp->lock, flags);
964 (void) sx_in (bp, 0); /* Turn ON interrupts. */
965 spin_unlock_irqrestore(&bp->lock, flags);
966
967 func_exit();
968 }
969
970
971 /* Called with disabled interrupts */
972 static inline int sx_setup_board(struct specialix_board * bp)
973 {
974 int error;
975
976 if (bp->flags & SX_BOARD_ACTIVE)
977 return 0;
978
979 if (bp->flags & SX_BOARD_IS_PCI)
980 error = request_irq(bp->irq, sx_interrupt, IRQF_DISABLED | IRQF_SHARED, "specialix IO8+", bp);
981 else
982 error = request_irq(bp->irq, sx_interrupt, IRQF_DISABLED, "specialix IO8+", bp);
983
984 if (error)
985 return error;
986
987 turn_ints_on (bp);
988 bp->flags |= SX_BOARD_ACTIVE;
989
990 return 0;
991 }
992
993
994 /* Called with disabled interrupts */
995 static inline void sx_shutdown_board(struct specialix_board *bp)
996 {
997 func_enter();
998
999 if (!(bp->flags & SX_BOARD_ACTIVE)) {
1000 func_exit();
1001 return;
1002 }
1003
1004 bp->flags &= ~SX_BOARD_ACTIVE;
1005
1006 dprintk (SX_DEBUG_IRQ, "Freeing IRQ%d for board %d.\n",
1007 bp->irq, board_No (bp));
1008 free_irq(bp->irq, bp);
1009
1010 turn_ints_off (bp);
1011
1012
1013 func_exit();
1014 }
1015
1016
1017 /*
1018 * Setting up port characteristics.
1019 * Must be called with disabled interrupts
1020 */
1021 static void sx_change_speed(struct specialix_board *bp, struct specialix_port *port)
1022 {
1023 struct tty_struct *tty;
1024 unsigned long baud;
1025 long tmp;
1026 unsigned char cor1 = 0, cor3 = 0;
1027 unsigned char mcor1 = 0, mcor2 = 0;
1028 static unsigned long again;
1029 unsigned long flags;
1030
1031 func_enter();
1032
1033 if (!(tty = port->tty) || !tty->termios) {
1034 func_exit();
1035 return;
1036 }
1037
1038 port->IER = 0;
1039 port->COR2 = 0;
1040 /* Select port on the board */
1041 spin_lock_irqsave(&bp->lock, flags);
1042 sx_out(bp, CD186x_CAR, port_No(port));
1043
1044 /* The Specialix board doens't implement the RTS lines.
1045 They are used to set the IRQ level. Don't touch them. */
1046 if (SX_CRTSCTS(tty))
1047 port->MSVR = MSVR_DTR | (sx_in(bp, CD186x_MSVR) & MSVR_RTS);
1048 else
1049 port->MSVR = (sx_in(bp, CD186x_MSVR) & MSVR_RTS);
1050 spin_unlock_irqrestore(&bp->lock, flags);
1051 dprintk (SX_DEBUG_TERMIOS, "sx: got MSVR=%02x.\n", port->MSVR);
1052 baud = tty_get_baud_rate(tty);
1053
1054 if (baud == 38400) {
1055 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1056 baud = 57600;
1057 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1058 baud = 115200;
1059 }
1060
1061 if (!baud) {
1062 /* Drop DTR & exit */
1063 dprintk (SX_DEBUG_TERMIOS, "Dropping DTR... Hmm....\n");
1064 if (!SX_CRTSCTS (tty)) {
1065 port -> MSVR &= ~ MSVR_DTR;
1066 spin_lock_irqsave(&bp->lock, flags);
1067 sx_out(bp, CD186x_MSVR, port->MSVR );
1068 spin_unlock_irqrestore(&bp->lock, flags);
1069 }
1070 else
1071 dprintk (SX_DEBUG_TERMIOS, "Can't drop DTR: no DTR.\n");
1072 return;
1073 } else {
1074 /* Set DTR on */
1075 if (!SX_CRTSCTS (tty)) {
1076 port ->MSVR |= MSVR_DTR;
1077 }
1078 }
1079
1080 /*
1081 * Now we must calculate some speed depended things
1082 */
1083
1084 /* Set baud rate for port */
1085 tmp = port->custom_divisor ;
1086 if ( tmp )
1087 printk (KERN_INFO "sx%d: Using custom baud rate divisor %ld. \n"
1088 "This is an untested option, please be carefull.\n",
1089 port_No (port), tmp);
1090 else
1091 tmp = (((SX_OSCFREQ + baud/2) / baud +
1092 CD186x_TPC/2) / CD186x_TPC);
1093
1094 if ((tmp < 0x10) && time_before(again, jiffies)) {
1095 again = jiffies + HZ * 60;
1096 /* Page 48 of version 2.0 of the CL-CD1865 databook */
1097 if (tmp >= 12) {
1098 printk (KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
1099 "Performance degradation is possible.\n"
1100 "Read specialix.txt for more info.\n",
1101 port_No (port), tmp);
1102 } else {
1103 printk (KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
1104 "Warning: overstressing Cirrus chip. "
1105 "This might not work.\n"
1106 "Read specialix.txt for more info.\n",
1107 port_No (port), tmp);
1108 }
1109 }
1110 spin_lock_irqsave(&bp->lock, flags);
1111 sx_out(bp, CD186x_RBPRH, (tmp >> 8) & 0xff);
1112 sx_out(bp, CD186x_TBPRH, (tmp >> 8) & 0xff);
1113 sx_out(bp, CD186x_RBPRL, tmp & 0xff);
1114 sx_out(bp, CD186x_TBPRL, tmp & 0xff);
1115 spin_unlock_irqrestore(&bp->lock, flags);
1116 if (port->custom_divisor)
1117 baud = (SX_OSCFREQ + port->custom_divisor/2) / port->custom_divisor;
1118 baud = (baud + 5) / 10; /* Estimated CPS */
1119
1120 /* Two timer ticks seems enough to wakeup something like SLIP driver */
1121 tmp = ((baud + HZ/2) / HZ) * 2 - CD186x_NFIFO;
1122 port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
1123 SERIAL_XMIT_SIZE - 1 : tmp);
1124
1125 /* Receiver timeout will be transmission time for 1.5 chars */
1126 tmp = (SPECIALIX_TPS + SPECIALIX_TPS/2 + baud/2) / baud;
1127 tmp = (tmp > 0xff) ? 0xff : tmp;
1128 spin_lock_irqsave(&bp->lock, flags);
1129 sx_out(bp, CD186x_RTPR, tmp);
1130 spin_unlock_irqrestore(&bp->lock, flags);
1131 switch (C_CSIZE(tty)) {
1132 case CS5:
1133 cor1 |= COR1_5BITS;
1134 break;
1135 case CS6:
1136 cor1 |= COR1_6BITS;
1137 break;
1138 case CS7:
1139 cor1 |= COR1_7BITS;
1140 break;
1141 case CS8:
1142 cor1 |= COR1_8BITS;
1143 break;
1144 }
1145
1146 if (C_CSTOPB(tty))
1147 cor1 |= COR1_2SB;
1148
1149 cor1 |= COR1_IGNORE;
1150 if (C_PARENB(tty)) {
1151 cor1 |= COR1_NORMPAR;
1152 if (C_PARODD(tty))
1153 cor1 |= COR1_ODDP;
1154 if (I_INPCK(tty))
1155 cor1 &= ~COR1_IGNORE;
1156 }
1157 /* Set marking of some errors */
1158 port->mark_mask = RCSR_OE | RCSR_TOUT;
1159 if (I_INPCK(tty))
1160 port->mark_mask |= RCSR_FE | RCSR_PE;
1161 if (I_BRKINT(tty) || I_PARMRK(tty))
1162 port->mark_mask |= RCSR_BREAK;
1163 if (I_IGNPAR(tty))
1164 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
1165 if (I_IGNBRK(tty)) {
1166 port->mark_mask &= ~RCSR_BREAK;
1167 if (I_IGNPAR(tty))
1168 /* Real raw mode. Ignore all */
1169 port->mark_mask &= ~RCSR_OE;
1170 }
1171 /* Enable Hardware Flow Control */
1172 if (C_CRTSCTS(tty)) {
1173 #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
1174 port->IER |= IER_DSR | IER_CTS;
1175 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
1176 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
1177 spin_lock_irqsave(&bp->lock, flags);
1178 tty->hw_stopped = !(sx_in(bp, CD186x_MSVR) & (MSVR_CTS|MSVR_DSR));
1179 spin_unlock_irqrestore(&bp->lock, flags);
1180 #else
1181 port->COR2 |= COR2_CTSAE;
1182 #endif
1183 }
1184 /* Enable Software Flow Control. FIXME: I'm not sure about this */
1185 /* Some people reported that it works, but I still doubt it */
1186 if (I_IXON(tty)) {
1187 port->COR2 |= COR2_TXIBE;
1188 cor3 |= (COR3_FCT | COR3_SCDE);
1189 if (I_IXANY(tty))
1190 port->COR2 |= COR2_IXM;
1191 spin_lock_irqsave(&bp->lock, flags);
1192 sx_out(bp, CD186x_SCHR1, START_CHAR(tty));
1193 sx_out(bp, CD186x_SCHR2, STOP_CHAR(tty));
1194 sx_out(bp, CD186x_SCHR3, START_CHAR(tty));
1195 sx_out(bp, CD186x_SCHR4, STOP_CHAR(tty));
1196 spin_unlock_irqrestore(&bp->lock, flags);
1197 }
1198 if (!C_CLOCAL(tty)) {
1199 /* Enable CD check */
1200 port->IER |= IER_CD;
1201 mcor1 |= MCOR1_CDZD;
1202 mcor2 |= MCOR2_CDOD;
1203 }
1204
1205 if (C_CREAD(tty))
1206 /* Enable receiver */
1207 port->IER |= IER_RXD;
1208
1209 /* Set input FIFO size (1-8 bytes) */
1210 cor3 |= sx_rxfifo;
1211 /* Setting up CD186x channel registers */
1212 spin_lock_irqsave(&bp->lock, flags);
1213 sx_out(bp, CD186x_COR1, cor1);
1214 sx_out(bp, CD186x_COR2, port->COR2);
1215 sx_out(bp, CD186x_COR3, cor3);
1216 spin_unlock_irqrestore(&bp->lock, flags);
1217 /* Make CD186x know about registers change */
1218 sx_wait_CCR(bp);
1219 spin_lock_irqsave(&bp->lock, flags);
1220 sx_out(bp, CD186x_CCR, CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3);
1221 /* Setting up modem option registers */
1222 dprintk (SX_DEBUG_TERMIOS, "Mcor1 = %02x, mcor2 = %02x.\n", mcor1, mcor2);
1223 sx_out(bp, CD186x_MCOR1, mcor1);
1224 sx_out(bp, CD186x_MCOR2, mcor2);
1225 spin_unlock_irqrestore(&bp->lock, flags);
1226 /* Enable CD186x transmitter & receiver */
1227 sx_wait_CCR(bp);
1228 spin_lock_irqsave(&bp->lock, flags);
1229 sx_out(bp, CD186x_CCR, CCR_TXEN | CCR_RXEN);
1230 /* Enable interrupts */
1231 sx_out(bp, CD186x_IER, port->IER);
1232 /* And finally set the modem lines... */
1233 sx_out(bp, CD186x_MSVR, port->MSVR);
1234 spin_unlock_irqrestore(&bp->lock, flags);
1235
1236 func_exit();
1237 }
1238
1239
1240 /* Must be called with interrupts enabled */
1241 static int sx_setup_port(struct specialix_board *bp, struct specialix_port *port)
1242 {
1243 unsigned long flags;
1244
1245 func_enter();
1246
1247 if (port->flags & ASYNC_INITIALIZED) {
1248 func_exit();
1249 return 0;
1250 }
1251
1252 if (!port->xmit_buf) {
1253 /* We may sleep in get_zeroed_page() */
1254 unsigned long tmp;
1255
1256 if (!(tmp = get_zeroed_page(GFP_KERNEL))) {
1257 func_exit();
1258 return -ENOMEM;
1259 }
1260
1261 if (port->xmit_buf) {
1262 free_page(tmp);
1263 func_exit();
1264 return -ERESTARTSYS;
1265 }
1266 port->xmit_buf = (unsigned char *) tmp;
1267 }
1268
1269 spin_lock_irqsave(&port->lock, flags);
1270
1271 if (port->tty)
1272 clear_bit(TTY_IO_ERROR, &port->tty->flags);
1273
1274 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1275 sx_change_speed(bp, port);
1276 port->flags |= ASYNC_INITIALIZED;
1277
1278 spin_unlock_irqrestore(&port->lock, flags);
1279
1280
1281 func_exit();
1282 return 0;
1283 }
1284
1285
1286 /* Must be called with interrupts disabled */
1287 static void sx_shutdown_port(struct specialix_board *bp, struct specialix_port *port)
1288 {
1289 struct tty_struct *tty;
1290 int i;
1291 unsigned long flags;
1292
1293 func_enter();
1294
1295 if (!(port->flags & ASYNC_INITIALIZED)) {
1296 func_exit();
1297 return;
1298 }
1299
1300 if (sx_debug & SX_DEBUG_FIFO) {
1301 dprintk(SX_DEBUG_FIFO, "sx%d: port %d: %ld overruns, FIFO hits [ ",
1302 board_No(bp), port_No(port), port->overrun);
1303 for (i = 0; i < 10; i++) {
1304 dprintk(SX_DEBUG_FIFO, "%ld ", port->hits[i]);
1305 }
1306 dprintk(SX_DEBUG_FIFO, "].\n");
1307 }
1308
1309 if (port->xmit_buf) {
1310 free_page((unsigned long) port->xmit_buf);
1311 port->xmit_buf = NULL;
1312 }
1313
1314 /* Select port */
1315 spin_lock_irqsave(&bp->lock, flags);
1316 sx_out(bp, CD186x_CAR, port_No(port));
1317
1318 if (!(tty = port->tty) || C_HUPCL(tty)) {
1319 /* Drop DTR */
1320 sx_out(bp, CD186x_MSVDTR, 0);
1321 }
1322 spin_unlock_irqrestore(&bp->lock, flags);
1323 /* Reset port */
1324 sx_wait_CCR(bp);
1325 spin_lock_irqsave(&bp->lock, flags);
1326 sx_out(bp, CD186x_CCR, CCR_SOFTRESET);
1327 /* Disable all interrupts from this port */
1328 port->IER = 0;
1329 sx_out(bp, CD186x_IER, port->IER);
1330 spin_unlock_irqrestore(&bp->lock, flags);
1331 if (tty)
1332 set_bit(TTY_IO_ERROR, &tty->flags);
1333 port->flags &= ~ASYNC_INITIALIZED;
1334
1335 if (!bp->count)
1336 sx_shutdown_board(bp);
1337 func_exit();
1338 }
1339
1340
1341 static int block_til_ready(struct tty_struct *tty, struct file * filp,
1342 struct specialix_port *port)
1343 {
1344 DECLARE_WAITQUEUE(wait, current);
1345 struct specialix_board *bp = port_Board(port);
1346 int retval;
1347 int do_clocal = 0;
1348 int CD;
1349 unsigned long flags;
1350
1351 func_enter();
1352
1353 /*
1354 * If the device is in the middle of being closed, then block
1355 * until it's done, and then try again.
1356 */
1357 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
1358 interruptible_sleep_on(&port->close_wait);
1359 if (port->flags & ASYNC_HUP_NOTIFY) {
1360 func_exit();
1361 return -EAGAIN;
1362 } else {
1363 func_exit();
1364 return -ERESTARTSYS;
1365 }
1366 }
1367
1368 /*
1369 * If non-blocking mode is set, or the port is not enabled,
1370 * then make the check up front and then exit.
1371 */
1372 if ((filp->f_flags & O_NONBLOCK) ||
1373 (tty->flags & (1 << TTY_IO_ERROR))) {
1374 port->flags |= ASYNC_NORMAL_ACTIVE;
1375 func_exit();
1376 return 0;
1377 }
1378
1379 if (C_CLOCAL(tty))
1380 do_clocal = 1;
1381
1382 /*
1383 * Block waiting for the carrier detect and the line to become
1384 * free (i.e., not in use by the callout). While we are in
1385 * this loop, info->count is dropped by one, so that
1386 * rs_close() knows when to free things. We restore it upon
1387 * exit, either normal or abnormal.
1388 */
1389 retval = 0;
1390 add_wait_queue(&port->open_wait, &wait);
1391 spin_lock_irqsave(&port->lock, flags);
1392 if (!tty_hung_up_p(filp)) {
1393 port->count--;
1394 }
1395 spin_unlock_irqrestore(&port->lock, flags);
1396 port->blocked_open++;
1397 while (1) {
1398 spin_lock_irqsave(&bp->lock, flags);
1399 sx_out(bp, CD186x_CAR, port_No(port));
1400 CD = sx_in(bp, CD186x_MSVR) & MSVR_CD;
1401 if (SX_CRTSCTS (tty)) {
1402 /* Activate RTS */
1403 port->MSVR |= MSVR_DTR; /* WTF? */
1404 sx_out (bp, CD186x_MSVR, port->MSVR);
1405 } else {
1406 /* Activate DTR */
1407 port->MSVR |= MSVR_DTR;
1408 sx_out (bp, CD186x_MSVR, port->MSVR);
1409 }
1410 spin_unlock_irqrestore(&bp->lock, flags);
1411 set_current_state(TASK_INTERRUPTIBLE);
1412 if (tty_hung_up_p(filp) ||
1413 !(port->flags & ASYNC_INITIALIZED)) {
1414 if (port->flags & ASYNC_HUP_NOTIFY)
1415 retval = -EAGAIN;
1416 else
1417 retval = -ERESTARTSYS;
1418 break;
1419 }
1420 if (!(port->flags & ASYNC_CLOSING) &&
1421 (do_clocal || CD))
1422 break;
1423 if (signal_pending(current)) {
1424 retval = -ERESTARTSYS;
1425 break;
1426 }
1427 schedule();
1428 }
1429
1430 set_current_state(TASK_RUNNING);
1431 remove_wait_queue(&port->open_wait, &wait);
1432 spin_lock_irqsave(&port->lock, flags);
1433 if (!tty_hung_up_p(filp)) {
1434 port->count++;
1435 }
1436 port->blocked_open--;
1437 spin_unlock_irqrestore(&port->lock, flags);
1438 if (retval) {
1439 func_exit();
1440 return retval;
1441 }
1442
1443 port->flags |= ASYNC_NORMAL_ACTIVE;
1444 func_exit();
1445 return 0;
1446 }
1447
1448
1449 static int sx_open(struct tty_struct * tty, struct file * filp)
1450 {
1451 int board;
1452 int error;
1453 struct specialix_port * port;
1454 struct specialix_board * bp;
1455 int i;
1456 unsigned long flags;
1457
1458 func_enter();
1459
1460 board = SX_BOARD(tty->index);
1461
1462 if (board >= SX_NBOARD || !(sx_board[board].flags & SX_BOARD_PRESENT)) {
1463 func_exit();
1464 return -ENODEV;
1465 }
1466
1467 bp = &sx_board[board];
1468 port = sx_port + board * SX_NPORT + SX_PORT(tty->index);
1469 port->overrun = 0;
1470 for (i = 0; i < 10; i++)
1471 port->hits[i]=0;
1472
1473 dprintk (SX_DEBUG_OPEN, "Board = %d, bp = %p, port = %p, portno = %d.\n",
1474 board, bp, port, SX_PORT(tty->index));
1475
1476 if (sx_paranoia_check(port, tty->name, "sx_open")) {
1477 func_enter();
1478 return -ENODEV;
1479 }
1480
1481 if ((error = sx_setup_board(bp))) {
1482 func_exit();
1483 return error;
1484 }
1485
1486 spin_lock_irqsave(&bp->lock, flags);
1487 port->count++;
1488 bp->count++;
1489 tty->driver_data = port;
1490 port->tty = tty;
1491 spin_unlock_irqrestore(&bp->lock, flags);
1492
1493 if ((error = sx_setup_port(bp, port))) {
1494 func_enter();
1495 return error;
1496 }
1497
1498 if ((error = block_til_ready(tty, filp, port))) {
1499 func_enter();
1500 return error;
1501 }
1502
1503 func_exit();
1504 return 0;
1505 }
1506
1507 static void sx_flush_buffer(struct tty_struct *tty)
1508 {
1509 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1510 unsigned long flags;
1511 struct specialix_board * bp;
1512
1513 func_enter();
1514
1515 if (sx_paranoia_check(port, tty->name, "sx_flush_buffer")) {
1516 func_exit();
1517 return;
1518 }
1519
1520 bp = port_Board(port);
1521 spin_lock_irqsave(&port->lock, flags);
1522 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1523 spin_unlock_irqrestore(&port->lock, flags);
1524 tty_wakeup(tty);
1525
1526 func_exit();
1527 }
1528
1529 static void sx_close(struct tty_struct * tty, struct file * filp)
1530 {
1531 struct specialix_port *port = (struct specialix_port *) tty->driver_data;
1532 struct specialix_board *bp;
1533 unsigned long flags;
1534 unsigned long timeout;
1535
1536 func_enter();
1537 if (!port || sx_paranoia_check(port, tty->name, "close")) {
1538 func_exit();
1539 return;
1540 }
1541 spin_lock_irqsave(&port->lock, flags);
1542
1543 if (tty_hung_up_p(filp)) {
1544 spin_unlock_irqrestore(&port->lock, flags);
1545 func_exit();
1546 return;
1547 }
1548
1549 bp = port_Board(port);
1550 if ((tty->count == 1) && (port->count != 1)) {
1551 printk(KERN_ERR "sx%d: sx_close: bad port count;"
1552 " tty->count is 1, port count is %d\n",
1553 board_No(bp), port->count);
1554 port->count = 1;
1555 }
1556
1557 if (port->count > 1) {
1558 port->count--;
1559 bp->count--;
1560
1561 spin_unlock_irqrestore(&port->lock, flags);
1562
1563 func_exit();
1564 return;
1565 }
1566 port->flags |= ASYNC_CLOSING;
1567 /*
1568 * Now we wait for the transmit buffer to clear; and we notify
1569 * the line discipline to only process XON/XOFF characters.
1570 */
1571 tty->closing = 1;
1572 spin_unlock_irqrestore(&port->lock, flags);
1573 dprintk (SX_DEBUG_OPEN, "Closing\n");
1574 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE) {
1575 tty_wait_until_sent(tty, port->closing_wait);
1576 }
1577 /*
1578 * At this point we stop accepting input. To do this, we
1579 * disable the receive line status interrupts, and tell the
1580 * interrupt driver to stop checking the data ready bit in the
1581 * line status register.
1582 */
1583 dprintk (SX_DEBUG_OPEN, "Closed\n");
1584 port->IER &= ~IER_RXD;
1585 if (port->flags & ASYNC_INITIALIZED) {
1586 port->IER &= ~IER_TXRDY;
1587 port->IER |= IER_TXEMPTY;
1588 spin_lock_irqsave(&bp->lock, flags);
1589 sx_out(bp, CD186x_CAR, port_No(port));
1590 sx_out(bp, CD186x_IER, port->IER);
1591 spin_unlock_irqrestore(&bp->lock, flags);
1592 /*
1593 * Before we drop DTR, make sure the UART transmitter
1594 * has completely drained; this is especially
1595 * important if there is a transmit FIFO!
1596 */
1597 timeout = jiffies+HZ;
1598 while(port->IER & IER_TXEMPTY) {
1599 set_current_state (TASK_INTERRUPTIBLE);
1600 msleep_interruptible(jiffies_to_msecs(port->timeout));
1601 if (time_after(jiffies, timeout)) {
1602 printk (KERN_INFO "Timeout waiting for close\n");
1603 break;
1604 }
1605 }
1606
1607 }
1608
1609 if (--bp->count < 0) {
1610 printk(KERN_ERR "sx%d: sx_shutdown_port: bad board count: %d port: %d\n",
1611 board_No(bp), bp->count, tty->index);
1612 bp->count = 0;
1613 }
1614 if (--port->count < 0) {
1615 printk(KERN_ERR "sx%d: sx_close: bad port count for tty%d: %d\n",
1616 board_No(bp), port_No(port), port->count);
1617 port->count = 0;
1618 }
1619
1620 sx_shutdown_port(bp, port);
1621 sx_flush_buffer(tty);
1622 tty_ldisc_flush(tty);
1623 spin_lock_irqsave(&port->lock, flags);
1624 tty->closing = 0;
1625 port->tty = NULL;
1626 spin_unlock_irqrestore(&port->lock, flags);
1627 if (port->blocked_open) {
1628 if (port->close_delay) {
1629 msleep_interruptible(jiffies_to_msecs(port->close_delay));
1630 }
1631 wake_up_interruptible(&port->open_wait);
1632 }
1633 port->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1634 wake_up_interruptible(&port->close_wait);
1635
1636 func_exit();
1637 }
1638
1639
1640 static int sx_write(struct tty_struct * tty,
1641 const unsigned char *buf, int count)
1642 {
1643 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1644 struct specialix_board *bp;
1645 int c, total = 0;
1646 unsigned long flags;
1647
1648 func_enter();
1649 if (sx_paranoia_check(port, tty->name, "sx_write")) {
1650 func_exit();
1651 return 0;
1652 }
1653
1654 bp = port_Board(port);
1655
1656 if (!port->xmit_buf) {
1657 func_exit();
1658 return 0;
1659 }
1660
1661 while (1) {
1662 spin_lock_irqsave(&port->lock, flags);
1663 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1664 SERIAL_XMIT_SIZE - port->xmit_head));
1665 if (c <= 0) {
1666 spin_unlock_irqrestore(&port->lock, flags);
1667 break;
1668 }
1669 memcpy(port->xmit_buf + port->xmit_head, buf, c);
1670 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1671 port->xmit_cnt += c;
1672 spin_unlock_irqrestore(&port->lock, flags);
1673
1674 buf += c;
1675 count -= c;
1676 total += c;
1677 }
1678
1679 spin_lock_irqsave(&bp->lock, flags);
1680 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1681 !(port->IER & IER_TXRDY)) {
1682 port->IER |= IER_TXRDY;
1683 sx_out(bp, CD186x_CAR, port_No(port));
1684 sx_out(bp, CD186x_IER, port->IER);
1685 }
1686 spin_unlock_irqrestore(&bp->lock, flags);
1687 func_exit();
1688
1689 return total;
1690 }
1691
1692
1693 static void sx_put_char(struct tty_struct * tty, unsigned char ch)
1694 {
1695 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1696 unsigned long flags;
1697 struct specialix_board * bp;
1698
1699 func_enter();
1700
1701 if (sx_paranoia_check(port, tty->name, "sx_put_char")) {
1702 func_exit();
1703 return;
1704 }
1705 dprintk (SX_DEBUG_TX, "check tty: %p %p\n", tty, port->xmit_buf);
1706 if (!port->xmit_buf) {
1707 func_exit();
1708 return;
1709 }
1710 bp = port_Board(port);
1711 spin_lock_irqsave(&port->lock, flags);
1712
1713 dprintk (SX_DEBUG_TX, "xmit_cnt: %d xmit_buf: %p\n", port->xmit_cnt, port->xmit_buf);
1714 if ((port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) || (!port->xmit_buf)) {
1715 spin_unlock_irqrestore(&port->lock, flags);
1716 dprintk (SX_DEBUG_TX, "Exit size\n");
1717 func_exit();
1718 return;
1719 }
1720 dprintk (SX_DEBUG_TX, "Handle xmit: %p %p\n", port, port->xmit_buf);
1721 port->xmit_buf[port->xmit_head++] = ch;
1722 port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1723 port->xmit_cnt++;
1724 spin_unlock_irqrestore(&port->lock, flags);
1725
1726 func_exit();
1727 }
1728
1729
1730 static void sx_flush_chars(struct tty_struct * tty)
1731 {
1732 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1733 unsigned long flags;
1734 struct specialix_board * bp = port_Board(port);
1735
1736 func_enter();
1737
1738 if (sx_paranoia_check(port, tty->name, "sx_flush_chars")) {
1739 func_exit();
1740 return;
1741 }
1742 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1743 !port->xmit_buf) {
1744 func_exit();
1745 return;
1746 }
1747 spin_lock_irqsave(&bp->lock, flags);
1748 port->IER |= IER_TXRDY;
1749 sx_out(port_Board(port), CD186x_CAR, port_No(port));
1750 sx_out(port_Board(port), CD186x_IER, port->IER);
1751 spin_unlock_irqrestore(&bp->lock, flags);
1752
1753 func_exit();
1754 }
1755
1756
1757 static int sx_write_room(struct tty_struct * tty)
1758 {
1759 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1760 int ret;
1761
1762 func_enter();
1763
1764 if (sx_paranoia_check(port, tty->name, "sx_write_room")) {
1765 func_exit();
1766 return 0;
1767 }
1768
1769 ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1770 if (ret < 0)
1771 ret = 0;
1772
1773 func_exit();
1774 return ret;
1775 }
1776
1777
1778 static int sx_chars_in_buffer(struct tty_struct *tty)
1779 {
1780 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1781
1782 func_enter();
1783
1784 if (sx_paranoia_check(port, tty->name, "sx_chars_in_buffer")) {
1785 func_exit();
1786 return 0;
1787 }
1788 func_exit();
1789 return port->xmit_cnt;
1790 }
1791
1792
1793
1794 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1795 {
1796 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1797 struct specialix_board * bp;
1798 unsigned char status;
1799 unsigned int result;
1800 unsigned long flags;
1801
1802 func_enter();
1803
1804 if (sx_paranoia_check(port, tty->name, __FUNCTION__)) {
1805 func_exit();
1806 return -ENODEV;
1807 }
1808
1809 bp = port_Board(port);
1810 spin_lock_irqsave (&bp->lock, flags);
1811 sx_out(bp, CD186x_CAR, port_No(port));
1812 status = sx_in(bp, CD186x_MSVR);
1813 spin_unlock_irqrestore(&bp->lock, flags);
1814 dprintk (SX_DEBUG_INIT, "Got msvr[%d] = %02x, car = %d.\n",
1815 port_No(port), status, sx_in (bp, CD186x_CAR));
1816 dprintk (SX_DEBUG_INIT, "sx_port = %p, port = %p\n", sx_port, port);
1817 if (SX_CRTSCTS(port->tty)) {
1818 result = /* (status & MSVR_RTS) ? */ TIOCM_DTR /* : 0) */
1819 | ((status & MSVR_DTR) ? TIOCM_RTS : 0)
1820 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1821 |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
1822 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1823 } else {
1824 result = /* (status & MSVR_RTS) ? */ TIOCM_RTS /* : 0) */
1825 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1826 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1827 |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
1828 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1829 }
1830
1831 func_exit();
1832
1833 return result;
1834 }
1835
1836
1837 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1838 unsigned int set, unsigned int clear)
1839 {
1840 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1841 unsigned long flags;
1842 struct specialix_board *bp;
1843
1844 func_enter();
1845
1846 if (sx_paranoia_check(port, tty->name, __FUNCTION__)) {
1847 func_exit();
1848 return -ENODEV;
1849 }
1850
1851 bp = port_Board(port);
1852
1853 spin_lock_irqsave(&port->lock, flags);
1854 /* if (set & TIOCM_RTS)
1855 port->MSVR |= MSVR_RTS; */
1856 /* if (set & TIOCM_DTR)
1857 port->MSVR |= MSVR_DTR; */
1858
1859 if (SX_CRTSCTS(port->tty)) {
1860 if (set & TIOCM_RTS)
1861 port->MSVR |= MSVR_DTR;
1862 } else {
1863 if (set & TIOCM_DTR)
1864 port->MSVR |= MSVR_DTR;
1865 }
1866
1867 /* if (clear & TIOCM_RTS)
1868 port->MSVR &= ~MSVR_RTS; */
1869 /* if (clear & TIOCM_DTR)
1870 port->MSVR &= ~MSVR_DTR; */
1871 if (SX_CRTSCTS(port->tty)) {
1872 if (clear & TIOCM_RTS)
1873 port->MSVR &= ~MSVR_DTR;
1874 } else {
1875 if (clear & TIOCM_DTR)
1876 port->MSVR &= ~MSVR_DTR;
1877 }
1878 spin_lock_irqsave(&bp->lock, flags);
1879 sx_out(bp, CD186x_CAR, port_No(port));
1880 sx_out(bp, CD186x_MSVR, port->MSVR);
1881 spin_unlock_irqrestore(&bp->lock, flags);
1882 spin_unlock_irqrestore(&port->lock, flags);
1883 func_exit();
1884 return 0;
1885 }
1886
1887
1888 static inline void sx_send_break(struct specialix_port * port, unsigned long length)
1889 {
1890 struct specialix_board *bp = port_Board(port);
1891 unsigned long flags;
1892
1893 func_enter();
1894
1895 spin_lock_irqsave (&port->lock, flags);
1896 port->break_length = SPECIALIX_TPS / HZ * length;
1897 port->COR2 |= COR2_ETC;
1898 port->IER |= IER_TXRDY;
1899 spin_lock_irqsave(&bp->lock, flags);
1900 sx_out(bp, CD186x_CAR, port_No(port));
1901 sx_out(bp, CD186x_COR2, port->COR2);
1902 sx_out(bp, CD186x_IER, port->IER);
1903 spin_unlock_irqrestore(&bp->lock, flags);
1904 spin_unlock_irqrestore (&port->lock, flags);
1905 sx_wait_CCR(bp);
1906 spin_lock_irqsave(&bp->lock, flags);
1907 sx_out(bp, CD186x_CCR, CCR_CORCHG2);
1908 spin_unlock_irqrestore(&bp->lock, flags);
1909 sx_wait_CCR(bp);
1910
1911 func_exit();
1912 }
1913
1914
1915 static inline int sx_set_serial_info(struct specialix_port * port,
1916 struct serial_struct __user * newinfo)
1917 {
1918 struct serial_struct tmp;
1919 struct specialix_board *bp = port_Board(port);
1920 int change_speed;
1921
1922 func_enter();
1923
1924 if (copy_from_user(&tmp, newinfo, sizeof(tmp))) {
1925 func_enter();
1926 return -EFAULT;
1927 }
1928
1929 lock_kernel();
1930
1931 change_speed = ((port->flags & ASYNC_SPD_MASK) !=
1932 (tmp.flags & ASYNC_SPD_MASK));
1933 change_speed |= (tmp.custom_divisor != port->custom_divisor);
1934
1935 if (!capable(CAP_SYS_ADMIN)) {
1936 if ((tmp.close_delay != port->close_delay) ||
1937 (tmp.closing_wait != port->closing_wait) ||
1938 ((tmp.flags & ~ASYNC_USR_MASK) !=
1939 (port->flags & ~ASYNC_USR_MASK))) {
1940 func_exit();
1941 unlock_kernel();
1942 return -EPERM;
1943 }
1944 port->flags = ((port->flags & ~ASYNC_USR_MASK) |
1945 (tmp.flags & ASYNC_USR_MASK));
1946 port->custom_divisor = tmp.custom_divisor;
1947 } else {
1948 port->flags = ((port->flags & ~ASYNC_FLAGS) |
1949 (tmp.flags & ASYNC_FLAGS));
1950 port->close_delay = tmp.close_delay;
1951 port->closing_wait = tmp.closing_wait;
1952 port->custom_divisor = tmp.custom_divisor;
1953 }
1954 if (change_speed) {
1955 sx_change_speed(bp, port);
1956 }
1957 func_exit();
1958 unlock_kernel();
1959 return 0;
1960 }
1961
1962
1963 static inline int sx_get_serial_info(struct specialix_port * port,
1964 struct serial_struct __user *retinfo)
1965 {
1966 struct serial_struct tmp;
1967 struct specialix_board *bp = port_Board(port);
1968
1969 func_enter();
1970
1971 memset(&tmp, 0, sizeof(tmp));
1972 lock_kernel();
1973 tmp.type = PORT_CIRRUS;
1974 tmp.line = port - sx_port;
1975 tmp.port = bp->base;
1976 tmp.irq = bp->irq;
1977 tmp.flags = port->flags;
1978 tmp.baud_base = (SX_OSCFREQ + CD186x_TPC/2) / CD186x_TPC;
1979 tmp.close_delay = port->close_delay * HZ/100;
1980 tmp.closing_wait = port->closing_wait * HZ/100;
1981 tmp.custom_divisor = port->custom_divisor;
1982 tmp.xmit_fifo_size = CD186x_NFIFO;
1983 unlock_kernel();
1984 if (copy_to_user(retinfo, &tmp, sizeof(tmp))) {
1985 func_exit();
1986 return -EFAULT;
1987 }
1988
1989 func_exit();
1990 return 0;
1991 }
1992
1993
1994 static int sx_ioctl(struct tty_struct * tty, struct file * filp,
1995 unsigned int cmd, unsigned long arg)
1996 {
1997 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1998 int retval;
1999 void __user *argp = (void __user *)arg;
2000
2001 func_enter();
2002
2003 if (sx_paranoia_check(port, tty->name, "sx_ioctl")) {
2004 func_exit();
2005 return -ENODEV;
2006 }
2007
2008 switch (cmd) {
2009 case TCSBRK: /* SVID version: non-zero arg --> no break */
2010 retval = tty_check_change(tty);
2011 if (retval) {
2012 func_exit();
2013 return retval;
2014 }
2015 tty_wait_until_sent(tty, 0);
2016 if (!arg)
2017 sx_send_break(port, HZ/4); /* 1/4 second */
2018 return 0;
2019 case TCSBRKP: /* support for POSIX tcsendbreak() */
2020 retval = tty_check_change(tty);
2021 if (retval) {
2022 func_exit();
2023 return retval;
2024 }
2025 tty_wait_until_sent(tty, 0);
2026 sx_send_break(port, arg ? arg*(HZ/10) : HZ/4);
2027 func_exit();
2028 return 0;
2029 case TIOCGSERIAL:
2030 func_exit();
2031 return sx_get_serial_info(port, argp);
2032 case TIOCSSERIAL:
2033 func_exit();
2034 return sx_set_serial_info(port, argp);
2035 default:
2036 func_exit();
2037 return -ENOIOCTLCMD;
2038 }
2039 func_exit();
2040 return 0;
2041 }
2042
2043
2044 static void sx_throttle(struct tty_struct * tty)
2045 {
2046 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2047 struct specialix_board *bp;
2048 unsigned long flags;
2049
2050 func_enter();
2051
2052 if (sx_paranoia_check(port, tty->name, "sx_throttle")) {
2053 func_exit();
2054 return;
2055 }
2056
2057 bp = port_Board(port);
2058
2059 /* Use DTR instead of RTS ! */
2060 if (SX_CRTSCTS (tty))
2061 port->MSVR &= ~MSVR_DTR;
2062 else {
2063 /* Auch!!! I think the system shouldn't call this then. */
2064 /* Or maybe we're supposed (allowed?) to do our side of hw
2065 handshake anyway, even when hardware handshake is off.
2066 When you see this in your logs, please report.... */
2067 printk (KERN_ERR "sx%d: Need to throttle, but can't (hardware hs is off)\n",
2068 port_No (port));
2069 }
2070 spin_lock_irqsave(&bp->lock, flags);
2071 sx_out(bp, CD186x_CAR, port_No(port));
2072 spin_unlock_irqrestore(&bp->lock, flags);
2073 if (I_IXOFF(tty)) {
2074 sx_wait_CCR(bp);
2075 spin_lock_irqsave(&bp->lock, flags);
2076 sx_out(bp, CD186x_CCR, CCR_SSCH2);
2077 spin_unlock_irqrestore(&bp->lock, flags);
2078 sx_wait_CCR(bp);
2079 }
2080 spin_lock_irqsave(&bp->lock, flags);
2081 sx_out(bp, CD186x_MSVR, port->MSVR);
2082 spin_unlock_irqrestore(&bp->lock, flags);
2083
2084 func_exit();
2085 }
2086
2087
2088 static void sx_unthrottle(struct tty_struct * tty)
2089 {
2090 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2091 struct specialix_board *bp;
2092 unsigned long flags;
2093
2094 func_enter();
2095
2096 if (sx_paranoia_check(port, tty->name, "sx_unthrottle")) {
2097 func_exit();
2098 return;
2099 }
2100
2101 bp = port_Board(port);
2102
2103 spin_lock_irqsave(&port->lock, flags);
2104 /* XXXX Use DTR INSTEAD???? */
2105 if (SX_CRTSCTS(tty)) {
2106 port->MSVR |= MSVR_DTR;
2107 } /* Else clause: see remark in "sx_throttle"... */
2108 spin_lock_irqsave(&bp->lock, flags);
2109 sx_out(bp, CD186x_CAR, port_No(port));
2110 spin_unlock_irqrestore(&bp->lock, flags);
2111 if (I_IXOFF(tty)) {
2112 spin_unlock_irqrestore(&port->lock, flags);
2113 sx_wait_CCR(bp);
2114 spin_lock_irqsave(&bp->lock, flags);
2115 sx_out(bp, CD186x_CCR, CCR_SSCH1);
2116 spin_unlock_irqrestore(&bp->lock, flags);
2117 sx_wait_CCR(bp);
2118 spin_lock_irqsave(&port->lock, flags);
2119 }
2120 spin_lock_irqsave(&bp->lock, flags);
2121 sx_out(bp, CD186x_MSVR, port->MSVR);
2122 spin_unlock_irqrestore(&bp->lock, flags);
2123 spin_unlock_irqrestore(&port->lock, flags);
2124
2125 func_exit();
2126 }
2127
2128
2129 static void sx_stop(struct tty_struct * tty)
2130 {
2131 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2132 struct specialix_board *bp;
2133 unsigned long flags;
2134
2135 func_enter();
2136
2137 if (sx_paranoia_check(port, tty->name, "sx_stop")) {
2138 func_exit();
2139 return;
2140 }
2141
2142 bp = port_Board(port);
2143
2144 spin_lock_irqsave(&port->lock, flags);
2145 port->IER &= ~IER_TXRDY;
2146 spin_lock_irqsave(&bp->lock, flags);
2147 sx_out(bp, CD186x_CAR, port_No(port));
2148 sx_out(bp, CD186x_IER, port->IER);
2149 spin_unlock_irqrestore(&bp->lock, flags);
2150 spin_unlock_irqrestore(&port->lock, flags);
2151
2152 func_exit();
2153 }
2154
2155
2156 static void sx_start(struct tty_struct * tty)
2157 {
2158 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2159 struct specialix_board *bp;
2160 unsigned long flags;
2161
2162 func_enter();
2163
2164 if (sx_paranoia_check(port, tty->name, "sx_start")) {
2165 func_exit();
2166 return;
2167 }
2168
2169 bp = port_Board(port);
2170
2171 spin_lock_irqsave(&port->lock, flags);
2172 if (port->xmit_cnt && port->xmit_buf && !(port->IER & IER_TXRDY)) {
2173 port->IER |= IER_TXRDY;
2174 spin_lock_irqsave(&bp->lock, flags);
2175 sx_out(bp, CD186x_CAR, port_No(port));
2176 sx_out(bp, CD186x_IER, port->IER);
2177 spin_unlock_irqrestore(&bp->lock, flags);
2178 }
2179 spin_unlock_irqrestore(&port->lock, flags);
2180
2181 func_exit();
2182 }
2183
2184 static void sx_hangup(struct tty_struct * tty)
2185 {
2186 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2187 struct specialix_board *bp;
2188 unsigned long flags;
2189
2190 func_enter();
2191
2192 if (sx_paranoia_check(port, tty->name, "sx_hangup")) {
2193 func_exit();
2194 return;
2195 }
2196
2197 bp = port_Board(port);
2198
2199 sx_shutdown_port(bp, port);
2200 spin_lock_irqsave(&port->lock, flags);
2201 bp->count -= port->count;
2202 if (bp->count < 0) {
2203 printk(KERN_ERR "sx%d: sx_hangup: bad board count: %d port: %d\n",
2204 board_No(bp), bp->count, tty->index);
2205 bp->count = 0;
2206 }
2207 port->count = 0;
2208 port->flags &= ~ASYNC_NORMAL_ACTIVE;
2209 port->tty = NULL;
2210 spin_unlock_irqrestore(&port->lock, flags);
2211 wake_up_interruptible(&port->open_wait);
2212
2213 func_exit();
2214 }
2215
2216
2217 static void sx_set_termios(struct tty_struct * tty, struct ktermios * old_termios)
2218 {
2219 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2220 unsigned long flags;
2221 struct specialix_board * bp;
2222
2223 if (sx_paranoia_check(port, tty->name, "sx_set_termios"))
2224 return;
2225
2226 if (tty->termios->c_cflag == old_termios->c_cflag &&
2227 tty->termios->c_iflag == old_termios->c_iflag)
2228 return;
2229
2230 bp = port_Board(port);
2231 spin_lock_irqsave(&port->lock, flags);
2232 sx_change_speed(port_Board(port), port);
2233 spin_unlock_irqrestore(&port->lock, flags);
2234
2235 if ((old_termios->c_cflag & CRTSCTS) &&
2236 !(tty->termios->c_cflag & CRTSCTS)) {
2237 tty->hw_stopped = 0;
2238 sx_start(tty);
2239 }
2240 }
2241
2242 static const struct tty_operations sx_ops = {
2243 .open = sx_open,
2244 .close = sx_close,
2245 .write = sx_write,
2246 .put_char = sx_put_char,
2247 .flush_chars = sx_flush_chars,
2248 .write_room = sx_write_room,
2249 .chars_in_buffer = sx_chars_in_buffer,
2250 .flush_buffer = sx_flush_buffer,
2251 .ioctl = sx_ioctl,
2252 .throttle = sx_throttle,
2253 .unthrottle = sx_unthrottle,
2254 .set_termios = sx_set_termios,
2255 .stop = sx_stop,
2256 .start = sx_start,
2257 .hangup = sx_hangup,
2258 .tiocmget = sx_tiocmget,
2259 .tiocmset = sx_tiocmset,
2260 };
2261
2262 static int sx_init_drivers(void)
2263 {
2264 int error;
2265 int i;
2266
2267 func_enter();
2268
2269 specialix_driver = alloc_tty_driver(SX_NBOARD * SX_NPORT);
2270 if (!specialix_driver) {
2271 printk(KERN_ERR "sx: Couldn't allocate tty_driver.\n");
2272 func_exit();
2273 return 1;
2274 }
2275
2276 specialix_driver->owner = THIS_MODULE;
2277 specialix_driver->name = "ttyW";
2278 specialix_driver->major = SPECIALIX_NORMAL_MAJOR;
2279 specialix_driver->type = TTY_DRIVER_TYPE_SERIAL;
2280 specialix_driver->subtype = SERIAL_TYPE_NORMAL;
2281 specialix_driver->init_termios = tty_std_termios;
2282 specialix_driver->init_termios.c_cflag =
2283 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2284 specialix_driver->init_termios.c_ispeed = 9600;
2285 specialix_driver->init_termios.c_ospeed = 9600;
2286 specialix_driver->flags = TTY_DRIVER_REAL_RAW;
2287 tty_set_operations(specialix_driver, &sx_ops);
2288
2289 if ((error = tty_register_driver(specialix_driver))) {
2290 put_tty_driver(specialix_driver);
2291 printk(KERN_ERR "sx: Couldn't register specialix IO8+ driver, error = %d\n",
2292 error);
2293 func_exit();
2294 return 1;
2295 }
2296 memset(sx_port, 0, sizeof(sx_port));
2297 for (i = 0; i < SX_NPORT * SX_NBOARD; i++) {
2298 sx_port[i].magic = SPECIALIX_MAGIC;
2299 sx_port[i].close_delay = 50 * HZ/100;
2300 sx_port[i].closing_wait = 3000 * HZ/100;
2301 init_waitqueue_head(&sx_port[i].open_wait);
2302 init_waitqueue_head(&sx_port[i].close_wait);
2303 spin_lock_init(&sx_port[i].lock);
2304 }
2305
2306 func_exit();
2307 return 0;
2308 }
2309
2310 static void sx_release_drivers(void)
2311 {
2312 func_enter();
2313
2314 tty_unregister_driver(specialix_driver);
2315 put_tty_driver(specialix_driver);
2316 func_exit();
2317 }
2318
2319 /*
2320 * This routine must be called by kernel at boot time
2321 */
2322 static int __init specialix_init(void)
2323 {
2324 int i;
2325 int found = 0;
2326
2327 func_enter();
2328
2329 printk(KERN_INFO "sx: Specialix IO8+ driver v" VERSION ", (c) R.E.Wolff 1997/1998.\n");
2330 printk(KERN_INFO "sx: derived from work (c) D.Gorodchanin 1994-1996.\n");
2331 #ifdef CONFIG_SPECIALIX_RTSCTS
2332 printk (KERN_INFO "sx: DTR/RTS pin is always RTS.\n");
2333 #else
2334 printk (KERN_INFO "sx: DTR/RTS pin is RTS when CRTSCTS is on.\n");
2335 #endif
2336
2337 for (i = 0; i < SX_NBOARD; i++)
2338 spin_lock_init(&sx_board[i].lock);
2339
2340 if (sx_init_drivers()) {
2341 func_exit();
2342 return -EIO;
2343 }
2344
2345 for (i = 0; i < SX_NBOARD; i++)
2346 if (sx_board[i].base && !sx_probe(&sx_board[i]))
2347 found++;
2348
2349 #ifdef CONFIG_PCI
2350 {
2351 struct pci_dev *pdev = NULL;
2352
2353 i=0;
2354 while (i < SX_NBOARD) {
2355 if (sx_board[i].flags & SX_BOARD_PRESENT) {
2356 i++;
2357 continue;
2358 }
2359 pdev = pci_get_device (PCI_VENDOR_ID_SPECIALIX,
2360 PCI_DEVICE_ID_SPECIALIX_IO8,
2361 pdev);
2362 if (!pdev) break;
2363
2364 if (pci_enable_device(pdev))
2365 continue;
2366
2367 sx_board[i].irq = pdev->irq;
2368
2369 sx_board[i].base = pci_resource_start (pdev, 2);
2370
2371 sx_board[i].flags |= SX_BOARD_IS_PCI;
2372 if (!sx_probe(&sx_board[i]))
2373 found ++;
2374 }
2375 /* May exit pci_get sequence early with lots of boards */
2376 if (pdev != NULL)
2377 pci_dev_put(pdev);
2378 }
2379 #endif
2380
2381 if (!found) {
2382 sx_release_drivers();
2383 printk(KERN_INFO "sx: No specialix IO8+ boards detected.\n");
2384 func_exit();
2385 return -EIO;
2386 }
2387
2388 func_exit();
2389 return 0;
2390 }
2391
2392 static int iobase[SX_NBOARD] = {0,};
2393
2394 static int irq [SX_NBOARD] = {0,};
2395
2396 module_param_array(iobase, int, NULL, 0);
2397 module_param_array(irq, int, NULL, 0);
2398 module_param(sx_debug, int, 0);
2399 module_param(sx_rxfifo, int, 0);
2400 #ifdef SPECIALIX_TIMER
2401 module_param(sx_poll, int, 0);
2402 #endif
2403
2404 /*
2405 * You can setup up to 4 boards.
2406 * by specifying "iobase=0xXXX,0xXXX ..." as insmod parameter.
2407 * You should specify the IRQs too in that case "irq=....,...".
2408 *
2409 * More than 4 boards in one computer is not possible, as the card can
2410 * only use 4 different interrupts.
2411 *
2412 */
2413 static int __init specialix_init_module(void)
2414 {
2415 int i;
2416
2417 func_enter();
2418
2419 if (iobase[0] || iobase[1] || iobase[2] || iobase[3]) {
2420 for(i = 0; i < SX_NBOARD; i++) {
2421 sx_board[i].base = iobase[i];
2422 sx_board[i].irq = irq[i];
2423 sx_board[i].count= 0;
2424 }
2425 }
2426
2427 func_exit();
2428
2429 return specialix_init();
2430 }
2431
2432 static void __exit specialix_exit_module(void)
2433 {
2434 int i;
2435
2436 func_enter();
2437
2438 sx_release_drivers();
2439 for (i = 0; i < SX_NBOARD; i++)
2440 if (sx_board[i].flags & SX_BOARD_PRESENT)
2441 sx_release_io_range(&sx_board[i]);
2442 #ifdef SPECIALIX_TIMER
2443 del_timer_sync(&missed_irq_timer);
2444 #endif
2445
2446 func_exit();
2447 }
2448
2449 static struct pci_device_id specialx_pci_tbl[] __devinitdata = {
2450 { PCI_DEVICE(PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_IO8) },
2451 { }
2452 };
2453 MODULE_DEVICE_TABLE(pci, specialx_pci_tbl);
2454
2455 module_init(specialix_init_module);
2456 module_exit(specialix_exit_module);
2457
2458 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.108093 seconds and 5 git commands to generate.