]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - drivers/char/specialix.c
projects / mirror_ubuntu-zesty-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'x86-mrst-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[mirror_ubuntu-zesty-kernel.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/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 #include <linux/gfp.h>
98
99 #include "specialix_io8.h"
100 #include "cd1865.h"
101
102
103 /*
104 This driver can spew a whole lot of debugging output at you. If you
105 need maximum performance, you should disable the DEBUG define. To
106 aid in debugging in the field, I'm leaving the compile-time debug
107 features enabled, and disable them "runtime". That allows me to
108 instruct people with problems to enable debugging without requiring
109 them to recompile...
110 */
111 #define DEBUG
112
113 static int sx_debug;
114 static int sx_rxfifo = SPECIALIX_RXFIFO;
115 static int sx_rtscts;
116
117 #ifdef DEBUG
118 #define dprintk(f, str...) if (sx_debug & f) printk(str)
119 #else
120 #define dprintk(f, str...) /* nothing */
121 #endif
122
123 #define SX_DEBUG_FLOW 0x0001
124 #define SX_DEBUG_DATA 0x0002
125 #define SX_DEBUG_PROBE 0x0004
126 #define SX_DEBUG_CHAN 0x0008
127 #define SX_DEBUG_INIT 0x0010
128 #define SX_DEBUG_RX 0x0020
129 #define SX_DEBUG_TX 0x0040
130 #define SX_DEBUG_IRQ 0x0080
131 #define SX_DEBUG_OPEN 0x0100
132 #define SX_DEBUG_TERMIOS 0x0200
133 #define SX_DEBUG_SIGNALS 0x0400
134 #define SX_DEBUG_FIFO 0x0800
135
136
137 #define func_enter() dprintk(SX_DEBUG_FLOW, "io8: enter %s\n", __func__)
138 #define func_exit() dprintk(SX_DEBUG_FLOW, "io8: exit %s\n", __func__)
139
140
141 /* Configurable options: */
142
143 /* Am I paranoid or not ? ;-) */
144 #define SPECIALIX_PARANOIA_CHECK
145
146 /*
147 * The following defines are mostly for testing purposes. But if you need
148 * some nice reporting in your syslog, you can define them also.
149 */
150 #undef SX_REPORT_FIFO
151 #undef SX_REPORT_OVERRUN
152
153
154
155
156 #define SPECIALIX_LEGAL_FLAGS \
157 (ASYNC_HUP_NOTIFY | ASYNC_SAK | ASYNC_SPLIT_TERMIOS | \
158 ASYNC_SPD_HI | ASYNC_SPEED_VHI | ASYNC_SESSION_LOCKOUT | \
159 ASYNC_PGRP_LOCKOUT | ASYNC_CALLOUT_NOHUP)
160
161 static struct tty_driver *specialix_driver;
162
163 static struct specialix_board sx_board[SX_NBOARD] = {
164 { 0, SX_IOBASE1, 9, },
165 { 0, SX_IOBASE2, 11, },
166 { 0, SX_IOBASE3, 12, },
167 { 0, SX_IOBASE4, 15, },
168 };
169
170 static struct specialix_port sx_port[SX_NBOARD * SX_NPORT];
171
172
173 static int sx_paranoia_check(struct specialix_port const *port,
174 char *name, const char *routine)
175 {
176 #ifdef SPECIALIX_PARANOIA_CHECK
177 static const char *badmagic = KERN_ERR
178 "sx: Warning: bad specialix port magic number for device %s in %s\n";
179 static const char *badinfo = KERN_ERR
180 "sx: Warning: null specialix port for device %s in %s\n";
181
182 if (!port) {
183 printk(badinfo, name, routine);
184 return 1;
185 }
186 if (port->magic != SPECIALIX_MAGIC) {
187 printk(badmagic, name, routine);
188 return 1;
189 }
190 #endif
191 return 0;
192 }
193
194
195 /*
196 *
197 * Service functions for specialix IO8+ driver.
198 *
199 */
200
201 /* Get board number from pointer */
202 static inline int board_No(struct specialix_board *bp)
203 {
204 return bp - sx_board;
205 }
206
207
208 /* Get port number from pointer */
209 static inline int port_No(struct specialix_port const *port)
210 {
211 return SX_PORT(port - sx_port);
212 }
213
214
215 /* Get pointer to board from pointer to port */
216 static inline struct specialix_board *port_Board(
217 struct specialix_port const *port)
218 {
219 return &sx_board[SX_BOARD(port - sx_port)];
220 }
221
222
223 /* Input Byte from CL CD186x register */
224 static inline unsigned char sx_in(struct specialix_board *bp,
225 unsigned short reg)
226 {
227 bp->reg = reg | 0x80;
228 outb(reg | 0x80, bp->base + SX_ADDR_REG);
229 return inb(bp->base + SX_DATA_REG);
230 }
231
232
233 /* Output Byte to CL CD186x register */
234 static inline void sx_out(struct specialix_board *bp, unsigned short reg,
235 unsigned char val)
236 {
237 bp->reg = reg | 0x80;
238 outb(reg | 0x80, bp->base + SX_ADDR_REG);
239 outb(val, bp->base + SX_DATA_REG);
240 }
241
242
243 /* Input Byte from CL CD186x register */
244 static inline unsigned char sx_in_off(struct specialix_board *bp,
245 unsigned short reg)
246 {
247 bp->reg = reg;
248 outb(reg, bp->base + SX_ADDR_REG);
249 return inb(bp->base + SX_DATA_REG);
250 }
251
252
253 /* Output Byte to CL CD186x register */
254 static inline void sx_out_off(struct specialix_board *bp,
255 unsigned short reg, unsigned char val)
256 {
257 bp->reg = reg;
258 outb(reg, bp->base + SX_ADDR_REG);
259 outb(val, bp->base + SX_DATA_REG);
260 }
261
262
263 /* Wait for Channel Command Register ready */
264 static void sx_wait_CCR(struct specialix_board *bp)
265 {
266 unsigned long delay, flags;
267 unsigned char ccr;
268
269 for (delay = SX_CCR_TIMEOUT; delay; delay--) {
270 spin_lock_irqsave(&bp->lock, flags);
271 ccr = sx_in(bp, CD186x_CCR);
272 spin_unlock_irqrestore(&bp->lock, flags);
273 if (!ccr)
274 return;
275 udelay(1);
276 }
277
278 printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
279 }
280
281
282 /* Wait for Channel Command Register ready */
283 static void sx_wait_CCR_off(struct specialix_board *bp)
284 {
285 unsigned long delay;
286 unsigned char crr;
287 unsigned long flags;
288
289 for (delay = SX_CCR_TIMEOUT; delay; delay--) {
290 spin_lock_irqsave(&bp->lock, flags);
291 crr = sx_in_off(bp, CD186x_CCR);
292 spin_unlock_irqrestore(&bp->lock, flags);
293 if (!crr)
294 return;
295 udelay(1);
296 }
297
298 printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
299 }
300
301
302 /*
303 * specialix IO8+ IO range functions.
304 */
305
306 static int sx_request_io_range(struct specialix_board *bp)
307 {
308 return request_region(bp->base,
309 bp->flags & SX_BOARD_IS_PCI ? SX_PCI_IO_SPACE : SX_IO_SPACE,
310 "specialix IO8+") == NULL;
311 }
312
313
314 static void sx_release_io_range(struct specialix_board *bp)
315 {
316 release_region(bp->base, bp->flags & SX_BOARD_IS_PCI ?
317 SX_PCI_IO_SPACE : SX_IO_SPACE);
318 }
319
320
321 /* Set the IRQ using the RTS lines that run to the PAL on the board.... */
322 static int sx_set_irq(struct specialix_board *bp)
323 {
324 int virq;
325 int i;
326 unsigned long flags;
327
328 if (bp->flags & SX_BOARD_IS_PCI)
329 return 1;
330 switch (bp->irq) {
331 /* In the same order as in the docs... */
332 case 15:
333 virq = 0;
334 break;
335 case 12:
336 virq = 1;
337 break;
338 case 11:
339 virq = 2;
340 break;
341 case 9:
342 virq = 3;
343 break;
344 default:printk(KERN_ERR
345 "Speclialix: cannot set irq to %d.\n", bp->irq);
346 return 0;
347 }
348 spin_lock_irqsave(&bp->lock, flags);
349 for (i = 0; i < 2; i++) {
350 sx_out(bp, CD186x_CAR, i);
351 sx_out(bp, CD186x_MSVRTS, ((virq >> i) & 0x1)? MSVR_RTS:0);
352 }
353 spin_unlock_irqrestore(&bp->lock, flags);
354 return 1;
355 }
356
357
358 /* Reset and setup CD186x chip */
359 static int sx_init_CD186x(struct specialix_board *bp)
360 {
361 unsigned long flags;
362 int scaler;
363 int rv = 1;
364
365 func_enter();
366 sx_wait_CCR_off(bp); /* Wait for CCR ready */
367 spin_lock_irqsave(&bp->lock, flags);
368 sx_out_off(bp, CD186x_CCR, CCR_HARDRESET); /* Reset CD186x chip */
369 spin_unlock_irqrestore(&bp->lock, flags);
370 msleep(50); /* Delay 0.05 sec */
371 spin_lock_irqsave(&bp->lock, flags);
372 sx_out_off(bp, CD186x_GIVR, SX_ID); /* Set ID for this chip */
373 sx_out_off(bp, CD186x_GICR, 0); /* Clear all bits */
374 sx_out_off(bp, CD186x_PILR1, SX_ACK_MINT); /* Prio for modem intr */
375 sx_out_off(bp, CD186x_PILR2, SX_ACK_TINT); /* Prio for transmitter intr */
376 sx_out_off(bp, CD186x_PILR3, SX_ACK_RINT); /* Prio for receiver intr */
377 /* Set RegAckEn */
378 sx_out_off(bp, CD186x_SRCR, sx_in(bp, CD186x_SRCR) | SRCR_REGACKEN);
379
380 /* Setting up prescaler. We need 4 ticks per 1 ms */
381 scaler = SX_OSCFREQ/SPECIALIX_TPS;
382
383 sx_out_off(bp, CD186x_PPRH, scaler >> 8);
384 sx_out_off(bp, CD186x_PPRL, scaler & 0xff);
385 spin_unlock_irqrestore(&bp->lock, flags);
386
387 if (!sx_set_irq(bp)) {
388 /* Figure out how to pass this along... */
389 printk(KERN_ERR "Cannot set irq to %d.\n", bp->irq);
390 rv = 0;
391 }
392
393 func_exit();
394 return rv;
395 }
396
397
398 static int read_cross_byte(struct specialix_board *bp, int reg, int bit)
399 {
400 int i;
401 int t;
402 unsigned long flags;
403
404 spin_lock_irqsave(&bp->lock, flags);
405 for (i = 0, t = 0; i < 8; i++) {
406 sx_out_off(bp, CD186x_CAR, i);
407 if (sx_in_off(bp, reg) & bit)
408 t |= 1 << i;
409 }
410 spin_unlock_irqrestore(&bp->lock, flags);
411
412 return t;
413 }
414
415
416 /* Main probing routine, also sets irq. */
417 static int sx_probe(struct specialix_board *bp)
418 {
419 unsigned char val1, val2;
420 int rev;
421 int chip;
422
423 func_enter();
424
425 if (sx_request_io_range(bp)) {
426 func_exit();
427 return 1;
428 }
429
430 /* Are the I/O ports here ? */
431 sx_out_off(bp, CD186x_PPRL, 0x5a);
432 udelay(1);
433 val1 = sx_in_off(bp, CD186x_PPRL);
434
435 sx_out_off(bp, CD186x_PPRL, 0xa5);
436 udelay(1);
437 val2 = sx_in_off(bp, CD186x_PPRL);
438
439
440 if (val1 != 0x5a || val2 != 0xa5) {
441 printk(KERN_INFO
442 "sx%d: specialix IO8+ Board at 0x%03x not found.\n",
443 board_No(bp), bp->base);
444 sx_release_io_range(bp);
445 func_exit();
446 return 1;
447 }
448
449 /* Check the DSR lines that Specialix uses as board
450 identification */
451 val1 = read_cross_byte(bp, CD186x_MSVR, MSVR_DSR);
452 val2 = read_cross_byte(bp, CD186x_MSVR, MSVR_RTS);
453 dprintk(SX_DEBUG_INIT,
454 "sx%d: DSR lines are: %02x, rts lines are: %02x\n",
455 board_No(bp), val1, val2);
456
457 /* They managed to switch the bit order between the docs and
458 the IO8+ card. The new PCI card now conforms to old docs.
459 They changed the PCI docs to reflect the situation on the
460 old card. */
461 val2 = (bp->flags & SX_BOARD_IS_PCI)?0x4d : 0xb2;
462 if (val1 != val2) {
463 printk(KERN_INFO
464 "sx%d: specialix IO8+ ID %02x at 0x%03x not found (%02x).\n",
465 board_No(bp), val2, bp->base, val1);
466 sx_release_io_range(bp);
467 func_exit();
468 return 1;
469 }
470
471
472 /* Reset CD186x again */
473 if (!sx_init_CD186x(bp)) {
474 sx_release_io_range(bp);
475 func_exit();
476 return 1;
477 }
478
479 sx_request_io_range(bp);
480 bp->flags |= SX_BOARD_PRESENT;
481
482 /* Chip revcode pkgtype
483 GFRCR SRCR bit 7
484 CD180 rev B 0x81 0
485 CD180 rev C 0x82 0
486 CD1864 rev A 0x82 1
487 CD1865 rev A 0x83 1 -- Do not use!!! Does not work.
488 CD1865 rev B 0x84 1
489 -- Thanks to Gwen Wang, Cirrus Logic.
490 */
491
492 switch (sx_in_off(bp, CD186x_GFRCR)) {
493 case 0x82:
494 chip = 1864;
495 rev = 'A';
496 break;
497 case 0x83:
498 chip = 1865;
499 rev = 'A';
500 break;
501 case 0x84:
502 chip = 1865;
503 rev = 'B';
504 break;
505 case 0x85:
506 chip = 1865;
507 rev = 'C';
508 break; /* Does not exist at this time */
509 default:
510 chip = -1;
511 rev = 'x';
512 }
513
514 dprintk(SX_DEBUG_INIT, " GFCR = 0x%02x\n", sx_in_off(bp, CD186x_GFRCR));
515
516 printk(KERN_INFO
517 "sx%d: specialix IO8+ board detected at 0x%03x, IRQ %d, CD%d Rev. %c.\n",
518 board_No(bp), bp->base, bp->irq, chip, rev);
519
520 func_exit();
521 return 0;
522 }
523
524 /*
525 *
526 * Interrupt processing routines.
527 * */
528
529 static struct specialix_port *sx_get_port(struct specialix_board *bp,
530 unsigned char const *what)
531 {
532 unsigned char channel;
533 struct specialix_port *port = NULL;
534
535 channel = sx_in(bp, CD186x_GICR) >> GICR_CHAN_OFF;
536 dprintk(SX_DEBUG_CHAN, "channel: %d\n", channel);
537 if (channel < CD186x_NCH) {
538 port = &sx_port[board_No(bp) * SX_NPORT + channel];
539 dprintk(SX_DEBUG_CHAN, "port: %d %p flags: 0x%lx\n",
540 board_No(bp) * SX_NPORT + channel, port,
541 port->port.flags & ASYNC_INITIALIZED);
542
543 if (port->port.flags & ASYNC_INITIALIZED) {
544 dprintk(SX_DEBUG_CHAN, "port: %d %p\n", channel, port);
545 func_exit();
546 return port;
547 }
548 }
549 printk(KERN_INFO "sx%d: %s interrupt from invalid port %d\n",
550 board_No(bp), what, channel);
551 return NULL;
552 }
553
554
555 static void sx_receive_exc(struct specialix_board *bp)
556 {
557 struct specialix_port *port;
558 struct tty_struct *tty;
559 unsigned char status;
560 unsigned char ch, flag;
561
562 func_enter();
563
564 port = sx_get_port(bp, "Receive");
565 if (!port) {
566 dprintk(SX_DEBUG_RX, "Hmm, couldn't find port.\n");
567 func_exit();
568 return;
569 }
570 tty = port->port.tty;
571
572 status = sx_in(bp, CD186x_RCSR);
573
574 dprintk(SX_DEBUG_RX, "status: 0x%x\n", status);
575 if (status & RCSR_OE) {
576 port->overrun++;
577 dprintk(SX_DEBUG_FIFO,
578 "sx%d: port %d: Overrun. Total %ld overruns.\n",
579 board_No(bp), port_No(port), port->overrun);
580 }
581 status &= port->mark_mask;
582
583 /* This flip buffer check needs to be below the reading of the
584 status register to reset the chip's IRQ.... */
585 if (tty_buffer_request_room(tty, 1) == 0) {
586 dprintk(SX_DEBUG_FIFO,
587 "sx%d: port %d: Working around flip buffer overflow.\n",
588 board_No(bp), port_No(port));
589 func_exit();
590 return;
591 }
592
593 ch = sx_in(bp, CD186x_RDR);
594 if (!status) {
595 func_exit();
596 return;
597 }
598 if (status & RCSR_TOUT) {
599 printk(KERN_INFO
600 "sx%d: port %d: Receiver timeout. Hardware problems ?\n",
601 board_No(bp), port_No(port));
602 func_exit();
603 return;
604
605 } else if (status & RCSR_BREAK) {
606 dprintk(SX_DEBUG_RX, "sx%d: port %d: Handling break...\n",
607 board_No(bp), port_No(port));
608 flag = TTY_BREAK;
609 if (port->port.flags & ASYNC_SAK)
610 do_SAK(tty);
611
612 } else if (status & RCSR_PE)
613 flag = TTY_PARITY;
614
615 else if (status & RCSR_FE)
616 flag = TTY_FRAME;
617
618 else if (status & RCSR_OE)
619 flag = TTY_OVERRUN;
620
621 else
622 flag = TTY_NORMAL;
623
624 if (tty_insert_flip_char(tty, ch, flag))
625 tty_flip_buffer_push(tty);
626 func_exit();
627 }
628
629
630 static void sx_receive(struct specialix_board *bp)
631 {
632 struct specialix_port *port;
633 struct tty_struct *tty;
634 unsigned char count;
635
636 func_enter();
637
638 port = sx_get_port(bp, "Receive");
639 if (port == NULL) {
640 dprintk(SX_DEBUG_RX, "Hmm, couldn't find port.\n");
641 func_exit();
642 return;
643 }
644 tty = port->port.tty;
645
646 count = sx_in(bp, CD186x_RDCR);
647 dprintk(SX_DEBUG_RX, "port: %p: count: %d\n", port, count);
648 port->hits[count > 8 ? 9 : count]++;
649
650 while (count--)
651 tty_insert_flip_char(tty, sx_in(bp, CD186x_RDR), TTY_NORMAL);
652 tty_flip_buffer_push(tty);
653 func_exit();
654 }
655
656
657 static void sx_transmit(struct specialix_board *bp)
658 {
659 struct specialix_port *port;
660 struct tty_struct *tty;
661 unsigned char count;
662
663 func_enter();
664 port = sx_get_port(bp, "Transmit");
665 if (port == NULL) {
666 func_exit();
667 return;
668 }
669 dprintk(SX_DEBUG_TX, "port: %p\n", port);
670 tty = port->port.tty;
671
672 if (port->IER & IER_TXEMPTY) {
673 /* FIFO drained */
674 sx_out(bp, CD186x_CAR, port_No(port));
675 port->IER &= ~IER_TXEMPTY;
676 sx_out(bp, CD186x_IER, port->IER);
677 func_exit();
678 return;
679 }
680
681 if ((port->xmit_cnt <= 0 && !port->break_length)
682 || tty->stopped || tty->hw_stopped) {
683 sx_out(bp, CD186x_CAR, port_No(port));
684 port->IER &= ~IER_TXRDY;
685 sx_out(bp, CD186x_IER, port->IER);
686 func_exit();
687 return;
688 }
689
690 if (port->break_length) {
691 if (port->break_length > 0) {
692 if (port->COR2 & COR2_ETC) {
693 sx_out(bp, CD186x_TDR, CD186x_C_ESC);
694 sx_out(bp, CD186x_TDR, CD186x_C_SBRK);
695 port->COR2 &= ~COR2_ETC;
696 }
697 count = min_t(int, port->break_length, 0xff);
698 sx_out(bp, CD186x_TDR, CD186x_C_ESC);
699 sx_out(bp, CD186x_TDR, CD186x_C_DELAY);
700 sx_out(bp, CD186x_TDR, count);
701 port->break_length -= count;
702 if (port->break_length == 0)
703 port->break_length--;
704 } else {
705 sx_out(bp, CD186x_TDR, CD186x_C_ESC);
706 sx_out(bp, CD186x_TDR, CD186x_C_EBRK);
707 sx_out(bp, CD186x_COR2, port->COR2);
708 sx_wait_CCR(bp);
709 sx_out(bp, CD186x_CCR, CCR_CORCHG2);
710 port->break_length = 0;
711 }
712
713 func_exit();
714 return;
715 }
716
717 count = CD186x_NFIFO;
718 do {
719 sx_out(bp, CD186x_TDR, port->xmit_buf[port->xmit_tail++]);
720 port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
721 if (--port->xmit_cnt <= 0)
722 break;
723 } while (--count > 0);
724
725 if (port->xmit_cnt <= 0) {
726 sx_out(bp, CD186x_CAR, port_No(port));
727 port->IER &= ~IER_TXRDY;
728 sx_out(bp, CD186x_IER, port->IER);
729 }
730 if (port->xmit_cnt <= port->wakeup_chars)
731 tty_wakeup(tty);
732
733 func_exit();
734 }
735
736
737 static void sx_check_modem(struct specialix_board *bp)
738 {
739 struct specialix_port *port;
740 struct tty_struct *tty;
741 unsigned char mcr;
742 int msvr_cd;
743
744 dprintk(SX_DEBUG_SIGNALS, "Modem intr. ");
745 port = sx_get_port(bp, "Modem");
746 if (port == NULL)
747 return;
748
749 tty = port->port.tty;
750
751 mcr = sx_in(bp, CD186x_MCR);
752
753 if ((mcr & MCR_CDCHG)) {
754 dprintk(SX_DEBUG_SIGNALS, "CD just changed... ");
755 msvr_cd = sx_in(bp, CD186x_MSVR) & MSVR_CD;
756 if (msvr_cd) {
757 dprintk(SX_DEBUG_SIGNALS, "Waking up guys in open.\n");
758 wake_up_interruptible(&port->port.open_wait);
759 } else {
760 dprintk(SX_DEBUG_SIGNALS, "Sending HUP.\n");
761 tty_hangup(tty);
762 }
763 }
764
765 #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
766 if (mcr & MCR_CTSCHG) {
767 if (sx_in(bp, CD186x_MSVR) & MSVR_CTS) {
768 tty->hw_stopped = 0;
769 port->IER |= IER_TXRDY;
770 if (port->xmit_cnt <= port->wakeup_chars)
771 tty_wakeup(tty);
772 } else {
773 tty->hw_stopped = 1;
774 port->IER &= ~IER_TXRDY;
775 }
776 sx_out(bp, CD186x_IER, port->IER);
777 }
778 if (mcr & MCR_DSSXHG) {
779 if (sx_in(bp, CD186x_MSVR) & MSVR_DSR) {
780 tty->hw_stopped = 0;
781 port->IER |= IER_TXRDY;
782 if (port->xmit_cnt <= port->wakeup_chars)
783 tty_wakeup(tty);
784 } else {
785 tty->hw_stopped = 1;
786 port->IER &= ~IER_TXRDY;
787 }
788 sx_out(bp, CD186x_IER, port->IER);
789 }
790 #endif /* SPECIALIX_BRAIN_DAMAGED_CTS */
791
792 /* Clear change bits */
793 sx_out(bp, CD186x_MCR, 0);
794 }
795
796
797 /* The main interrupt processing routine */
798 static irqreturn_t sx_interrupt(int dummy, void *dev_id)
799 {
800 unsigned char status;
801 unsigned char ack;
802 struct specialix_board *bp = dev_id;
803 unsigned long loop = 0;
804 int saved_reg;
805 unsigned long flags;
806
807 func_enter();
808
809 spin_lock_irqsave(&bp->lock, flags);
810
811 dprintk(SX_DEBUG_FLOW, "enter %s port %d room: %ld\n", __func__,
812 port_No(sx_get_port(bp, "INT")),
813 SERIAL_XMIT_SIZE - sx_get_port(bp, "ITN")->xmit_cnt - 1);
814 if (!(bp->flags & SX_BOARD_ACTIVE)) {
815 dprintk(SX_DEBUG_IRQ, "sx: False interrupt. irq %d.\n",
816 bp->irq);
817 spin_unlock_irqrestore(&bp->lock, flags);
818 func_exit();
819 return IRQ_NONE;
820 }
821
822 saved_reg = bp->reg;
823
824 while (++loop < 16) {
825 status = sx_in(bp, CD186x_SRSR) &
826 (SRSR_RREQint | SRSR_TREQint | SRSR_MREQint);
827 if (status == 0)
828 break;
829 if (status & SRSR_RREQint) {
830 ack = sx_in(bp, CD186x_RRAR);
831
832 if (ack == (SX_ID | GIVR_IT_RCV))
833 sx_receive(bp);
834 else if (ack == (SX_ID | GIVR_IT_REXC))
835 sx_receive_exc(bp);
836 else
837 printk(KERN_ERR
838 "sx%d: status: 0x%x Bad receive ack 0x%02x.\n",
839 board_No(bp), status, ack);
840
841 } else if (status & SRSR_TREQint) {
842 ack = sx_in(bp, CD186x_TRAR);
843
844 if (ack == (SX_ID | GIVR_IT_TX))
845 sx_transmit(bp);
846 else
847 printk(KERN_ERR "sx%d: status: 0x%x Bad transmit ack 0x%02x. port: %d\n",
848 board_No(bp), status, ack,
849 port_No(sx_get_port(bp, "Int")));
850 } else if (status & SRSR_MREQint) {
851 ack = sx_in(bp, CD186x_MRAR);
852
853 if (ack == (SX_ID | GIVR_IT_MODEM))
854 sx_check_modem(bp);
855 else
856 printk(KERN_ERR
857 "sx%d: status: 0x%x Bad modem ack 0x%02x.\n",
858 board_No(bp), status, ack);
859
860 }
861
862 sx_out(bp, CD186x_EOIR, 0); /* Mark end of interrupt */
863 }
864 bp->reg = saved_reg;
865 outb(bp->reg, bp->base + SX_ADDR_REG);
866 spin_unlock_irqrestore(&bp->lock, flags);
867 func_exit();
868 return IRQ_HANDLED;
869 }
870
871
872 /*
873 * Routines for open & close processing.
874 */
875
876 static void turn_ints_off(struct specialix_board *bp)
877 {
878 unsigned long flags;
879
880 func_enter();
881 spin_lock_irqsave(&bp->lock, flags);
882 (void) sx_in_off(bp, 0); /* Turn off interrupts. */
883 spin_unlock_irqrestore(&bp->lock, flags);
884
885 func_exit();
886 }
887
888 static void turn_ints_on(struct specialix_board *bp)
889 {
890 unsigned long flags;
891
892 func_enter();
893
894 spin_lock_irqsave(&bp->lock, flags);
895 (void) sx_in(bp, 0); /* Turn ON interrupts. */
896 spin_unlock_irqrestore(&bp->lock, flags);
897
898 func_exit();
899 }
900
901
902 /* Called with disabled interrupts */
903 static int sx_setup_board(struct specialix_board *bp)
904 {
905 int error;
906
907 if (bp->flags & SX_BOARD_ACTIVE)
908 return 0;
909
910 if (bp->flags & SX_BOARD_IS_PCI)
911 error = request_irq(bp->irq, sx_interrupt,
912 IRQF_DISABLED | IRQF_SHARED, "specialix IO8+", bp);
913 else
914 error = request_irq(bp->irq, sx_interrupt,
915 IRQF_DISABLED, "specialix IO8+", bp);
916
917 if (error)
918 return error;
919
920 turn_ints_on(bp);
921 bp->flags |= SX_BOARD_ACTIVE;
922
923 return 0;
924 }
925
926
927 /* Called with disabled interrupts */
928 static void sx_shutdown_board(struct specialix_board *bp)
929 {
930 func_enter();
931
932 if (!(bp->flags & SX_BOARD_ACTIVE)) {
933 func_exit();
934 return;
935 }
936
937 bp->flags &= ~SX_BOARD_ACTIVE;
938
939 dprintk(SX_DEBUG_IRQ, "Freeing IRQ%d for board %d.\n",
940 bp->irq, board_No(bp));
941 free_irq(bp->irq, bp);
942 turn_ints_off(bp);
943 func_exit();
944 }
945
946 static unsigned int sx_crtscts(struct tty_struct *tty)
947 {
948 if (sx_rtscts)
949 return C_CRTSCTS(tty);
950 return 1;
951 }
952
953 /*
954 * Setting up port characteristics.
955 * Must be called with disabled interrupts
956 */
957 static void sx_change_speed(struct specialix_board *bp,
958 struct specialix_port *port)
959 {
960 struct tty_struct *tty;
961 unsigned long baud;
962 long tmp;
963 unsigned char cor1 = 0, cor3 = 0;
964 unsigned char mcor1 = 0, mcor2 = 0;
965 static unsigned long again;
966 unsigned long flags;
967
968 func_enter();
969
970 tty = port->port.tty;
971 if (!tty || !tty->termios) {
972 func_exit();
973 return;
974 }
975
976 port->IER = 0;
977 port->COR2 = 0;
978 /* Select port on the board */
979 spin_lock_irqsave(&bp->lock, flags);
980 sx_out(bp, CD186x_CAR, port_No(port));
981
982 /* The Specialix board doens't implement the RTS lines.
983 They are used to set the IRQ level. Don't touch them. */
984 if (sx_crtscts(tty))
985 port->MSVR = MSVR_DTR | (sx_in(bp, CD186x_MSVR) & MSVR_RTS);
986 else
987 port->MSVR = (sx_in(bp, CD186x_MSVR) & MSVR_RTS);
988 spin_unlock_irqrestore(&bp->lock, flags);
989 dprintk(SX_DEBUG_TERMIOS, "sx: got MSVR=%02x.\n", port->MSVR);
990 baud = tty_get_baud_rate(tty);
991
992 if (baud == 38400) {
993 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
994 baud = 57600;
995 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
996 baud = 115200;
997 }
998
999 if (!baud) {
1000 /* Drop DTR & exit */
1001 dprintk(SX_DEBUG_TERMIOS, "Dropping DTR... Hmm....\n");
1002 if (!sx_crtscts(tty)) {
1003 port->MSVR &= ~MSVR_DTR;
1004 spin_lock_irqsave(&bp->lock, flags);
1005 sx_out(bp, CD186x_MSVR, port->MSVR);
1006 spin_unlock_irqrestore(&bp->lock, flags);
1007 } else
1008 dprintk(SX_DEBUG_TERMIOS, "Can't drop DTR: no DTR.\n");
1009 return;
1010 } else {
1011 /* Set DTR on */
1012 if (!sx_crtscts(tty))
1013 port->MSVR |= MSVR_DTR;
1014 }
1015
1016 /*
1017 * Now we must calculate some speed depended things
1018 */
1019
1020 /* Set baud rate for port */
1021 tmp = port->custom_divisor ;
1022 if (tmp)
1023 printk(KERN_INFO
1024 "sx%d: Using custom baud rate divisor %ld. \n"
1025 "This is an untested option, please be careful.\n",
1026 port_No(port), tmp);
1027 else
1028 tmp = (((SX_OSCFREQ + baud/2) / baud + CD186x_TPC/2) /
1029 CD186x_TPC);
1030
1031 if (tmp < 0x10 && time_before(again, jiffies)) {
1032 again = jiffies + HZ * 60;
1033 /* Page 48 of version 2.0 of the CL-CD1865 databook */
1034 if (tmp >= 12) {
1035 printk(KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
1036 "Performance degradation is possible.\n"
1037 "Read specialix.txt for more info.\n",
1038 port_No(port), tmp);
1039 } else {
1040 printk(KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
1041 "Warning: overstressing Cirrus chip. This might not work.\n"
1042 "Read specialix.txt for more info.\n", port_No(port), tmp);
1043 }
1044 }
1045 spin_lock_irqsave(&bp->lock, flags);
1046 sx_out(bp, CD186x_RBPRH, (tmp >> 8) & 0xff);
1047 sx_out(bp, CD186x_TBPRH, (tmp >> 8) & 0xff);
1048 sx_out(bp, CD186x_RBPRL, tmp & 0xff);
1049 sx_out(bp, CD186x_TBPRL, tmp & 0xff);
1050 spin_unlock_irqrestore(&bp->lock, flags);
1051 if (port->custom_divisor)
1052 baud = (SX_OSCFREQ + port->custom_divisor/2) /
1053 port->custom_divisor;
1054 baud = (baud + 5) / 10; /* Estimated CPS */
1055
1056 /* Two timer ticks seems enough to wakeup something like SLIP driver */
1057 tmp = ((baud + HZ/2) / HZ) * 2 - CD186x_NFIFO;
1058 port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
1059 SERIAL_XMIT_SIZE - 1 : tmp);
1060
1061 /* Receiver timeout will be transmission time for 1.5 chars */
1062 tmp = (SPECIALIX_TPS + SPECIALIX_TPS/2 + baud/2) / baud;
1063 tmp = (tmp > 0xff) ? 0xff : tmp;
1064 spin_lock_irqsave(&bp->lock, flags);
1065 sx_out(bp, CD186x_RTPR, tmp);
1066 spin_unlock_irqrestore(&bp->lock, flags);
1067 switch (C_CSIZE(tty)) {
1068 case CS5:
1069 cor1 |= COR1_5BITS;
1070 break;
1071 case CS6:
1072 cor1 |= COR1_6BITS;
1073 break;
1074 case CS7:
1075 cor1 |= COR1_7BITS;
1076 break;
1077 case CS8:
1078 cor1 |= COR1_8BITS;
1079 break;
1080 }
1081
1082 if (C_CSTOPB(tty))
1083 cor1 |= COR1_2SB;
1084
1085 cor1 |= COR1_IGNORE;
1086 if (C_PARENB(tty)) {
1087 cor1 |= COR1_NORMPAR;
1088 if (C_PARODD(tty))
1089 cor1 |= COR1_ODDP;
1090 if (I_INPCK(tty))
1091 cor1 &= ~COR1_IGNORE;
1092 }
1093 /* Set marking of some errors */
1094 port->mark_mask = RCSR_OE | RCSR_TOUT;
1095 if (I_INPCK(tty))
1096 port->mark_mask |= RCSR_FE | RCSR_PE;
1097 if (I_BRKINT(tty) || I_PARMRK(tty))
1098 port->mark_mask |= RCSR_BREAK;
1099 if (I_IGNPAR(tty))
1100 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
1101 if (I_IGNBRK(tty)) {
1102 port->mark_mask &= ~RCSR_BREAK;
1103 if (I_IGNPAR(tty))
1104 /* Real raw mode. Ignore all */
1105 port->mark_mask &= ~RCSR_OE;
1106 }
1107 /* Enable Hardware Flow Control */
1108 if (C_CRTSCTS(tty)) {
1109 #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
1110 port->IER |= IER_DSR | IER_CTS;
1111 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
1112 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
1113 spin_lock_irqsave(&bp->lock, flags);
1114 tty->hw_stopped = !(sx_in(bp, CD186x_MSVR) &
1115 (MSVR_CTS|MSVR_DSR));
1116 spin_unlock_irqrestore(&bp->lock, flags);
1117 #else
1118 port->COR2 |= COR2_CTSAE;
1119 #endif
1120 }
1121 /* Enable Software Flow Control. FIXME: I'm not sure about this */
1122 /* Some people reported that it works, but I still doubt it */
1123 if (I_IXON(tty)) {
1124 port->COR2 |= COR2_TXIBE;
1125 cor3 |= (COR3_FCT | COR3_SCDE);
1126 if (I_IXANY(tty))
1127 port->COR2 |= COR2_IXM;
1128 spin_lock_irqsave(&bp->lock, flags);
1129 sx_out(bp, CD186x_SCHR1, START_CHAR(tty));
1130 sx_out(bp, CD186x_SCHR2, STOP_CHAR(tty));
1131 sx_out(bp, CD186x_SCHR3, START_CHAR(tty));
1132 sx_out(bp, CD186x_SCHR4, STOP_CHAR(tty));
1133 spin_unlock_irqrestore(&bp->lock, flags);
1134 }
1135 if (!C_CLOCAL(tty)) {
1136 /* Enable CD check */
1137 port->IER |= IER_CD;
1138 mcor1 |= MCOR1_CDZD;
1139 mcor2 |= MCOR2_CDOD;
1140 }
1141
1142 if (C_CREAD(tty))
1143 /* Enable receiver */
1144 port->IER |= IER_RXD;
1145
1146 /* Set input FIFO size (1-8 bytes) */
1147 cor3 |= sx_rxfifo;
1148 /* Setting up CD186x channel registers */
1149 spin_lock_irqsave(&bp->lock, flags);
1150 sx_out(bp, CD186x_COR1, cor1);
1151 sx_out(bp, CD186x_COR2, port->COR2);
1152 sx_out(bp, CD186x_COR3, cor3);
1153 spin_unlock_irqrestore(&bp->lock, flags);
1154 /* Make CD186x know about registers change */
1155 sx_wait_CCR(bp);
1156 spin_lock_irqsave(&bp->lock, flags);
1157 sx_out(bp, CD186x_CCR, CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3);
1158 /* Setting up modem option registers */
1159 dprintk(SX_DEBUG_TERMIOS, "Mcor1 = %02x, mcor2 = %02x.\n",
1160 mcor1, mcor2);
1161 sx_out(bp, CD186x_MCOR1, mcor1);
1162 sx_out(bp, CD186x_MCOR2, mcor2);
1163 spin_unlock_irqrestore(&bp->lock, flags);
1164 /* Enable CD186x transmitter & receiver */
1165 sx_wait_CCR(bp);
1166 spin_lock_irqsave(&bp->lock, flags);
1167 sx_out(bp, CD186x_CCR, CCR_TXEN | CCR_RXEN);
1168 /* Enable interrupts */
1169 sx_out(bp, CD186x_IER, port->IER);
1170 /* And finally set the modem lines... */
1171 sx_out(bp, CD186x_MSVR, port->MSVR);
1172 spin_unlock_irqrestore(&bp->lock, flags);
1173
1174 func_exit();
1175 }
1176
1177
1178 /* Must be called with interrupts enabled */
1179 static int sx_setup_port(struct specialix_board *bp,
1180 struct specialix_port *port)
1181 {
1182 unsigned long flags;
1183
1184 func_enter();
1185
1186 if (port->port.flags & ASYNC_INITIALIZED) {
1187 func_exit();
1188 return 0;
1189 }
1190
1191 if (!port->xmit_buf) {
1192 /* We may sleep in get_zeroed_page() */
1193 unsigned long tmp;
1194
1195 tmp = get_zeroed_page(GFP_KERNEL);
1196 if (tmp == 0L) {
1197 func_exit();
1198 return -ENOMEM;
1199 }
1200
1201 if (port->xmit_buf) {
1202 free_page(tmp);
1203 func_exit();
1204 return -ERESTARTSYS;
1205 }
1206 port->xmit_buf = (unsigned char *) tmp;
1207 }
1208
1209 spin_lock_irqsave(&port->lock, flags);
1210
1211 if (port->port.tty)
1212 clear_bit(TTY_IO_ERROR, &port->port.tty->flags);
1213
1214 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1215 sx_change_speed(bp, port);
1216 port->port.flags |= ASYNC_INITIALIZED;
1217
1218 spin_unlock_irqrestore(&port->lock, flags);
1219
1220
1221 func_exit();
1222 return 0;
1223 }
1224
1225
1226 /* Must be called with interrupts disabled */
1227 static void sx_shutdown_port(struct specialix_board *bp,
1228 struct specialix_port *port)
1229 {
1230 struct tty_struct *tty;
1231 int i;
1232 unsigned long flags;
1233
1234 func_enter();
1235
1236 if (!(port->port.flags & ASYNC_INITIALIZED)) {
1237 func_exit();
1238 return;
1239 }
1240
1241 if (sx_debug & SX_DEBUG_FIFO) {
1242 dprintk(SX_DEBUG_FIFO,
1243 "sx%d: port %d: %ld overruns, FIFO hits [ ",
1244 board_No(bp), port_No(port), port->overrun);
1245 for (i = 0; i < 10; i++)
1246 dprintk(SX_DEBUG_FIFO, "%ld ", port->hits[i]);
1247 dprintk(SX_DEBUG_FIFO, "].\n");
1248 }
1249
1250 if (port->xmit_buf) {
1251 free_page((unsigned long) port->xmit_buf);
1252 port->xmit_buf = NULL;
1253 }
1254
1255 /* Select port */
1256 spin_lock_irqsave(&bp->lock, flags);
1257 sx_out(bp, CD186x_CAR, port_No(port));
1258
1259 tty = port->port.tty;
1260 if (tty == NULL || C_HUPCL(tty)) {
1261 /* Drop DTR */
1262 sx_out(bp, CD186x_MSVDTR, 0);
1263 }
1264 spin_unlock_irqrestore(&bp->lock, flags);
1265 /* Reset port */
1266 sx_wait_CCR(bp);
1267 spin_lock_irqsave(&bp->lock, flags);
1268 sx_out(bp, CD186x_CCR, CCR_SOFTRESET);
1269 /* Disable all interrupts from this port */
1270 port->IER = 0;
1271 sx_out(bp, CD186x_IER, port->IER);
1272 spin_unlock_irqrestore(&bp->lock, flags);
1273 if (tty)
1274 set_bit(TTY_IO_ERROR, &tty->flags);
1275 port->port.flags &= ~ASYNC_INITIALIZED;
1276
1277 if (!bp->count)
1278 sx_shutdown_board(bp);
1279 func_exit();
1280 }
1281
1282
1283 static int block_til_ready(struct tty_struct *tty, struct file *filp,
1284 struct specialix_port *port)
1285 {
1286 DECLARE_WAITQUEUE(wait, current);
1287 struct specialix_board *bp = port_Board(port);
1288 int retval;
1289 int do_clocal = 0;
1290 int CD;
1291 unsigned long flags;
1292
1293 func_enter();
1294
1295 /*
1296 * If the device is in the middle of being closed, then block
1297 * until it's done, and then try again.
1298 */
1299 if (tty_hung_up_p(filp) || port->port.flags & ASYNC_CLOSING) {
1300 interruptible_sleep_on(&port->port.close_wait);
1301 if (port->port.flags & ASYNC_HUP_NOTIFY) {
1302 func_exit();
1303 return -EAGAIN;
1304 } else {
1305 func_exit();
1306 return -ERESTARTSYS;
1307 }
1308 }
1309
1310 /*
1311 * If non-blocking mode is set, or the port is not enabled,
1312 * then make the check up front and then exit.
1313 */
1314 if ((filp->f_flags & O_NONBLOCK) ||
1315 (tty->flags & (1 << TTY_IO_ERROR))) {
1316 port->port.flags |= ASYNC_NORMAL_ACTIVE;
1317 func_exit();
1318 return 0;
1319 }
1320
1321 if (C_CLOCAL(tty))
1322 do_clocal = 1;
1323
1324 /*
1325 * Block waiting for the carrier detect and the line to become
1326 * free (i.e., not in use by the callout). While we are in
1327 * this loop, info->count is dropped by one, so that
1328 * rs_close() knows when to free things. We restore it upon
1329 * exit, either normal or abnormal.
1330 */
1331 retval = 0;
1332 add_wait_queue(&port->port.open_wait, &wait);
1333 spin_lock_irqsave(&port->lock, flags);
1334 if (!tty_hung_up_p(filp))
1335 port->port.count--;
1336 spin_unlock_irqrestore(&port->lock, flags);
1337 port->port.blocked_open++;
1338 while (1) {
1339 spin_lock_irqsave(&bp->lock, flags);
1340 sx_out(bp, CD186x_CAR, port_No(port));
1341 CD = sx_in(bp, CD186x_MSVR) & MSVR_CD;
1342 if (sx_crtscts(tty)) {
1343 /* Activate RTS */
1344 port->MSVR |= MSVR_DTR; /* WTF? */
1345 sx_out(bp, CD186x_MSVR, port->MSVR);
1346 } else {
1347 /* Activate DTR */
1348 port->MSVR |= MSVR_DTR;
1349 sx_out(bp, CD186x_MSVR, port->MSVR);
1350 }
1351 spin_unlock_irqrestore(&bp->lock, flags);
1352 set_current_state(TASK_INTERRUPTIBLE);
1353 if (tty_hung_up_p(filp) ||
1354 !(port->port.flags & ASYNC_INITIALIZED)) {
1355 if (port->port.flags & ASYNC_HUP_NOTIFY)
1356 retval = -EAGAIN;
1357 else
1358 retval = -ERESTARTSYS;
1359 break;
1360 }
1361 if (!(port->port.flags & ASYNC_CLOSING) &&
1362 (do_clocal || CD))
1363 break;
1364 if (signal_pending(current)) {
1365 retval = -ERESTARTSYS;
1366 break;
1367 }
1368 tty_unlock();
1369 schedule();
1370 tty_lock();
1371 }
1372
1373 set_current_state(TASK_RUNNING);
1374 remove_wait_queue(&port->port.open_wait, &wait);
1375 spin_lock_irqsave(&port->lock, flags);
1376 if (!tty_hung_up_p(filp))
1377 port->port.count++;
1378 port->port.blocked_open--;
1379 spin_unlock_irqrestore(&port->lock, flags);
1380 if (retval) {
1381 func_exit();
1382 return retval;
1383 }
1384
1385 port->port.flags |= ASYNC_NORMAL_ACTIVE;
1386 func_exit();
1387 return 0;
1388 }
1389
1390
1391 static int sx_open(struct tty_struct *tty, struct file *filp)
1392 {
1393 int board;
1394 int error;
1395 struct specialix_port *port;
1396 struct specialix_board *bp;
1397 int i;
1398 unsigned long flags;
1399
1400 func_enter();
1401
1402 board = SX_BOARD(tty->index);
1403
1404 if (board >= SX_NBOARD || !(sx_board[board].flags & SX_BOARD_PRESENT)) {
1405 func_exit();
1406 return -ENODEV;
1407 }
1408
1409 bp = &sx_board[board];
1410 port = sx_port + board * SX_NPORT + SX_PORT(tty->index);
1411 port->overrun = 0;
1412 for (i = 0; i < 10; i++)
1413 port->hits[i] = 0;
1414
1415 dprintk(SX_DEBUG_OPEN,
1416 "Board = %d, bp = %p, port = %p, portno = %d.\n",
1417 board, bp, port, SX_PORT(tty->index));
1418
1419 if (sx_paranoia_check(port, tty->name, "sx_open")) {
1420 func_enter();
1421 return -ENODEV;
1422 }
1423
1424 error = sx_setup_board(bp);
1425 if (error) {
1426 func_exit();
1427 return error;
1428 }
1429
1430 spin_lock_irqsave(&bp->lock, flags);
1431 port->port.count++;
1432 bp->count++;
1433 tty->driver_data = port;
1434 port->port.tty = tty;
1435 spin_unlock_irqrestore(&bp->lock, flags);
1436
1437 error = sx_setup_port(bp, port);
1438 if (error) {
1439 func_enter();
1440 return error;
1441 }
1442
1443 error = block_til_ready(tty, filp, port);
1444 if (error) {
1445 func_enter();
1446 return error;
1447 }
1448
1449 func_exit();
1450 return 0;
1451 }
1452
1453 static void sx_flush_buffer(struct tty_struct *tty)
1454 {
1455 struct specialix_port *port = tty->driver_data;
1456 unsigned long flags;
1457 struct specialix_board *bp;
1458
1459 func_enter();
1460
1461 if (sx_paranoia_check(port, tty->name, "sx_flush_buffer")) {
1462 func_exit();
1463 return;
1464 }
1465
1466 bp = port_Board(port);
1467 spin_lock_irqsave(&port->lock, flags);
1468 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1469 spin_unlock_irqrestore(&port->lock, flags);
1470 tty_wakeup(tty);
1471
1472 func_exit();
1473 }
1474
1475 static void sx_close(struct tty_struct *tty, struct file *filp)
1476 {
1477 struct specialix_port *port = tty->driver_data;
1478 struct specialix_board *bp;
1479 unsigned long flags;
1480 unsigned long timeout;
1481
1482 func_enter();
1483 if (!port || sx_paranoia_check(port, tty->name, "close")) {
1484 func_exit();
1485 return;
1486 }
1487 spin_lock_irqsave(&port->lock, flags);
1488
1489 if (tty_hung_up_p(filp)) {
1490 spin_unlock_irqrestore(&port->lock, flags);
1491 func_exit();
1492 return;
1493 }
1494
1495 bp = port_Board(port);
1496 if (tty->count == 1 && port->port.count != 1) {
1497 printk(KERN_ERR "sx%d: sx_close: bad port count;"
1498 " tty->count is 1, port count is %d\n",
1499 board_No(bp), port->port.count);
1500 port->port.count = 1;
1501 }
1502
1503 if (port->port.count > 1) {
1504 port->port.count--;
1505 bp->count--;
1506
1507 spin_unlock_irqrestore(&port->lock, flags);
1508
1509 func_exit();
1510 return;
1511 }
1512 port->port.flags |= ASYNC_CLOSING;
1513 /*
1514 * Now we wait for the transmit buffer to clear; and we notify
1515 * the line discipline to only process XON/XOFF characters.
1516 */
1517 tty->closing = 1;
1518 spin_unlock_irqrestore(&port->lock, flags);
1519 dprintk(SX_DEBUG_OPEN, "Closing\n");
1520 if (port->port.closing_wait != ASYNC_CLOSING_WAIT_NONE)
1521 tty_wait_until_sent(tty, port->port.closing_wait);
1522 /*
1523 * At this point we stop accepting input. To do this, we
1524 * disable the receive line status interrupts, and tell the
1525 * interrupt driver to stop checking the data ready bit in the
1526 * line status register.
1527 */
1528 dprintk(SX_DEBUG_OPEN, "Closed\n");
1529 port->IER &= ~IER_RXD;
1530 if (port->port.flags & ASYNC_INITIALIZED) {
1531 port->IER &= ~IER_TXRDY;
1532 port->IER |= IER_TXEMPTY;
1533 spin_lock_irqsave(&bp->lock, flags);
1534 sx_out(bp, CD186x_CAR, port_No(port));
1535 sx_out(bp, CD186x_IER, port->IER);
1536 spin_unlock_irqrestore(&bp->lock, flags);
1537 /*
1538 * Before we drop DTR, make sure the UART transmitter
1539 * has completely drained; this is especially
1540 * important if there is a transmit FIFO!
1541 */
1542 timeout = jiffies+HZ;
1543 while (port->IER & IER_TXEMPTY) {
1544 set_current_state(TASK_INTERRUPTIBLE);
1545 msleep_interruptible(jiffies_to_msecs(port->timeout));
1546 if (time_after(jiffies, timeout)) {
1547 printk(KERN_INFO "Timeout waiting for close\n");
1548 break;
1549 }
1550 }
1551
1552 }
1553
1554 if (--bp->count < 0) {
1555 printk(KERN_ERR
1556 "sx%d: sx_shutdown_port: bad board count: %d port: %d\n",
1557 board_No(bp), bp->count, tty->index);
1558 bp->count = 0;
1559 }
1560 if (--port->port.count < 0) {
1561 printk(KERN_ERR
1562 "sx%d: sx_close: bad port count for tty%d: %d\n",
1563 board_No(bp), port_No(port), port->port.count);
1564 port->port.count = 0;
1565 }
1566
1567 sx_shutdown_port(bp, port);
1568 sx_flush_buffer(tty);
1569 tty_ldisc_flush(tty);
1570 spin_lock_irqsave(&port->lock, flags);
1571 tty->closing = 0;
1572 port->port.tty = NULL;
1573 spin_unlock_irqrestore(&port->lock, flags);
1574 if (port->port.blocked_open) {
1575 if (port->port.close_delay)
1576 msleep_interruptible(
1577 jiffies_to_msecs(port->port.close_delay));
1578 wake_up_interruptible(&port->port.open_wait);
1579 }
1580 port->port.flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1581 wake_up_interruptible(&port->port.close_wait);
1582
1583 func_exit();
1584 }
1585
1586
1587 static int sx_write(struct tty_struct *tty,
1588 const unsigned char *buf, int count)
1589 {
1590 struct specialix_port *port = tty->driver_data;
1591 struct specialix_board *bp;
1592 int c, total = 0;
1593 unsigned long flags;
1594
1595 func_enter();
1596 if (sx_paranoia_check(port, tty->name, "sx_write")) {
1597 func_exit();
1598 return 0;
1599 }
1600
1601 bp = port_Board(port);
1602
1603 if (!port->xmit_buf) {
1604 func_exit();
1605 return 0;
1606 }
1607
1608 while (1) {
1609 spin_lock_irqsave(&port->lock, flags);
1610 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1611 SERIAL_XMIT_SIZE - port->xmit_head));
1612 if (c <= 0) {
1613 spin_unlock_irqrestore(&port->lock, flags);
1614 break;
1615 }
1616 memcpy(port->xmit_buf + port->xmit_head, buf, c);
1617 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1618 port->xmit_cnt += c;
1619 spin_unlock_irqrestore(&port->lock, flags);
1620
1621 buf += c;
1622 count -= c;
1623 total += c;
1624 }
1625
1626 spin_lock_irqsave(&bp->lock, flags);
1627 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1628 !(port->IER & IER_TXRDY)) {
1629 port->IER |= IER_TXRDY;
1630 sx_out(bp, CD186x_CAR, port_No(port));
1631 sx_out(bp, CD186x_IER, port->IER);
1632 }
1633 spin_unlock_irqrestore(&bp->lock, flags);
1634 func_exit();
1635
1636 return total;
1637 }
1638
1639
1640 static int sx_put_char(struct tty_struct *tty, unsigned char ch)
1641 {
1642 struct specialix_port *port = tty->driver_data;
1643 unsigned long flags;
1644 struct specialix_board *bp;
1645
1646 func_enter();
1647
1648 if (sx_paranoia_check(port, tty->name, "sx_put_char")) {
1649 func_exit();
1650 return 0;
1651 }
1652 dprintk(SX_DEBUG_TX, "check tty: %p %p\n", tty, port->xmit_buf);
1653 if (!port->xmit_buf) {
1654 func_exit();
1655 return 0;
1656 }
1657 bp = port_Board(port);
1658 spin_lock_irqsave(&port->lock, flags);
1659
1660 dprintk(SX_DEBUG_TX, "xmit_cnt: %d xmit_buf: %p\n",
1661 port->xmit_cnt, port->xmit_buf);
1662 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1 || !port->xmit_buf) {
1663 spin_unlock_irqrestore(&port->lock, flags);
1664 dprintk(SX_DEBUG_TX, "Exit size\n");
1665 func_exit();
1666 return 0;
1667 }
1668 dprintk(SX_DEBUG_TX, "Handle xmit: %p %p\n", port, port->xmit_buf);
1669 port->xmit_buf[port->xmit_head++] = ch;
1670 port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1671 port->xmit_cnt++;
1672 spin_unlock_irqrestore(&port->lock, flags);
1673
1674 func_exit();
1675 return 1;
1676 }
1677
1678
1679 static void sx_flush_chars(struct tty_struct *tty)
1680 {
1681 struct specialix_port *port = tty->driver_data;
1682 unsigned long flags;
1683 struct specialix_board *bp = port_Board(port);
1684
1685 func_enter();
1686
1687 if (sx_paranoia_check(port, tty->name, "sx_flush_chars")) {
1688 func_exit();
1689 return;
1690 }
1691 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1692 !port->xmit_buf) {
1693 func_exit();
1694 return;
1695 }
1696 spin_lock_irqsave(&bp->lock, flags);
1697 port->IER |= IER_TXRDY;
1698 sx_out(port_Board(port), CD186x_CAR, port_No(port));
1699 sx_out(port_Board(port), CD186x_IER, port->IER);
1700 spin_unlock_irqrestore(&bp->lock, flags);
1701
1702 func_exit();
1703 }
1704
1705
1706 static int sx_write_room(struct tty_struct *tty)
1707 {
1708 struct specialix_port *port = tty->driver_data;
1709 int ret;
1710
1711 func_enter();
1712
1713 if (sx_paranoia_check(port, tty->name, "sx_write_room")) {
1714 func_exit();
1715 return 0;
1716 }
1717
1718 ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1719 if (ret < 0)
1720 ret = 0;
1721
1722 func_exit();
1723 return ret;
1724 }
1725
1726
1727 static int sx_chars_in_buffer(struct tty_struct *tty)
1728 {
1729 struct specialix_port *port = tty->driver_data;
1730
1731 func_enter();
1732
1733 if (sx_paranoia_check(port, tty->name, "sx_chars_in_buffer")) {
1734 func_exit();
1735 return 0;
1736 }
1737 func_exit();
1738 return port->xmit_cnt;
1739 }
1740
1741 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1742 {
1743 struct specialix_port *port = tty->driver_data;
1744 struct specialix_board *bp;
1745 unsigned char status;
1746 unsigned int result;
1747 unsigned long flags;
1748
1749 func_enter();
1750
1751 if (sx_paranoia_check(port, tty->name, __func__)) {
1752 func_exit();
1753 return -ENODEV;
1754 }
1755
1756 bp = port_Board(port);
1757 spin_lock_irqsave(&bp->lock, flags);
1758 sx_out(bp, CD186x_CAR, port_No(port));
1759 status = sx_in(bp, CD186x_MSVR);
1760 spin_unlock_irqrestore(&bp->lock, flags);
1761 dprintk(SX_DEBUG_INIT, "Got msvr[%d] = %02x, car = %d.\n",
1762 port_No(port), status, sx_in(bp, CD186x_CAR));
1763 dprintk(SX_DEBUG_INIT, "sx_port = %p, port = %p\n", sx_port, port);
1764 if (sx_crtscts(port->port.tty)) {
1765 result = TIOCM_DTR | TIOCM_DSR
1766 | ((status & MSVR_DTR) ? TIOCM_RTS : 0)
1767 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1768 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1769 } else {
1770 result = TIOCM_RTS | TIOCM_DSR
1771 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1772 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1773 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1774 }
1775
1776 func_exit();
1777
1778 return result;
1779 }
1780
1781
1782 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1783 unsigned int set, unsigned int clear)
1784 {
1785 struct specialix_port *port = tty->driver_data;
1786 unsigned long flags;
1787 struct specialix_board *bp;
1788
1789 func_enter();
1790
1791 if (sx_paranoia_check(port, tty->name, __func__)) {
1792 func_exit();
1793 return -ENODEV;
1794 }
1795
1796 bp = port_Board(port);
1797
1798 spin_lock_irqsave(&port->lock, flags);
1799 if (sx_crtscts(port->port.tty)) {
1800 if (set & TIOCM_RTS)
1801 port->MSVR |= MSVR_DTR;
1802 } else {
1803 if (set & TIOCM_DTR)
1804 port->MSVR |= MSVR_DTR;
1805 }
1806 if (sx_crtscts(port->port.tty)) {
1807 if (clear & TIOCM_RTS)
1808 port->MSVR &= ~MSVR_DTR;
1809 } else {
1810 if (clear & TIOCM_DTR)
1811 port->MSVR &= ~MSVR_DTR;
1812 }
1813 spin_lock(&bp->lock);
1814 sx_out(bp, CD186x_CAR, port_No(port));
1815 sx_out(bp, CD186x_MSVR, port->MSVR);
1816 spin_unlock(&bp->lock);
1817 spin_unlock_irqrestore(&port->lock, flags);
1818 func_exit();
1819 return 0;
1820 }
1821
1822
1823 static int sx_send_break(struct tty_struct *tty, int length)
1824 {
1825 struct specialix_port *port = tty->driver_data;
1826 struct specialix_board *bp = port_Board(port);
1827 unsigned long flags;
1828
1829 func_enter();
1830 if (length == 0 || length == -1)
1831 return -EOPNOTSUPP;
1832
1833 spin_lock_irqsave(&port->lock, flags);
1834 port->break_length = SPECIALIX_TPS / HZ * length;
1835 port->COR2 |= COR2_ETC;
1836 port->IER |= IER_TXRDY;
1837 spin_lock(&bp->lock);
1838 sx_out(bp, CD186x_CAR, port_No(port));
1839 sx_out(bp, CD186x_COR2, port->COR2);
1840 sx_out(bp, CD186x_IER, port->IER);
1841 spin_unlock(&bp->lock);
1842 spin_unlock_irqrestore(&port->lock, flags);
1843 sx_wait_CCR(bp);
1844 spin_lock_irqsave(&bp->lock, flags);
1845 sx_out(bp, CD186x_CCR, CCR_CORCHG2);
1846 spin_unlock_irqrestore(&bp->lock, flags);
1847 sx_wait_CCR(bp);
1848
1849 func_exit();
1850 return 0;
1851 }
1852
1853
1854 static int sx_set_serial_info(struct specialix_port *port,
1855 struct serial_struct __user *newinfo)
1856 {
1857 struct serial_struct tmp;
1858 struct specialix_board *bp = port_Board(port);
1859 int change_speed;
1860
1861 func_enter();
1862
1863 if (copy_from_user(&tmp, newinfo, sizeof(tmp))) {
1864 func_enter();
1865 return -EFAULT;
1866 }
1867
1868 mutex_lock(&port->port.mutex);
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 mutex_unlock(&port->port.mutex);
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 mutex_unlock(&port->port.mutex);
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 mutex_lock(&port->port.mutex);
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 mutex_unlock(&port->port.mutex);
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);
ubuntu-zesty-kernel mirror