?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] specialix - remove private speed decoding
[linux-2.6/linux-loongson.git] / drivers / char / specialix.c
blobc0ef0f0e5800dcd74a90e38cc483bc2e37ac60f0
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 = tty_get_baud_rate(tty);
1091
1092 if (baud == 38400) {
1093 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1094 baud ++;
1095 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1096 baud += 2;
1097 }
1098
1099 if (!baud) {
1100 /* Drop DTR & exit */
1101 dprintk (SX_DEBUG_TERMIOS, "Dropping DTR... Hmm....\n");
1102 if (!SX_CRTSCTS (tty)) {
1103 port -> MSVR &= ~ MSVR_DTR;
1104 spin_lock_irqsave(&bp->lock, flags);
1105 sx_out(bp, CD186x_MSVR, port->MSVR );
1106 spin_unlock_irqrestore(&bp->lock, flags);
1107 }
1108 else
1109 dprintk (SX_DEBUG_TERMIOS, "Can't drop DTR: no DTR.\n");
1110 return;
1111 } else {
1112 /* Set DTR on */
1113 if (!SX_CRTSCTS (tty)) {
1114 port ->MSVR |= MSVR_DTR;
1115 }
1116 }
1117
1118 /*
1119 * Now we must calculate some speed depended things
1120 */
1121
1122 /* Set baud rate for port */
1123 tmp = port->custom_divisor ;
1124 if ( tmp )
1125 printk (KERN_INFO "sx%d: Using custom baud rate divisor %ld. \n"
1126 "This is an untested option, please be carefull.\n",
1127 port_No (port), tmp);
1128 else
1129 tmp = (((SX_OSCFREQ + baud/2) / baud +
1130 CD186x_TPC/2) / CD186x_TPC);
1131
1132 if ((tmp < 0x10) && time_before(again, jiffies)) {
1133 again = jiffies + HZ * 60;
1134 /* Page 48 of version 2.0 of the CL-CD1865 databook */
1135 if (tmp >= 12) {
1136 printk (KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
1137 "Performance degradation is possible.\n"
1138 "Read specialix.txt for more info.\n",
1139 port_No (port), tmp);
1140 } else {
1141 printk (KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
1142 "Warning: overstressing Cirrus chip. "
1143 "This might not work.\n"
1144 "Read specialix.txt for more info.\n",
1145 port_No (port), tmp);
1146 }
1147 }
1148 spin_lock_irqsave(&bp->lock, flags);
1149 sx_out(bp, CD186x_RBPRH, (tmp >> 8) & 0xff);
1150 sx_out(bp, CD186x_TBPRH, (tmp >> 8) & 0xff);
1151 sx_out(bp, CD186x_RBPRL, tmp & 0xff);
1152 sx_out(bp, CD186x_TBPRL, tmp & 0xff);
1153 spin_unlock_irqrestore(&bp->lock, flags);
1154 if (port->custom_divisor) {
1155 baud = (SX_OSCFREQ + port->custom_divisor/2) / port->custom_divisor;
1156 baud = ( baud + 5 ) / 10;
1157 } else
1158 baud = (baud_table[baud] + 5) / 10; /* Estimated CPS */
1159
1160 /* Two timer ticks seems enough to wakeup something like SLIP driver */
1161 tmp = ((baud + HZ/2) / HZ) * 2 - CD186x_NFIFO;
1162 port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
1163 SERIAL_XMIT_SIZE - 1 : tmp);
1164
1165 /* Receiver timeout will be transmission time for 1.5 chars */
1166 tmp = (SPECIALIX_TPS + SPECIALIX_TPS/2 + baud/2) / baud;
1167 tmp = (tmp > 0xff) ? 0xff : tmp;
1168 spin_lock_irqsave(&bp->lock, flags);
1169 sx_out(bp, CD186x_RTPR, tmp);
1170 spin_unlock_irqrestore(&bp->lock, flags);
1171 switch (C_CSIZE(tty)) {
1172 case CS5:
1173 cor1 |= COR1_5BITS;
1174 break;
1175 case CS6:
1176 cor1 |= COR1_6BITS;
1177 break;
1178 case CS7:
1179 cor1 |= COR1_7BITS;
1180 break;
1181 case CS8:
1182 cor1 |= COR1_8BITS;
1183 break;
1184 }
1185
1186 if (C_CSTOPB(tty))
1187 cor1 |= COR1_2SB;
1188
1189 cor1 |= COR1_IGNORE;
1190 if (C_PARENB(tty)) {
1191 cor1 |= COR1_NORMPAR;
1192 if (C_PARODD(tty))
1193 cor1 |= COR1_ODDP;
1194 if (I_INPCK(tty))
1195 cor1 &= ~COR1_IGNORE;
1196 }
1197 /* Set marking of some errors */
1198 port->mark_mask = RCSR_OE | RCSR_TOUT;
1199 if (I_INPCK(tty))
1200 port->mark_mask |= RCSR_FE | RCSR_PE;
1201 if (I_BRKINT(tty) || I_PARMRK(tty))
1202 port->mark_mask |= RCSR_BREAK;
1203 if (I_IGNPAR(tty))
1204 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
1205 if (I_IGNBRK(tty)) {
1206 port->mark_mask &= ~RCSR_BREAK;
1207 if (I_IGNPAR(tty))
1208 /* Real raw mode. Ignore all */
1209 port->mark_mask &= ~RCSR_OE;
1210 }
1211 /* Enable Hardware Flow Control */
1212 if (C_CRTSCTS(tty)) {
1213 #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
1214 port->IER |= IER_DSR | IER_CTS;
1215 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
1216 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
1217 spin_lock_irqsave(&bp->lock, flags);
1218 tty->hw_stopped = !(sx_in(bp, CD186x_MSVR) & (MSVR_CTS|MSVR_DSR));
1219 spin_unlock_irqrestore(&bp->lock, flags);
1220 #else
1221 port->COR2 |= COR2_CTSAE;
1222 #endif
1223 }
1224 /* Enable Software Flow Control. FIXME: I'm not sure about this */
1225 /* Some people reported that it works, but I still doubt it */
1226 if (I_IXON(tty)) {
1227 port->COR2 |= COR2_TXIBE;
1228 cor3 |= (COR3_FCT | COR3_SCDE);
1229 if (I_IXANY(tty))
1230 port->COR2 |= COR2_IXM;
1231 spin_lock_irqsave(&bp->lock, flags);
1232 sx_out(bp, CD186x_SCHR1, START_CHAR(tty));
1233 sx_out(bp, CD186x_SCHR2, STOP_CHAR(tty));
1234 sx_out(bp, CD186x_SCHR3, START_CHAR(tty));
1235 sx_out(bp, CD186x_SCHR4, STOP_CHAR(tty));
1236 spin_unlock_irqrestore(&bp->lock, flags);
1237 }
1238 if (!C_CLOCAL(tty)) {
1239 /* Enable CD check */
1240 port->IER |= IER_CD;
1241 mcor1 |= MCOR1_CDZD;
1242 mcor2 |= MCOR2_CDOD;
1243 }
1244
1245 if (C_CREAD(tty))
1246 /* Enable receiver */
1247 port->IER |= IER_RXD;
1248
1249 /* Set input FIFO size (1-8 bytes) */
1250 cor3 |= sx_rxfifo;
1251 /* Setting up CD186x channel registers */
1252 spin_lock_irqsave(&bp->lock, flags);
1253 sx_out(bp, CD186x_COR1, cor1);
1254 sx_out(bp, CD186x_COR2, port->COR2);
1255 sx_out(bp, CD186x_COR3, cor3);
1256 spin_unlock_irqrestore(&bp->lock, flags);
1257 /* Make CD186x know about registers change */
1258 sx_wait_CCR(bp);
1259 spin_lock_irqsave(&bp->lock, flags);
1260 sx_out(bp, CD186x_CCR, CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3);
1261 /* Setting up modem option registers */
1262 dprintk (SX_DEBUG_TERMIOS, "Mcor1 = %02x, mcor2 = %02x.\n", mcor1, mcor2);
1263 sx_out(bp, CD186x_MCOR1, mcor1);
1264 sx_out(bp, CD186x_MCOR2, mcor2);
1265 spin_unlock_irqrestore(&bp->lock, flags);
1266 /* Enable CD186x transmitter & receiver */
1267 sx_wait_CCR(bp);
1268 spin_lock_irqsave(&bp->lock, flags);
1269 sx_out(bp, CD186x_CCR, CCR_TXEN | CCR_RXEN);
1270 /* Enable interrupts */
1271 sx_out(bp, CD186x_IER, port->IER);
1272 /* And finally set the modem lines... */
1273 sx_out(bp, CD186x_MSVR, port->MSVR);
1274 spin_unlock_irqrestore(&bp->lock, flags);
1275
1276 func_exit();
1277 }
1278
1279
1280 /* Must be called with interrupts enabled */
1281 static int sx_setup_port(struct specialix_board *bp, struct specialix_port *port)
1282 {
1283 unsigned long flags;
1284
1285 func_enter();
1286
1287 if (port->flags & ASYNC_INITIALIZED) {
1288 func_exit();
1289 return 0;
1290 }
1291
1292 if (!port->xmit_buf) {
1293 /* We may sleep in get_zeroed_page() */
1294 unsigned long tmp;
1295
1296 if (!(tmp = get_zeroed_page(GFP_KERNEL))) {
1297 func_exit();
1298 return -ENOMEM;
1299 }
1300
1301 if (port->xmit_buf) {
1302 free_page(tmp);
1303 func_exit();
1304 return -ERESTARTSYS;
1305 }
1306 port->xmit_buf = (unsigned char *) tmp;
1307 }
1308
1309 spin_lock_irqsave(&port->lock, flags);
1310
1311 if (port->tty)
1312 clear_bit(TTY_IO_ERROR, &port->tty->flags);
1313
1314 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1315 sx_change_speed(bp, port);
1316 port->flags |= ASYNC_INITIALIZED;
1317
1318 spin_unlock_irqrestore(&port->lock, flags);
1319
1320
1321 func_exit();
1322 return 0;
1323 }
1324
1325
1326 /* Must be called with interrupts disabled */
1327 static void sx_shutdown_port(struct specialix_board *bp, struct specialix_port *port)
1328 {
1329 struct tty_struct *tty;
1330 int i;
1331 unsigned long flags;
1332
1333 func_enter();
1334
1335 if (!(port->flags & ASYNC_INITIALIZED)) {
1336 func_exit();
1337 return;
1338 }
1339
1340 if (sx_debug & SX_DEBUG_FIFO) {
1341 dprintk(SX_DEBUG_FIFO, "sx%d: port %d: %ld overruns, FIFO hits [ ",
1342 board_No(bp), port_No(port), port->overrun);
1343 for (i = 0; i < 10; i++) {
1344 dprintk(SX_DEBUG_FIFO, "%ld ", port->hits[i]);
1345 }
1346 dprintk(SX_DEBUG_FIFO, "].\n");
1347 }
1348
1349 if (port->xmit_buf) {
1350 free_page((unsigned long) port->xmit_buf);
1351 port->xmit_buf = NULL;
1352 }
1353
1354 /* Select port */
1355 spin_lock_irqsave(&bp->lock, flags);
1356 sx_out(bp, CD186x_CAR, port_No(port));
1357
1358 if (!(tty = port->tty) || C_HUPCL(tty)) {
1359 /* Drop DTR */
1360 sx_out(bp, CD186x_MSVDTR, 0);
1361 }
1362 spin_unlock_irqrestore(&bp->lock, flags);
1363 /* Reset port */
1364 sx_wait_CCR(bp);
1365 spin_lock_irqsave(&bp->lock, flags);
1366 sx_out(bp, CD186x_CCR, CCR_SOFTRESET);
1367 /* Disable all interrupts from this port */
1368 port->IER = 0;
1369 sx_out(bp, CD186x_IER, port->IER);
1370 spin_unlock_irqrestore(&bp->lock, flags);
1371 if (tty)
1372 set_bit(TTY_IO_ERROR, &tty->flags);
1373 port->flags &= ~ASYNC_INITIALIZED;
1374
1375 if (!bp->count)
1376 sx_shutdown_board(bp);
1377 func_exit();
1378 }
1379
1380
1381 static int block_til_ready(struct tty_struct *tty, struct file * filp,
1382 struct specialix_port *port)
1383 {
1384 DECLARE_WAITQUEUE(wait, current);
1385 struct specialix_board *bp = port_Board(port);
1386 int retval;
1387 int do_clocal = 0;
1388 int CD;
1389 unsigned long flags;
1390
1391 func_enter();
1392
1393 /*
1394 * If the device is in the middle of being closed, then block
1395 * until it's done, and then try again.
1396 */
1397 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
1398 interruptible_sleep_on(&port->close_wait);
1399 if (port->flags & ASYNC_HUP_NOTIFY) {
1400 func_exit();
1401 return -EAGAIN;
1402 } else {
1403 func_exit();
1404 return -ERESTARTSYS;
1405 }
1406 }
1407
1408 /*
1409 * If non-blocking mode is set, or the port is not enabled,
1410 * then make the check up front and then exit.
1411 */
1412 if ((filp->f_flags & O_NONBLOCK) ||
1413 (tty->flags & (1 << TTY_IO_ERROR))) {
1414 port->flags |= ASYNC_NORMAL_ACTIVE;
1415 func_exit();
1416 return 0;
1417 }
1418
1419 if (C_CLOCAL(tty))
1420 do_clocal = 1;
1421
1422 /*
1423 * Block waiting for the carrier detect and the line to become
1424 * free (i.e., not in use by the callout). While we are in
1425 * this loop, info->count is dropped by one, so that
1426 * rs_close() knows when to free things. We restore it upon
1427 * exit, either normal or abnormal.
1428 */
1429 retval = 0;
1430 add_wait_queue(&port->open_wait, &wait);
1431 spin_lock_irqsave(&port->lock, flags);
1432 if (!tty_hung_up_p(filp)) {
1433 port->count--;
1434 }
1435 spin_unlock_irqrestore(&port->lock, flags);
1436 port->blocked_open++;
1437 while (1) {
1438 spin_lock_irqsave(&bp->lock, flags);
1439 sx_out(bp, CD186x_CAR, port_No(port));
1440 CD = sx_in(bp, CD186x_MSVR) & MSVR_CD;
1441 if (SX_CRTSCTS (tty)) {
1442 /* Activate RTS */
1443 port->MSVR |= MSVR_DTR; /* WTF? */
1444 sx_out (bp, CD186x_MSVR, port->MSVR);
1445 } else {
1446 /* Activate DTR */
1447 port->MSVR |= MSVR_DTR;
1448 sx_out (bp, CD186x_MSVR, port->MSVR);
1449 }
1450 spin_unlock_irqrestore(&bp->lock, flags);
1451 set_current_state(TASK_INTERRUPTIBLE);
1452 if (tty_hung_up_p(filp) ||
1453 !(port->flags & ASYNC_INITIALIZED)) {
1454 if (port->flags & ASYNC_HUP_NOTIFY)
1455 retval = -EAGAIN;
1456 else
1457 retval = -ERESTARTSYS;
1458 break;
1459 }
1460 if (!(port->flags & ASYNC_CLOSING) &&
1461 (do_clocal || CD))
1462 break;
1463 if (signal_pending(current)) {
1464 retval = -ERESTARTSYS;
1465 break;
1466 }
1467 schedule();
1468 }
1469
1470 set_current_state(TASK_RUNNING);
1471 remove_wait_queue(&port->open_wait, &wait);
1472 spin_lock_irqsave(&port->lock, flags);
1473 if (!tty_hung_up_p(filp)) {
1474 port->count++;
1475 }
1476 port->blocked_open--;
1477 spin_unlock_irqrestore(&port->lock, flags);
1478 if (retval) {
1479 func_exit();
1480 return retval;
1481 }
1482
1483 port->flags |= ASYNC_NORMAL_ACTIVE;
1484 func_exit();
1485 return 0;
1486 }
1487
1488
1489 static int sx_open(struct tty_struct * tty, struct file * filp)
1490 {
1491 int board;
1492 int error;
1493 struct specialix_port * port;
1494 struct specialix_board * bp;
1495 int i;
1496 unsigned long flags;
1497
1498 func_enter();
1499
1500 board = SX_BOARD(tty->index);
1501
1502 if (board >= SX_NBOARD || !(sx_board[board].flags & SX_BOARD_PRESENT)) {
1503 func_exit();
1504 return -ENODEV;
1505 }
1506
1507 bp = &sx_board[board];
1508 port = sx_port + board * SX_NPORT + SX_PORT(tty->index);
1509 port->overrun = 0;
1510 for (i = 0; i < 10; i++)
1511 port->hits[i]=0;
1512
1513 dprintk (SX_DEBUG_OPEN, "Board = %d, bp = %p, port = %p, portno = %d.\n",
1514 board, bp, port, SX_PORT(tty->index));
1515
1516 if (sx_paranoia_check(port, tty->name, "sx_open")) {
1517 func_enter();
1518 return -ENODEV;
1519 }
1520
1521 if ((error = sx_setup_board(bp))) {
1522 func_exit();
1523 return error;
1524 }
1525
1526 spin_lock_irqsave(&bp->lock, flags);
1527 port->count++;
1528 bp->count++;
1529 tty->driver_data = port;
1530 port->tty = tty;
1531 spin_unlock_irqrestore(&bp->lock, flags);
1532
1533 if ((error = sx_setup_port(bp, port))) {
1534 func_enter();
1535 return error;
1536 }
1537
1538 if ((error = block_til_ready(tty, filp, port))) {
1539 func_enter();
1540 return error;
1541 }
1542
1543 func_exit();
1544 return 0;
1545 }
1546
1547
1548 static void sx_close(struct tty_struct * tty, struct file * filp)
1549 {
1550 struct specialix_port *port = (struct specialix_port *) tty->driver_data;
1551 struct specialix_board *bp;
1552 unsigned long flags;
1553 unsigned long timeout;
1554
1555 func_enter();
1556 if (!port || sx_paranoia_check(port, tty->name, "close")) {
1557 func_exit();
1558 return;
1559 }
1560 spin_lock_irqsave(&port->lock, flags);
1561
1562 if (tty_hung_up_p(filp)) {
1563 spin_unlock_irqrestore(&port->lock, flags);
1564 func_exit();
1565 return;
1566 }
1567
1568 bp = port_Board(port);
1569 if ((tty->count == 1) && (port->count != 1)) {
1570 printk(KERN_ERR "sx%d: sx_close: bad port count;"
1571 " tty->count is 1, port count is %d\n",
1572 board_No(bp), port->count);
1573 port->count = 1;
1574 }
1575
1576 if (port->count > 1) {
1577 port->count--;
1578 bp->count--;
1579
1580 spin_unlock_irqrestore(&port->lock, flags);
1581
1582 func_exit();
1583 return;
1584 }
1585 port->flags |= ASYNC_CLOSING;
1586 /*
1587 * Now we wait for the transmit buffer to clear; and we notify
1588 * the line discipline to only process XON/XOFF characters.
1589 */
1590 tty->closing = 1;
1591 spin_unlock_irqrestore(&port->lock, flags);
1592 dprintk (SX_DEBUG_OPEN, "Closing\n");
1593 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE) {
1594 tty_wait_until_sent(tty, port->closing_wait);
1595 }
1596 /*
1597 * At this point we stop accepting input. To do this, we
1598 * disable the receive line status interrupts, and tell the
1599 * interrupt driver to stop checking the data ready bit in the
1600 * line status register.
1601 */
1602 dprintk (SX_DEBUG_OPEN, "Closed\n");
1603 port->IER &= ~IER_RXD;
1604 if (port->flags & ASYNC_INITIALIZED) {
1605 port->IER &= ~IER_TXRDY;
1606 port->IER |= IER_TXEMPTY;
1607 spin_lock_irqsave(&bp->lock, flags);
1608 sx_out(bp, CD186x_CAR, port_No(port));
1609 sx_out(bp, CD186x_IER, port->IER);
1610 spin_unlock_irqrestore(&bp->lock, flags);
1611 /*
1612 * Before we drop DTR, make sure the UART transmitter
1613 * has completely drained; this is especially
1614 * important if there is a transmit FIFO!
1615 */
1616 timeout = jiffies+HZ;
1617 while(port->IER & IER_TXEMPTY) {
1618 set_current_state (TASK_INTERRUPTIBLE);
1619 msleep_interruptible(jiffies_to_msecs(port->timeout));
1620 if (time_after(jiffies, timeout)) {
1621 printk (KERN_INFO "Timeout waiting for close\n");
1622 break;
1623 }
1624 }
1625
1626 }
1627
1628 if (--bp->count < 0) {
1629 printk(KERN_ERR "sx%d: sx_shutdown_port: bad board count: %d port: %d\n",
1630 board_No(bp), bp->count, tty->index);
1631 bp->count = 0;
1632 }
1633 if (--port->count < 0) {
1634 printk(KERN_ERR "sx%d: sx_close: bad port count for tty%d: %d\n",
1635 board_No(bp), port_No(port), port->count);
1636 port->count = 0;
1637 }
1638
1639 sx_shutdown_port(bp, port);
1640 if (tty->driver->flush_buffer)
1641 tty->driver->flush_buffer(tty);
1642 tty_ldisc_flush(tty);
1643 spin_lock_irqsave(&port->lock, flags);
1644 tty->closing = 0;
1645 port->event = 0;
1646 port->tty = NULL;
1647 spin_unlock_irqrestore(&port->lock, flags);
1648 if (port->blocked_open) {
1649 if (port->close_delay) {
1650 msleep_interruptible(jiffies_to_msecs(port->close_delay));
1651 }
1652 wake_up_interruptible(&port->open_wait);
1653 }
1654 port->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1655 wake_up_interruptible(&port->close_wait);
1656
1657 func_exit();
1658 }
1659
1660
1661 static int sx_write(struct tty_struct * tty,
1662 const unsigned char *buf, int count)
1663 {
1664 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1665 struct specialix_board *bp;
1666 int c, total = 0;
1667 unsigned long flags;
1668
1669 func_enter();
1670 if (sx_paranoia_check(port, tty->name, "sx_write")) {
1671 func_exit();
1672 return 0;
1673 }
1674
1675 bp = port_Board(port);
1676
1677 if (!port->xmit_buf || !tmp_buf) {
1678 func_exit();
1679 return 0;
1680 }
1681
1682 while (1) {
1683 spin_lock_irqsave(&port->lock, flags);
1684 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1685 SERIAL_XMIT_SIZE - port->xmit_head));
1686 if (c <= 0) {
1687 spin_unlock_irqrestore(&port->lock, flags);
1688 break;
1689 }
1690 memcpy(port->xmit_buf + port->xmit_head, buf, c);
1691 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1692 port->xmit_cnt += c;
1693 spin_unlock_irqrestore(&port->lock, flags);
1694
1695 buf += c;
1696 count -= c;
1697 total += c;
1698 }
1699
1700 spin_lock_irqsave(&bp->lock, flags);
1701 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1702 !(port->IER & IER_TXRDY)) {
1703 port->IER |= IER_TXRDY;
1704 sx_out(bp, CD186x_CAR, port_No(port));
1705 sx_out(bp, CD186x_IER, port->IER);
1706 }
1707 spin_unlock_irqrestore(&bp->lock, flags);
1708 func_exit();
1709
1710 return total;
1711 }
1712
1713
1714 static void sx_put_char(struct tty_struct * tty, unsigned char ch)
1715 {
1716 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1717 unsigned long flags;
1718 struct specialix_board * bp;
1719
1720 func_enter();
1721
1722 if (sx_paranoia_check(port, tty->name, "sx_put_char")) {
1723 func_exit();
1724 return;
1725 }
1726 dprintk (SX_DEBUG_TX, "check tty: %p %p\n", tty, port->xmit_buf);
1727 if (!port->xmit_buf) {
1728 func_exit();
1729 return;
1730 }
1731 bp = port_Board(port);
1732 spin_lock_irqsave(&port->lock, flags);
1733
1734 dprintk (SX_DEBUG_TX, "xmit_cnt: %d xmit_buf: %p\n", port->xmit_cnt, port->xmit_buf);
1735 if ((port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) || (!port->xmit_buf)) {
1736 spin_unlock_irqrestore(&port->lock, flags);
1737 dprintk (SX_DEBUG_TX, "Exit size\n");
1738 func_exit();
1739 return;
1740 }
1741 dprintk (SX_DEBUG_TX, "Handle xmit: %p %p\n", port, port->xmit_buf);
1742 port->xmit_buf[port->xmit_head++] = ch;
1743 port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1744 port->xmit_cnt++;
1745 spin_unlock_irqrestore(&port->lock, flags);
1746
1747 func_exit();
1748 }
1749
1750
1751 static void sx_flush_chars(struct tty_struct * tty)
1752 {
1753 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1754 unsigned long flags;
1755 struct specialix_board * bp = port_Board(port);
1756
1757 func_enter();
1758
1759 if (sx_paranoia_check(port, tty->name, "sx_flush_chars")) {
1760 func_exit();
1761 return;
1762 }
1763 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1764 !port->xmit_buf) {
1765 func_exit();
1766 return;
1767 }
1768 spin_lock_irqsave(&bp->lock, flags);
1769 port->IER |= IER_TXRDY;
1770 sx_out(port_Board(port), CD186x_CAR, port_No(port));
1771 sx_out(port_Board(port), CD186x_IER, port->IER);
1772 spin_unlock_irqrestore(&bp->lock, flags);
1773
1774 func_exit();
1775 }
1776
1777
1778 static int sx_write_room(struct tty_struct * tty)
1779 {
1780 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1781 int ret;
1782
1783 func_enter();
1784
1785 if (sx_paranoia_check(port, tty->name, "sx_write_room")) {
1786 func_exit();
1787 return 0;
1788 }
1789
1790 ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1791 if (ret < 0)
1792 ret = 0;
1793
1794 func_exit();
1795 return ret;
1796 }
1797
1798
1799 static int sx_chars_in_buffer(struct tty_struct *tty)
1800 {
1801 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1802
1803 func_enter();
1804
1805 if (sx_paranoia_check(port, tty->name, "sx_chars_in_buffer")) {
1806 func_exit();
1807 return 0;
1808 }
1809 func_exit();
1810 return port->xmit_cnt;
1811 }
1812
1813
1814 static void sx_flush_buffer(struct tty_struct *tty)
1815 {
1816 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1817 unsigned long flags;
1818 struct specialix_board * bp;
1819
1820 func_enter();
1821
1822 if (sx_paranoia_check(port, tty->name, "sx_flush_buffer")) {
1823 func_exit();
1824 return;
1825 }
1826
1827 bp = port_Board(port);
1828 spin_lock_irqsave(&port->lock, flags);
1829 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1830 spin_unlock_irqrestore(&port->lock, flags);
1831 tty_wakeup(tty);
1832
1833 func_exit();
1834 }
1835
1836
1837 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1838 {
1839 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1840 struct specialix_board * bp;
1841 unsigned char status;
1842 unsigned int result;
1843 unsigned long flags;
1844
1845 func_enter();
1846
1847 if (sx_paranoia_check(port, tty->name, __FUNCTION__)) {
1848 func_exit();
1849 return -ENODEV;
1850 }
1851
1852 bp = port_Board(port);
1853 spin_lock_irqsave (&bp->lock, flags);
1854 sx_out(bp, CD186x_CAR, port_No(port));
1855 status = sx_in(bp, CD186x_MSVR);
1856 spin_unlock_irqrestore(&bp->lock, flags);
1857 dprintk (SX_DEBUG_INIT, "Got msvr[%d] = %02x, car = %d.\n",
1858 port_No(port), status, sx_in (bp, CD186x_CAR));
1859 dprintk (SX_DEBUG_INIT, "sx_port = %p, port = %p\n", sx_port, port);
1860 if (SX_CRTSCTS(port->tty)) {
1861 result = /* (status & MSVR_RTS) ? */ TIOCM_DTR /* : 0) */
1862 | ((status & MSVR_DTR) ? TIOCM_RTS : 0)
1863 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1864 |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
1865 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1866 } else {
1867 result = /* (status & MSVR_RTS) ? */ TIOCM_RTS /* : 0) */
1868 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1869 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1870 |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
1871 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1872 }
1873
1874 func_exit();
1875
1876 return result;
1877 }
1878
1879
1880 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1881 unsigned int set, unsigned int clear)
1882 {
1883 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1884 unsigned long flags;
1885 struct specialix_board *bp;
1886
1887 func_enter();
1888
1889 if (sx_paranoia_check(port, tty->name, __FUNCTION__)) {
1890 func_exit();
1891 return -ENODEV;
1892 }
1893
1894 bp = port_Board(port);
1895
1896 spin_lock_irqsave(&port->lock, flags);
1897 /* if (set & TIOCM_RTS)
1898 port->MSVR |= MSVR_RTS; */
1899 /* if (set & TIOCM_DTR)
1900 port->MSVR |= MSVR_DTR; */
1901
1902 if (SX_CRTSCTS(port->tty)) {
1903 if (set & TIOCM_RTS)
1904 port->MSVR |= MSVR_DTR;
1905 } else {
1906 if (set & TIOCM_DTR)
1907 port->MSVR |= MSVR_DTR;
1908 }
1909
1910 /* if (clear & TIOCM_RTS)
1911 port->MSVR &= ~MSVR_RTS; */
1912 /* if (clear & TIOCM_DTR)
1913 port->MSVR &= ~MSVR_DTR; */
1914 if (SX_CRTSCTS(port->tty)) {
1915 if (clear & TIOCM_RTS)
1916 port->MSVR &= ~MSVR_DTR;
1917 } else {
1918 if (clear & TIOCM_DTR)
1919 port->MSVR &= ~MSVR_DTR;
1920 }
1921 spin_lock_irqsave(&bp->lock, flags);
1922 sx_out(bp, CD186x_CAR, port_No(port));
1923 sx_out(bp, CD186x_MSVR, port->MSVR);
1924 spin_unlock_irqrestore(&bp->lock, flags);
1925 spin_unlock_irqrestore(&port->lock, flags);
1926 func_exit();
1927 return 0;
1928 }
1929
1930
1931 static inline void sx_send_break(struct specialix_port * port, unsigned long length)
1932 {
1933 struct specialix_board *bp = port_Board(port);
1934 unsigned long flags;
1935
1936 func_enter();
1937
1938 spin_lock_irqsave (&port->lock, flags);
1939 port->break_length = SPECIALIX_TPS / HZ * length;
1940 port->COR2 |= COR2_ETC;
1941 port->IER |= IER_TXRDY;
1942 spin_lock_irqsave(&bp->lock, flags);
1943 sx_out(bp, CD186x_CAR, port_No(port));
1944 sx_out(bp, CD186x_COR2, port->COR2);
1945 sx_out(bp, CD186x_IER, port->IER);
1946 spin_unlock_irqrestore(&bp->lock, flags);
1947 spin_unlock_irqrestore (&port->lock, flags);
1948 sx_wait_CCR(bp);
1949 spin_lock_irqsave(&bp->lock, flags);
1950 sx_out(bp, CD186x_CCR, CCR_CORCHG2);
1951 spin_unlock_irqrestore(&bp->lock, flags);
1952 sx_wait_CCR(bp);
1953
1954 func_exit();
1955 }
1956
1957
1958 static inline int sx_set_serial_info(struct specialix_port * port,
1959 struct serial_struct __user * newinfo)
1960 {
1961 struct serial_struct tmp;
1962 struct specialix_board *bp = port_Board(port);
1963 int change_speed;
1964
1965 func_enter();
1966 /*
1967 if (!access_ok(VERIFY_READ, (void *) newinfo, sizeof(tmp))) {
1968 func_exit();
1969 return -EFAULT;
1970 }
1971 */
1972 if (copy_from_user(&tmp, newinfo, sizeof(tmp))) {
1973 func_enter();
1974 return -EFAULT;
1975 }
1976
1977 #if 0
1978 if ((tmp.irq != bp->irq) ||
1979 (tmp.port != bp->base) ||
1980 (tmp.type != PORT_CIRRUS) ||
1981 (tmp.baud_base != (SX_OSCFREQ + CD186x_TPC/2) / CD186x_TPC) ||
1982 (tmp.custom_divisor != 0) ||
1983 (tmp.xmit_fifo_size != CD186x_NFIFO) ||
1984 (tmp.flags & ~SPECIALIX_LEGAL_FLAGS)) {
1985 func_exit();
1986 return -EINVAL;
1987 }
1988 #endif
1989
1990 change_speed = ((port->flags & ASYNC_SPD_MASK) !=
1991 (tmp.flags & ASYNC_SPD_MASK));
1992 change_speed |= (tmp.custom_divisor != port->custom_divisor);
1993
1994 if (!capable(CAP_SYS_ADMIN)) {
1995 if ((tmp.close_delay != port->close_delay) ||
1996 (tmp.closing_wait != port->closing_wait) ||
1997 ((tmp.flags & ~ASYNC_USR_MASK) !=
1998 (port->flags & ~ASYNC_USR_MASK))) {
1999 func_exit();
2000 return -EPERM;
2001 }
2002 port->flags = ((port->flags & ~ASYNC_USR_MASK) |
2003 (tmp.flags & ASYNC_USR_MASK));
2004 port->custom_divisor = tmp.custom_divisor;
2005 } else {
2006 port->flags = ((port->flags & ~ASYNC_FLAGS) |
2007 (tmp.flags & ASYNC_FLAGS));
2008 port->close_delay = tmp.close_delay;
2009 port->closing_wait = tmp.closing_wait;
2010 port->custom_divisor = tmp.custom_divisor;
2011 }
2012 if (change_speed) {
2013 sx_change_speed(bp, port);
2014 }
2015 func_exit();
2016 return 0;
2017 }
2018
2019
2020 static inline int sx_get_serial_info(struct specialix_port * port,
2021 struct serial_struct __user *retinfo)
2022 {
2023 struct serial_struct tmp;
2024 struct specialix_board *bp = port_Board(port);
2025
2026 func_enter();
2027
2028 /*
2029 if (!access_ok(VERIFY_WRITE, (void *) retinfo, sizeof(tmp)))
2030 return -EFAULT;
2031 */
2032
2033 memset(&tmp, 0, sizeof(tmp));
2034 tmp.type = PORT_CIRRUS;
2035 tmp.line = port - sx_port;
2036 tmp.port = bp->base;
2037 tmp.irq = bp->irq;
2038 tmp.flags = port->flags;
2039 tmp.baud_base = (SX_OSCFREQ + CD186x_TPC/2) / CD186x_TPC;
2040 tmp.close_delay = port->close_delay * HZ/100;
2041 tmp.closing_wait = port->closing_wait * HZ/100;
2042 tmp.custom_divisor = port->custom_divisor;
2043 tmp.xmit_fifo_size = CD186x_NFIFO;
2044 if (copy_to_user(retinfo, &tmp, sizeof(tmp))) {
2045 func_exit();
2046 return -EFAULT;
2047 }
2048
2049 func_exit();
2050 return 0;
2051 }
2052
2053
2054 static int sx_ioctl(struct tty_struct * tty, struct file * filp,
2055 unsigned int cmd, unsigned long arg)
2056 {
2057 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2058 int retval;
2059 void __user *argp = (void __user *)arg;
2060
2061 func_enter();
2062
2063 if (sx_paranoia_check(port, tty->name, "sx_ioctl")) {
2064 func_exit();
2065 return -ENODEV;
2066 }
2067
2068 switch (cmd) {
2069 case TCSBRK: /* SVID version: non-zero arg --> no break */
2070 retval = tty_check_change(tty);
2071 if (retval) {
2072 func_exit();
2073 return retval;
2074 }
2075 tty_wait_until_sent(tty, 0);
2076 if (!arg)
2077 sx_send_break(port, HZ/4); /* 1/4 second */
2078 return 0;
2079 case TCSBRKP: /* support for POSIX tcsendbreak() */
2080 retval = tty_check_change(tty);
2081 if (retval) {
2082 func_exit();
2083 return retval;
2084 }
2085 tty_wait_until_sent(tty, 0);
2086 sx_send_break(port, arg ? arg*(HZ/10) : HZ/4);
2087 func_exit();
2088 return 0;
2089 case TIOCGSOFTCAR:
2090 if (put_user(C_CLOCAL(tty)?1:0, (unsigned long __user *)argp)) {
2091 func_exit();
2092 return -EFAULT;
2093 }
2094 func_exit();
2095 return 0;
2096 case TIOCSSOFTCAR:
2097 if (get_user(arg, (unsigned long __user *) argp)) {
2098 func_exit();
2099 return -EFAULT;
2100 }
2101 tty->termios->c_cflag =
2102 ((tty->termios->c_cflag & ~CLOCAL) |
2103 (arg ? CLOCAL : 0));
2104 func_exit();
2105 return 0;
2106 case TIOCGSERIAL:
2107 func_exit();
2108 return sx_get_serial_info(port, argp);
2109 case TIOCSSERIAL:
2110 func_exit();
2111 return sx_set_serial_info(port, argp);
2112 default:
2113 func_exit();
2114 return -ENOIOCTLCMD;
2115 }
2116 func_exit();
2117 return 0;
2118 }
2119
2120
2121 static void sx_throttle(struct tty_struct * tty)
2122 {
2123 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2124 struct specialix_board *bp;
2125 unsigned long flags;
2126
2127 func_enter();
2128
2129 if (sx_paranoia_check(port, tty->name, "sx_throttle")) {
2130 func_exit();
2131 return;
2132 }
2133
2134 bp = port_Board(port);
2135
2136 /* Use DTR instead of RTS ! */
2137 if (SX_CRTSCTS (tty))
2138 port->MSVR &= ~MSVR_DTR;
2139 else {
2140 /* Auch!!! I think the system shouldn't call this then. */
2141 /* Or maybe we're supposed (allowed?) to do our side of hw
2142 handshake anyway, even when hardware handshake is off.
2143 When you see this in your logs, please report.... */
2144 printk (KERN_ERR "sx%d: Need to throttle, but can't (hardware hs is off)\n",
2145 port_No (port));
2146 }
2147 spin_lock_irqsave(&bp->lock, flags);
2148 sx_out(bp, CD186x_CAR, port_No(port));
2149 spin_unlock_irqrestore(&bp->lock, flags);
2150 if (I_IXOFF(tty)) {
2151 spin_unlock_irqrestore(&bp->lock, flags);
2152 sx_wait_CCR(bp);
2153 spin_lock_irqsave(&bp->lock, flags);
2154 sx_out(bp, CD186x_CCR, CCR_SSCH2);
2155 spin_unlock_irqrestore(&bp->lock, flags);
2156 sx_wait_CCR(bp);
2157 }
2158 spin_lock_irqsave(&bp->lock, flags);
2159 sx_out(bp, CD186x_MSVR, port->MSVR);
2160 spin_unlock_irqrestore(&bp->lock, flags);
2161
2162 func_exit();
2163 }
2164
2165
2166 static void sx_unthrottle(struct tty_struct * tty)
2167 {
2168 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2169 struct specialix_board *bp;
2170 unsigned long flags;
2171
2172 func_enter();
2173
2174 if (sx_paranoia_check(port, tty->name, "sx_unthrottle")) {
2175 func_exit();
2176 return;
2177 }
2178
2179 bp = port_Board(port);
2180
2181 spin_lock_irqsave(&port->lock, flags);
2182 /* XXXX Use DTR INSTEAD???? */
2183 if (SX_CRTSCTS(tty)) {
2184 port->MSVR |= MSVR_DTR;
2185 } /* Else clause: see remark in "sx_throttle"... */
2186 spin_lock_irqsave(&bp->lock, flags);
2187 sx_out(bp, CD186x_CAR, port_No(port));
2188 spin_unlock_irqrestore(&bp->lock, flags);
2189 if (I_IXOFF(tty)) {
2190 spin_unlock_irqrestore(&port->lock, flags);
2191 sx_wait_CCR(bp);
2192 spin_lock_irqsave(&bp->lock, flags);
2193 sx_out(bp, CD186x_CCR, CCR_SSCH1);
2194 spin_unlock_irqrestore(&bp->lock, flags);
2195 sx_wait_CCR(bp);
2196 spin_lock_irqsave(&port->lock, flags);
2197 }
2198 spin_lock_irqsave(&bp->lock, flags);
2199 sx_out(bp, CD186x_MSVR, port->MSVR);
2200 spin_unlock_irqrestore(&bp->lock, flags);
2201 spin_unlock_irqrestore(&port->lock, flags);
2202
2203 func_exit();
2204 }
2205
2206
2207 static void sx_stop(struct tty_struct * tty)
2208 {
2209 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2210 struct specialix_board *bp;
2211 unsigned long flags;
2212
2213 func_enter();
2214
2215 if (sx_paranoia_check(port, tty->name, "sx_stop")) {
2216 func_exit();
2217 return;
2218 }
2219
2220 bp = port_Board(port);
2221
2222 spin_lock_irqsave(&port->lock, flags);
2223 port->IER &= ~IER_TXRDY;
2224 spin_lock_irqsave(&bp->lock, flags);
2225 sx_out(bp, CD186x_CAR, port_No(port));
2226 sx_out(bp, CD186x_IER, port->IER);
2227 spin_unlock_irqrestore(&bp->lock, flags);
2228 spin_unlock_irqrestore(&port->lock, flags);
2229
2230 func_exit();
2231 }
2232
2233
2234 static void sx_start(struct tty_struct * tty)
2235 {
2236 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2237 struct specialix_board *bp;
2238 unsigned long flags;
2239
2240 func_enter();
2241
2242 if (sx_paranoia_check(port, tty->name, "sx_start")) {
2243 func_exit();
2244 return;
2245 }
2246
2247 bp = port_Board(port);
2248
2249 spin_lock_irqsave(&port->lock, flags);
2250 if (port->xmit_cnt && port->xmit_buf && !(port->IER & IER_TXRDY)) {
2251 port->IER |= IER_TXRDY;
2252 spin_lock_irqsave(&bp->lock, flags);
2253 sx_out(bp, CD186x_CAR, port_No(port));
2254 sx_out(bp, CD186x_IER, port->IER);
2255 spin_unlock_irqrestore(&bp->lock, flags);
2256 }
2257 spin_unlock_irqrestore(&port->lock, flags);
2258
2259 func_exit();
2260 }
2261
2262
2263 /*
2264 * This routine is called from the work-queue when the interrupt
2265 * routine has signalled that a hangup has occurred. The path of
2266 * hangup processing is:
2267 *
2268 * serial interrupt routine -> (workqueue) ->
2269 * do_sx_hangup() -> tty->hangup() -> sx_hangup()
2270 *
2271 */
2272 static void do_sx_hangup(void *private_)
2273 {
2274 struct specialix_port *port = (struct specialix_port *) private_;
2275 struct tty_struct *tty;
2276
2277 func_enter();
2278
2279 tty = port->tty;
2280 if (tty)
2281 tty_hangup(tty); /* FIXME: module removal race here */
2282
2283 func_exit();
2284 }
2285
2286
2287 static void sx_hangup(struct tty_struct * tty)
2288 {
2289 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2290 struct specialix_board *bp;
2291 unsigned long flags;
2292
2293 func_enter();
2294
2295 if (sx_paranoia_check(port, tty->name, "sx_hangup")) {
2296 func_exit();
2297 return;
2298 }
2299
2300 bp = port_Board(port);
2301
2302 sx_shutdown_port(bp, port);
2303 spin_lock_irqsave(&port->lock, flags);
2304 port->event = 0;
2305 bp->count -= port->count;
2306 if (bp->count < 0) {
2307 printk(KERN_ERR "sx%d: sx_hangup: bad board count: %d port: %d\n",
2308 board_No(bp), bp->count, tty->index);
2309 bp->count = 0;
2310 }
2311 port->count = 0;
2312 port->flags &= ~ASYNC_NORMAL_ACTIVE;
2313 port->tty = NULL;
2314 spin_unlock_irqrestore(&port->lock, flags);
2315 wake_up_interruptible(&port->open_wait);
2316
2317 func_exit();
2318 }
2319
2320
2321 static void sx_set_termios(struct tty_struct * tty, struct termios * old_termios)
2322 {
2323 struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2324 unsigned long flags;
2325 struct specialix_board * bp;
2326
2327 if (sx_paranoia_check(port, tty->name, "sx_set_termios"))
2328 return;
2329
2330 if (tty->termios->c_cflag == old_termios->c_cflag &&
2331 tty->termios->c_iflag == old_termios->c_iflag)
2332 return;
2333
2334 bp = port_Board(port);
2335 spin_lock_irqsave(&port->lock, flags);
2336 sx_change_speed(port_Board(port), port);
2337 spin_unlock_irqrestore(&port->lock, flags);
2338
2339 if ((old_termios->c_cflag & CRTSCTS) &&
2340 !(tty->termios->c_cflag & CRTSCTS)) {
2341 tty->hw_stopped = 0;
2342 sx_start(tty);
2343 }
2344 }
2345
2346
2347 static void do_softint(void *private_)
2348 {
2349 struct specialix_port *port = (struct specialix_port *) private_;
2350 struct tty_struct *tty;
2351
2352 func_enter();
2353
2354 if(!(tty = port->tty)) {
2355 func_exit();
2356 return;
2357 }
2358
2359 if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &port->event)) {
2360 tty_wakeup(tty);
2361 //wake_up_interruptible(&tty->write_wait);
2362 }
2363
2364 func_exit();
2365 }
2366
2367 static struct tty_operations sx_ops = {
2368 .open = sx_open,
2369 .close = sx_close,
2370 .write = sx_write,
2371 .put_char = sx_put_char,
2372 .flush_chars = sx_flush_chars,
2373 .write_room = sx_write_room,
2374 .chars_in_buffer = sx_chars_in_buffer,
2375 .flush_buffer = sx_flush_buffer,
2376 .ioctl = sx_ioctl,
2377 .throttle = sx_throttle,
2378 .unthrottle = sx_unthrottle,
2379 .set_termios = sx_set_termios,
2380 .stop = sx_stop,
2381 .start = sx_start,
2382 .hangup = sx_hangup,
2383 .tiocmget = sx_tiocmget,
2384 .tiocmset = sx_tiocmset,
2385 };
2386
2387 static int sx_init_drivers(void)
2388 {
2389 int error;
2390 int i;
2391
2392 func_enter();
2393
2394 specialix_driver = alloc_tty_driver(SX_NBOARD * SX_NPORT);
2395 if (!specialix_driver) {
2396 printk(KERN_ERR "sx: Couldn't allocate tty_driver.\n");
2397 func_exit();
2398 return 1;
2399 }
2400
2401 if (!(tmp_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL))) {
2402 printk(KERN_ERR "sx: Couldn't get free page.\n");
2403 put_tty_driver(specialix_driver);
2404 func_exit();
2405 return 1;
2406 }
2407 specialix_driver->owner = THIS_MODULE;
2408 specialix_driver->name = "ttyW";
2409 specialix_driver->major = SPECIALIX_NORMAL_MAJOR;
2410 specialix_driver->type = TTY_DRIVER_TYPE_SERIAL;
2411 specialix_driver->subtype = SERIAL_TYPE_NORMAL;
2412 specialix_driver->init_termios = tty_std_termios;
2413 specialix_driver->init_termios.c_cflag =
2414 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2415 specialix_driver->flags = TTY_DRIVER_REAL_RAW;
2416 tty_set_operations(specialix_driver, &sx_ops);
2417
2418 if ((error = tty_register_driver(specialix_driver))) {
2419 put_tty_driver(specialix_driver);
2420 free_page((unsigned long)tmp_buf);
2421 printk(KERN_ERR "sx: Couldn't register specialix IO8+ driver, error = %d\n",
2422 error);
2423 func_exit();
2424 return 1;
2425 }
2426 memset(sx_port, 0, sizeof(sx_port));
2427 for (i = 0; i < SX_NPORT * SX_NBOARD; i++) {
2428 sx_port[i].magic = SPECIALIX_MAGIC;
2429 INIT_WORK(&sx_port[i].tqueue, do_softint, &sx_port[i]);
2430 INIT_WORK(&sx_port[i].tqueue_hangup, do_sx_hangup, &sx_port[i]);
2431 sx_port[i].close_delay = 50 * HZ/100;
2432 sx_port[i].closing_wait = 3000 * HZ/100;
2433 init_waitqueue_head(&sx_port[i].open_wait);
2434 init_waitqueue_head(&sx_port[i].close_wait);
2435 spin_lock_init(&sx_port[i].lock);
2436 }
2437
2438 func_exit();
2439 return 0;
2440 }
2441
2442 static void sx_release_drivers(void)
2443 {
2444 func_enter();
2445
2446 free_page((unsigned long)tmp_buf);
2447 tty_unregister_driver(specialix_driver);
2448 put_tty_driver(specialix_driver);
2449 func_exit();
2450 }
2451
2452 /*
2453 * This routine must be called by kernel at boot time
2454 */
2455 static int __init specialix_init(void)
2456 {
2457 int i;
2458 int found = 0;
2459
2460 func_enter();
2461
2462 printk(KERN_INFO "sx: Specialix IO8+ driver v" VERSION ", (c) R.E.Wolff 1997/1998.\n");
2463 printk(KERN_INFO "sx: derived from work (c) D.Gorodchanin 1994-1996.\n");
2464 #ifdef CONFIG_SPECIALIX_RTSCTS
2465 printk (KERN_INFO "sx: DTR/RTS pin is always RTS.\n");
2466 #else
2467 printk (KERN_INFO "sx: DTR/RTS pin is RTS when CRTSCTS is on.\n");
2468 #endif
2469
2470 for (i = 0; i < SX_NBOARD; i++)
2471 spin_lock_init(&sx_board[i].lock);
2472
2473 if (sx_init_drivers()) {
2474 func_exit();
2475 return -EIO;
2476 }
2477
2478 for (i = 0; i < SX_NBOARD; i++)
2479 if (sx_board[i].base && !sx_probe(&sx_board[i]))
2480 found++;
2481
2482 #ifdef CONFIG_PCI
2483 {
2484 struct pci_dev *pdev = NULL;
2485
2486 i=0;
2487 while (i < SX_NBOARD) {
2488 if (sx_board[i].flags & SX_BOARD_PRESENT) {
2489 i++;
2490 continue;
2491 }
2492 pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX,
2493 PCI_DEVICE_ID_SPECIALIX_IO8,
2494 pdev);
2495 if (!pdev) break;
2496
2497 if (pci_enable_device(pdev))
2498 continue;
2499
2500 sx_board[i].irq = pdev->irq;
2501
2502 sx_board[i].base = pci_resource_start (pdev, 2);
2503
2504 sx_board[i].flags |= SX_BOARD_IS_PCI;
2505 if (!sx_probe(&sx_board[i]))
2506 found ++;
2507 }
2508 }
2509 #endif
2510
2511 if (!found) {
2512 sx_release_drivers();
2513 printk(KERN_INFO "sx: No specialix IO8+ boards detected.\n");
2514 func_exit();
2515 return -EIO;
2516 }
2517
2518 func_exit();
2519 return 0;
2520 }
2521
2522 static int iobase[SX_NBOARD] = {0,};
2523
2524 static int irq [SX_NBOARD] = {0,};
2525
2526 module_param_array(iobase, int, NULL, 0);
2527 module_param_array(irq, int, NULL, 0);
2528 module_param(sx_debug, int, 0);
2529 module_param(sx_rxfifo, int, 0);
2530 #ifdef SPECIALIX_TIMER
2531 module_param(sx_poll, int, 0);
2532 #endif
2533
2534 /*
2535 * You can setup up to 4 boards.
2536 * by specifying "iobase=0xXXX,0xXXX ..." as insmod parameter.
2537 * You should specify the IRQs too in that case "irq=....,...".
2538 *
2539 * More than 4 boards in one computer is not possible, as the card can
2540 * only use 4 different interrupts.
2541 *
2542 */
2543 static int __init specialix_init_module(void)
2544 {
2545 int i;
2546
2547 func_enter();
2548
2549 if (iobase[0] || iobase[1] || iobase[2] || iobase[3]) {
2550 for(i = 0; i < SX_NBOARD; i++) {
2551 sx_board[i].base = iobase[i];
2552 sx_board[i].irq = irq[i];
2553 sx_board[i].count= 0;
2554 }
2555 }
2556
2557 func_exit();
2558
2559 return specialix_init();
2560 }
2561
2562 static void __exit specialix_exit_module(void)
2563 {
2564 int i;
2565
2566 func_enter();
2567
2568 sx_release_drivers();
2569 for (i = 0; i < SX_NBOARD; i++)
2570 if (sx_board[i].flags & SX_BOARD_PRESENT)
2571 sx_release_io_range(&sx_board[i]);
2572 #ifdef SPECIALIX_TIMER
2573 del_timer (&missed_irq_timer);
2574 #endif
2575
2576 func_exit();
2577 }
2578
2579 static struct pci_device_id specialx_pci_tbl[] __devinitdata = {
2580 { PCI_DEVICE(PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_IO8) },
2581 { }
2582 };
2583 MODULE_DEVICE_TABLE(pci, specialx_pci_tbl);
2584
2585 module_init(specialix_init_module);
2586 module_exit(specialix_exit_module);
2587
2588 MODULE_LICENSE("GPL");
linux kernel for loongson