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