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