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