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