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