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