Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial
[linux-3.10.git] / drivers / char / stallion.c
1 /*****************************************************************************/
2
3 /*
4  *      stallion.c  -- stallion multiport serial driver.
5  *
6  *      Copyright (C) 1996-1999  Stallion Technologies
7  *      Copyright (C) 1994-1996  Greg Ungerer.
8  *
9  *      This code is loosely based on the Linux serial driver, written by
10  *      Linus Torvalds, Theodore T'so and others.
11  *
12  *      This program is free software; you can redistribute it and/or modify
13  *      it under the terms of the GNU General Public License as published by
14  *      the Free Software Foundation; either version 2 of the License, or
15  *      (at your option) any later version.
16  *
17  *      This program is distributed in the hope that it will be useful,
18  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
19  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  *      GNU General Public License for more details.
21  *
22  *      You should have received a copy of the GNU General Public License
23  *      along with this program; if not, write to the Free Software
24  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25  */
26
27 /*****************************************************************************/
28
29 #include <linux/module.h>
30 #include <linux/sched.h>
31 #include <linux/slab.h>
32 #include <linux/interrupt.h>
33 #include <linux/tty.h>
34 #include <linux/tty_flip.h>
35 #include <linux/serial.h>
36 #include <linux/seq_file.h>
37 #include <linux/cd1400.h>
38 #include <linux/sc26198.h>
39 #include <linux/comstats.h>
40 #include <linux/stallion.h>
41 #include <linux/ioport.h>
42 #include <linux/init.h>
43 #include <linux/smp_lock.h>
44 #include <linux/device.h>
45 #include <linux/delay.h>
46 #include <linux/ctype.h>
47
48 #include <asm/io.h>
49 #include <asm/uaccess.h>
50
51 #include <linux/pci.h>
52
53 /*****************************************************************************/
54
55 /*
56  *      Define different board types. Use the standard Stallion "assigned"
57  *      board numbers. Boards supported in this driver are abbreviated as
58  *      EIO = EasyIO and ECH = EasyConnection 8/32.
59  */
60 #define BRD_EASYIO      20
61 #define BRD_ECH         21
62 #define BRD_ECHMC       22
63 #define BRD_ECHPCI      26
64 #define BRD_ECH64PCI    27
65 #define BRD_EASYIOPCI   28
66
67 struct stlconf {
68         unsigned int    brdtype;
69         int             ioaddr1;
70         int             ioaddr2;
71         unsigned long   memaddr;
72         int             irq;
73         int             irqtype;
74 };
75
76 static unsigned int stl_nrbrds;
77
78 /*****************************************************************************/
79
80 /*
81  *      Define some important driver characteristics. Device major numbers
82  *      allocated as per Linux Device Registry.
83  */
84 #ifndef STL_SIOMEMMAJOR
85 #define STL_SIOMEMMAJOR         28
86 #endif
87 #ifndef STL_SERIALMAJOR
88 #define STL_SERIALMAJOR         24
89 #endif
90 #ifndef STL_CALLOUTMAJOR
91 #define STL_CALLOUTMAJOR        25
92 #endif
93
94 /*
95  *      Set the TX buffer size. Bigger is better, but we don't want
96  *      to chew too much memory with buffers!
97  */
98 #define STL_TXBUFLOW            512
99 #define STL_TXBUFSIZE           4096
100
101 /*****************************************************************************/
102
103 /*
104  *      Define our local driver identity first. Set up stuff to deal with
105  *      all the local structures required by a serial tty driver.
106  */
107 static char     *stl_drvtitle = "Stallion Multiport Serial Driver";
108 static char     *stl_drvname = "stallion";
109 static char     *stl_drvversion = "5.6.0";
110
111 static struct tty_driver        *stl_serial;
112
113 /*
114  *      Define a local default termios struct. All ports will be created
115  *      with this termios initially. Basically all it defines is a raw port
116  *      at 9600, 8 data bits, 1 stop bit.
117  */
118 static struct ktermios          stl_deftermios = {
119         .c_cflag        = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
120         .c_cc           = INIT_C_CC,
121         .c_ispeed       = 9600,
122         .c_ospeed       = 9600,
123 };
124
125 /*
126  *      Define global place to put buffer overflow characters.
127  */
128 static char             stl_unwanted[SC26198_RXFIFOSIZE];
129
130 /*****************************************************************************/
131
132 static DEFINE_MUTEX(stl_brdslock);
133 static struct stlbrd            *stl_brds[STL_MAXBRDS];
134
135 static const struct tty_port_operations stl_port_ops;
136
137 /*
138  *      Per board state flags. Used with the state field of the board struct.
139  *      Not really much here!
140  */
141 #define BRD_FOUND       0x1
142 #define STL_PROBED      0x2
143
144
145 /*
146  *      Define the port structure istate flags. These set of flags are
147  *      modified at interrupt time - so setting and reseting them needs
148  *      to be atomic. Use the bit clear/setting routines for this.
149  */
150 #define ASYI_TXBUSY     1
151 #define ASYI_TXLOW      2
152 #define ASYI_TXFLOWED   3
153
154 /*
155  *      Define an array of board names as printable strings. Handy for
156  *      referencing boards when printing trace and stuff.
157  */
158 static char     *stl_brdnames[] = {
159         NULL,
160         NULL,
161         NULL,
162         NULL,
163         NULL,
164         NULL,
165         NULL,
166         NULL,
167         NULL,
168         NULL,
169         NULL,
170         NULL,
171         NULL,
172         NULL,
173         NULL,
174         NULL,
175         NULL,
176         NULL,
177         NULL,
178         NULL,
179         "EasyIO",
180         "EC8/32-AT",
181         "EC8/32-MC",
182         NULL,
183         NULL,
184         NULL,
185         "EC8/32-PCI",
186         "EC8/64-PCI",
187         "EasyIO-PCI",
188 };
189
190 /*****************************************************************************/
191
192 /*
193  *      Define some string labels for arguments passed from the module
194  *      load line. These allow for easy board definitions, and easy
195  *      modification of the io, memory and irq resoucres.
196  */
197 static unsigned int stl_nargs;
198 static char     *board0[4];
199 static char     *board1[4];
200 static char     *board2[4];
201 static char     *board3[4];
202
203 static char     **stl_brdsp[] = {
204         (char **) &board0,
205         (char **) &board1,
206         (char **) &board2,
207         (char **) &board3
208 };
209
210 /*
211  *      Define a set of common board names, and types. This is used to
212  *      parse any module arguments.
213  */
214
215 static struct {
216         char    *name;
217         int     type;
218 } stl_brdstr[] = {
219         { "easyio", BRD_EASYIO },
220         { "eio", BRD_EASYIO },
221         { "20", BRD_EASYIO },
222         { "ec8/32", BRD_ECH },
223         { "ec8/32-at", BRD_ECH },
224         { "ec8/32-isa", BRD_ECH },
225         { "ech", BRD_ECH },
226         { "echat", BRD_ECH },
227         { "21", BRD_ECH },
228         { "ec8/32-mc", BRD_ECHMC },
229         { "ec8/32-mca", BRD_ECHMC },
230         { "echmc", BRD_ECHMC },
231         { "echmca", BRD_ECHMC },
232         { "22", BRD_ECHMC },
233         { "ec8/32-pc", BRD_ECHPCI },
234         { "ec8/32-pci", BRD_ECHPCI },
235         { "26", BRD_ECHPCI },
236         { "ec8/64-pc", BRD_ECH64PCI },
237         { "ec8/64-pci", BRD_ECH64PCI },
238         { "ech-pci", BRD_ECH64PCI },
239         { "echpci", BRD_ECH64PCI },
240         { "echpc", BRD_ECH64PCI },
241         { "27", BRD_ECH64PCI },
242         { "easyio-pc", BRD_EASYIOPCI },
243         { "easyio-pci", BRD_EASYIOPCI },
244         { "eio-pci", BRD_EASYIOPCI },
245         { "eiopci", BRD_EASYIOPCI },
246         { "28", BRD_EASYIOPCI },
247 };
248
249 /*
250  *      Define the module agruments.
251  */
252
253 module_param_array(board0, charp, &stl_nargs, 0);
254 MODULE_PARM_DESC(board0, "Board 0 config -> name[,ioaddr[,ioaddr2][,irq]]");
255 module_param_array(board1, charp, &stl_nargs, 0);
256 MODULE_PARM_DESC(board1, "Board 1 config -> name[,ioaddr[,ioaddr2][,irq]]");
257 module_param_array(board2, charp, &stl_nargs, 0);
258 MODULE_PARM_DESC(board2, "Board 2 config -> name[,ioaddr[,ioaddr2][,irq]]");
259 module_param_array(board3, charp, &stl_nargs, 0);
260 MODULE_PARM_DESC(board3, "Board 3 config -> name[,ioaddr[,ioaddr2][,irq]]");
261
262 /*****************************************************************************/
263
264 /*
265  *      Hardware ID bits for the EasyIO and ECH boards. These defines apply
266  *      to the directly accessible io ports of these boards (not the uarts -
267  *      they are in cd1400.h and sc26198.h).
268  */
269 #define EIO_8PORTRS     0x04
270 #define EIO_4PORTRS     0x05
271 #define EIO_8PORTDI     0x00
272 #define EIO_8PORTM      0x06
273 #define EIO_MK3         0x03
274 #define EIO_IDBITMASK   0x07
275
276 #define EIO_BRDMASK     0xf0
277 #define ID_BRD4         0x10
278 #define ID_BRD8         0x20
279 #define ID_BRD16        0x30
280
281 #define EIO_INTRPEND    0x08
282 #define EIO_INTEDGE     0x00
283 #define EIO_INTLEVEL    0x08
284 #define EIO_0WS         0x10
285
286 #define ECH_ID          0xa0
287 #define ECH_IDBITMASK   0xe0
288 #define ECH_BRDENABLE   0x08
289 #define ECH_BRDDISABLE  0x00
290 #define ECH_INTENABLE   0x01
291 #define ECH_INTDISABLE  0x00
292 #define ECH_INTLEVEL    0x02
293 #define ECH_INTEDGE     0x00
294 #define ECH_INTRPEND    0x01
295 #define ECH_BRDRESET    0x01
296
297 #define ECHMC_INTENABLE 0x01
298 #define ECHMC_BRDRESET  0x02
299
300 #define ECH_PNLSTATUS   2
301 #define ECH_PNL16PORT   0x20
302 #define ECH_PNLIDMASK   0x07
303 #define ECH_PNLXPID     0x40
304 #define ECH_PNLINTRPEND 0x80
305
306 #define ECH_ADDR2MASK   0x1e0
307
308 /*
309  *      Define the vector mapping bits for the programmable interrupt board
310  *      hardware. These bits encode the interrupt for the board to use - it
311  *      is software selectable (except the EIO-8M).
312  */
313 static unsigned char    stl_vecmap[] = {
314         0xff, 0xff, 0xff, 0x04, 0x06, 0x05, 0xff, 0x07,
315         0xff, 0xff, 0x00, 0x02, 0x01, 0xff, 0xff, 0x03
316 };
317
318 /*
319  *      Lock ordering is that you may not take stallion_lock holding
320  *      brd_lock.
321  */
322
323 static spinlock_t brd_lock;             /* Guard the board mapping */
324 static spinlock_t stallion_lock;        /* Guard the tty driver */
325
326 /*
327  *      Set up enable and disable macros for the ECH boards. They require
328  *      the secondary io address space to be activated and deactivated.
329  *      This way all ECH boards can share their secondary io region.
330  *      If this is an ECH-PCI board then also need to set the page pointer
331  *      to point to the correct page.
332  */
333 #define BRDENABLE(brdnr,pagenr)                                         \
334         if (stl_brds[(brdnr)]->brdtype == BRD_ECH)                      \
335                 outb((stl_brds[(brdnr)]->ioctrlval | ECH_BRDENABLE),    \
336                         stl_brds[(brdnr)]->ioctrl);                     \
337         else if (stl_brds[(brdnr)]->brdtype == BRD_ECHPCI)              \
338                 outb((pagenr), stl_brds[(brdnr)]->ioctrl);
339
340 #define BRDDISABLE(brdnr)                                               \
341         if (stl_brds[(brdnr)]->brdtype == BRD_ECH)                      \
342                 outb((stl_brds[(brdnr)]->ioctrlval | ECH_BRDDISABLE),   \
343                         stl_brds[(brdnr)]->ioctrl);
344
345 #define STL_CD1400MAXBAUD       230400
346 #define STL_SC26198MAXBAUD      460800
347
348 #define STL_BAUDBASE            115200
349 #define STL_CLOSEDELAY          (5 * HZ / 10)
350
351 /*****************************************************************************/
352
353 /*
354  *      Define the Stallion PCI vendor and device IDs.
355  */
356 #ifndef PCI_VENDOR_ID_STALLION
357 #define PCI_VENDOR_ID_STALLION          0x124d
358 #endif
359 #ifndef PCI_DEVICE_ID_ECHPCI832
360 #define PCI_DEVICE_ID_ECHPCI832         0x0000
361 #endif
362 #ifndef PCI_DEVICE_ID_ECHPCI864
363 #define PCI_DEVICE_ID_ECHPCI864         0x0002
364 #endif
365 #ifndef PCI_DEVICE_ID_EIOPCI
366 #define PCI_DEVICE_ID_EIOPCI            0x0003
367 #endif
368
369 /*
370  *      Define structure to hold all Stallion PCI boards.
371  */
372
373 static struct pci_device_id stl_pcibrds[] = {
374         { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI864),
375                 .driver_data = BRD_ECH64PCI },
376         { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_EIOPCI),
377                 .driver_data = BRD_EASYIOPCI },
378         { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI832),
379                 .driver_data = BRD_ECHPCI },
380         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_87410),
381                 .driver_data = BRD_ECHPCI },
382         { }
383 };
384 MODULE_DEVICE_TABLE(pci, stl_pcibrds);
385
386 /*****************************************************************************/
387
388 /*
389  *      Define macros to extract a brd/port number from a minor number.
390  */
391 #define MINOR2BRD(min)          (((min) & 0xc0) >> 6)
392 #define MINOR2PORT(min)         ((min) & 0x3f)
393
394 /*
395  *      Define a baud rate table that converts termios baud rate selector
396  *      into the actual baud rate value. All baud rate calculations are
397  *      based on the actual baud rate required.
398  */
399 static unsigned int     stl_baudrates[] = {
400         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
401         9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600
402 };
403
404 /*****************************************************************************/
405
406 /*
407  *      Declare all those functions in this driver!
408  */
409
410 static long     stl_memioctl(struct file *fp, unsigned int cmd, unsigned long arg);
411 static int      stl_brdinit(struct stlbrd *brdp);
412 static int      stl_getportstats(struct tty_struct *tty, struct stlport *portp, comstats_t __user *cp);
413 static int      stl_clrportstats(struct stlport *portp, comstats_t __user *cp);
414
415 /*
416  *      CD1400 uart specific handling functions.
417  */
418 static void     stl_cd1400setreg(struct stlport *portp, int regnr, int value);
419 static int      stl_cd1400getreg(struct stlport *portp, int regnr);
420 static int      stl_cd1400updatereg(struct stlport *portp, int regnr, int value);
421 static int      stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp);
422 static void     stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
423 static void     stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp);
424 static int      stl_cd1400getsignals(struct stlport *portp);
425 static void     stl_cd1400setsignals(struct stlport *portp, int dtr, int rts);
426 static void     stl_cd1400ccrwait(struct stlport *portp);
427 static void     stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx);
428 static void     stl_cd1400startrxtx(struct stlport *portp, int rx, int tx);
429 static void     stl_cd1400disableintrs(struct stlport *portp);
430 static void     stl_cd1400sendbreak(struct stlport *portp, int len);
431 static void     stl_cd1400flowctrl(struct stlport *portp, int state);
432 static void     stl_cd1400sendflow(struct stlport *portp, int state);
433 static void     stl_cd1400flush(struct stlport *portp);
434 static int      stl_cd1400datastate(struct stlport *portp);
435 static void     stl_cd1400eiointr(struct stlpanel *panelp, unsigned int iobase);
436 static void     stl_cd1400echintr(struct stlpanel *panelp, unsigned int iobase);
437 static void     stl_cd1400txisr(struct stlpanel *panelp, int ioaddr);
438 static void     stl_cd1400rxisr(struct stlpanel *panelp, int ioaddr);
439 static void     stl_cd1400mdmisr(struct stlpanel *panelp, int ioaddr);
440
441 static inline int       stl_cd1400breakisr(struct stlport *portp, int ioaddr);
442
443 /*
444  *      SC26198 uart specific handling functions.
445  */
446 static void     stl_sc26198setreg(struct stlport *portp, int regnr, int value);
447 static int      stl_sc26198getreg(struct stlport *portp, int regnr);
448 static int      stl_sc26198updatereg(struct stlport *portp, int regnr, int value);
449 static int      stl_sc26198getglobreg(struct stlport *portp, int regnr);
450 static int      stl_sc26198panelinit(struct stlbrd *brdp, struct stlpanel *panelp);
451 static void     stl_sc26198portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
452 static void     stl_sc26198setport(struct stlport *portp, struct ktermios *tiosp);
453 static int      stl_sc26198getsignals(struct stlport *portp);
454 static void     stl_sc26198setsignals(struct stlport *portp, int dtr, int rts);
455 static void     stl_sc26198enablerxtx(struct stlport *portp, int rx, int tx);
456 static void     stl_sc26198startrxtx(struct stlport *portp, int rx, int tx);
457 static void     stl_sc26198disableintrs(struct stlport *portp);
458 static void     stl_sc26198sendbreak(struct stlport *portp, int len);
459 static void     stl_sc26198flowctrl(struct stlport *portp, int state);
460 static void     stl_sc26198sendflow(struct stlport *portp, int state);
461 static void     stl_sc26198flush(struct stlport *portp);
462 static int      stl_sc26198datastate(struct stlport *portp);
463 static void     stl_sc26198wait(struct stlport *portp);
464 static void     stl_sc26198txunflow(struct stlport *portp, struct tty_struct *tty);
465 static void     stl_sc26198intr(struct stlpanel *panelp, unsigned int iobase);
466 static void     stl_sc26198txisr(struct stlport *port);
467 static void     stl_sc26198rxisr(struct stlport *port, unsigned int iack);
468 static void     stl_sc26198rxbadch(struct stlport *portp, unsigned char status, char ch);
469 static void     stl_sc26198rxbadchars(struct stlport *portp);
470 static void     stl_sc26198otherisr(struct stlport *port, unsigned int iack);
471
472 /*****************************************************************************/
473
474 /*
475  *      Generic UART support structure.
476  */
477 typedef struct uart {
478         int     (*panelinit)(struct stlbrd *brdp, struct stlpanel *panelp);
479         void    (*portinit)(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
480         void    (*setport)(struct stlport *portp, struct ktermios *tiosp);
481         int     (*getsignals)(struct stlport *portp);
482         void    (*setsignals)(struct stlport *portp, int dtr, int rts);
483         void    (*enablerxtx)(struct stlport *portp, int rx, int tx);
484         void    (*startrxtx)(struct stlport *portp, int rx, int tx);
485         void    (*disableintrs)(struct stlport *portp);
486         void    (*sendbreak)(struct stlport *portp, int len);
487         void    (*flowctrl)(struct stlport *portp, int state);
488         void    (*sendflow)(struct stlport *portp, int state);
489         void    (*flush)(struct stlport *portp);
490         int     (*datastate)(struct stlport *portp);
491         void    (*intr)(struct stlpanel *panelp, unsigned int iobase);
492 } uart_t;
493
494 /*
495  *      Define some macros to make calling these functions nice and clean.
496  */
497 #define stl_panelinit           (* ((uart_t *) panelp->uartp)->panelinit)
498 #define stl_portinit            (* ((uart_t *) portp->uartp)->portinit)
499 #define stl_setport             (* ((uart_t *) portp->uartp)->setport)
500 #define stl_getsignals          (* ((uart_t *) portp->uartp)->getsignals)
501 #define stl_setsignals          (* ((uart_t *) portp->uartp)->setsignals)
502 #define stl_enablerxtx          (* ((uart_t *) portp->uartp)->enablerxtx)
503 #define stl_startrxtx           (* ((uart_t *) portp->uartp)->startrxtx)
504 #define stl_disableintrs        (* ((uart_t *) portp->uartp)->disableintrs)
505 #define stl_sendbreak           (* ((uart_t *) portp->uartp)->sendbreak)
506 #define stl_flowctrl            (* ((uart_t *) portp->uartp)->flowctrl)
507 #define stl_sendflow            (* ((uart_t *) portp->uartp)->sendflow)
508 #define stl_flush               (* ((uart_t *) portp->uartp)->flush)
509 #define stl_datastate           (* ((uart_t *) portp->uartp)->datastate)
510
511 /*****************************************************************************/
512
513 /*
514  *      CD1400 UART specific data initialization.
515  */
516 static uart_t stl_cd1400uart = {
517         stl_cd1400panelinit,
518         stl_cd1400portinit,
519         stl_cd1400setport,
520         stl_cd1400getsignals,
521         stl_cd1400setsignals,
522         stl_cd1400enablerxtx,
523         stl_cd1400startrxtx,
524         stl_cd1400disableintrs,
525         stl_cd1400sendbreak,
526         stl_cd1400flowctrl,
527         stl_cd1400sendflow,
528         stl_cd1400flush,
529         stl_cd1400datastate,
530         stl_cd1400eiointr
531 };
532
533 /*
534  *      Define the offsets within the register bank of a cd1400 based panel.
535  *      These io address offsets are common to the EasyIO board as well.
536  */
537 #define EREG_ADDR       0
538 #define EREG_DATA       4
539 #define EREG_RXACK      5
540 #define EREG_TXACK      6
541 #define EREG_MDACK      7
542
543 #define EREG_BANKSIZE   8
544
545 #define CD1400_CLK      25000000
546 #define CD1400_CLK8M    20000000
547
548 /*
549  *      Define the cd1400 baud rate clocks. These are used when calculating
550  *      what clock and divisor to use for the required baud rate. Also
551  *      define the maximum baud rate allowed, and the default base baud.
552  */
553 static int      stl_cd1400clkdivs[] = {
554         CD1400_CLK0, CD1400_CLK1, CD1400_CLK2, CD1400_CLK3, CD1400_CLK4
555 };
556
557 /*****************************************************************************/
558
559 /*
560  *      SC26198 UART specific data initization.
561  */
562 static uart_t stl_sc26198uart = {
563         stl_sc26198panelinit,
564         stl_sc26198portinit,
565         stl_sc26198setport,
566         stl_sc26198getsignals,
567         stl_sc26198setsignals,
568         stl_sc26198enablerxtx,
569         stl_sc26198startrxtx,
570         stl_sc26198disableintrs,
571         stl_sc26198sendbreak,
572         stl_sc26198flowctrl,
573         stl_sc26198sendflow,
574         stl_sc26198flush,
575         stl_sc26198datastate,
576         stl_sc26198intr
577 };
578
579 /*
580  *      Define the offsets within the register bank of a sc26198 based panel.
581  */
582 #define XP_DATA         0
583 #define XP_ADDR         1
584 #define XP_MODID        2
585 #define XP_STATUS       2
586 #define XP_IACK         3
587
588 #define XP_BANKSIZE     4
589
590 /*
591  *      Define the sc26198 baud rate table. Offsets within the table
592  *      represent the actual baud rate selector of sc26198 registers.
593  */
594 static unsigned int     sc26198_baudtable[] = {
595         50, 75, 150, 200, 300, 450, 600, 900, 1200, 1800, 2400, 3600,
596         4800, 7200, 9600, 14400, 19200, 28800, 38400, 57600, 115200,
597         230400, 460800, 921600
598 };
599
600 #define SC26198_NRBAUDS         ARRAY_SIZE(sc26198_baudtable)
601
602 /*****************************************************************************/
603
604 /*
605  *      Define the driver info for a user level control device. Used mainly
606  *      to get at port stats - only not using the port device itself.
607  */
608 static const struct file_operations     stl_fsiomem = {
609         .owner          = THIS_MODULE,
610         .unlocked_ioctl = stl_memioctl,
611         .llseek         = noop_llseek,
612 };
613
614 static struct class *stallion_class;
615
616 static void stl_cd_change(struct stlport *portp)
617 {
618         unsigned int oldsigs = portp->sigs;
619         struct tty_struct *tty = tty_port_tty_get(&portp->port);
620
621         if (!tty)
622                 return;
623
624         portp->sigs = stl_getsignals(portp);
625
626         if ((portp->sigs & TIOCM_CD) && ((oldsigs & TIOCM_CD) == 0))
627                 wake_up_interruptible(&portp->port.open_wait);
628
629         if ((oldsigs & TIOCM_CD) && ((portp->sigs & TIOCM_CD) == 0))
630                 if (portp->port.flags & ASYNC_CHECK_CD)
631                         tty_hangup(tty);
632         tty_kref_put(tty);
633 }
634
635 /*
636  *      Check for any arguments passed in on the module load command line.
637  */
638
639 /*****************************************************************************/
640
641 /*
642  *      Parse the supplied argument string, into the board conf struct.
643  */
644
645 static int __init stl_parsebrd(struct stlconf *confp, char **argp)
646 {
647         char    *sp;
648         unsigned int i;
649
650         pr_debug("stl_parsebrd(confp=%p,argp=%p)\n", confp, argp);
651
652         if ((argp[0] == NULL) || (*argp[0] == 0))
653                 return 0;
654
655         for (sp = argp[0], i = 0; (*sp != 0) && (i < 25); sp++, i++)
656                 *sp = tolower(*sp);
657
658         for (i = 0; i < ARRAY_SIZE(stl_brdstr); i++)
659                 if (strcmp(stl_brdstr[i].name, argp[0]) == 0)
660                         break;
661
662         if (i == ARRAY_SIZE(stl_brdstr)) {
663                 printk("STALLION: unknown board name, %s?\n", argp[0]);
664                 return 0;
665         }
666
667         confp->brdtype = stl_brdstr[i].type;
668
669         i = 1;
670         if ((argp[i] != NULL) && (*argp[i] != 0))
671                 confp->ioaddr1 = simple_strtoul(argp[i], NULL, 0);
672         i++;
673         if (confp->brdtype == BRD_ECH) {
674                 if ((argp[i] != NULL) && (*argp[i] != 0))
675                         confp->ioaddr2 = simple_strtoul(argp[i], NULL, 0);
676                 i++;
677         }
678         if ((argp[i] != NULL) && (*argp[i] != 0))
679                 confp->irq = simple_strtoul(argp[i], NULL, 0);
680         return 1;
681 }
682
683 /*****************************************************************************/
684
685 /*
686  *      Allocate a new board structure. Fill out the basic info in it.
687  */
688
689 static struct stlbrd *stl_allocbrd(void)
690 {
691         struct stlbrd   *brdp;
692
693         brdp = kzalloc(sizeof(struct stlbrd), GFP_KERNEL);
694         if (!brdp) {
695                 printk("STALLION: failed to allocate memory (size=%Zd)\n",
696                         sizeof(struct stlbrd));
697                 return NULL;
698         }
699
700         brdp->magic = STL_BOARDMAGIC;
701         return brdp;
702 }
703
704 /*****************************************************************************/
705
706 static int stl_activate(struct tty_port *port, struct tty_struct *tty)
707 {
708         struct stlport *portp = container_of(port, struct stlport, port);
709         if (!portp->tx.buf) {
710                 portp->tx.buf = kmalloc(STL_TXBUFSIZE, GFP_KERNEL);
711                 if (!portp->tx.buf)
712                         return -ENOMEM;
713                 portp->tx.head = portp->tx.buf;
714                 portp->tx.tail = portp->tx.buf;
715         }
716         stl_setport(portp, tty->termios);
717         portp->sigs = stl_getsignals(portp);
718         stl_setsignals(portp, 1, 1);
719         stl_enablerxtx(portp, 1, 1);
720         stl_startrxtx(portp, 1, 0);
721         return 0;
722 }
723
724 static int stl_open(struct tty_struct *tty, struct file *filp)
725 {
726         struct stlport  *portp;
727         struct stlbrd   *brdp;
728         unsigned int    minordev, brdnr, panelnr;
729         int             portnr;
730
731         pr_debug("stl_open(tty=%p,filp=%p): device=%s\n", tty, filp, tty->name);
732
733         minordev = tty->index;
734         brdnr = MINOR2BRD(minordev);
735         if (brdnr >= stl_nrbrds)
736                 return -ENODEV;
737         brdp = stl_brds[brdnr];
738         if (brdp == NULL)
739                 return -ENODEV;
740
741         minordev = MINOR2PORT(minordev);
742         for (portnr = -1, panelnr = 0; panelnr < STL_MAXPANELS; panelnr++) {
743                 if (brdp->panels[panelnr] == NULL)
744                         break;
745                 if (minordev < brdp->panels[panelnr]->nrports) {
746                         portnr = minordev;
747                         break;
748                 }
749                 minordev -= brdp->panels[panelnr]->nrports;
750         }
751         if (portnr < 0)
752                 return -ENODEV;
753
754         portp = brdp->panels[panelnr]->ports[portnr];
755         if (portp == NULL)
756                 return -ENODEV;
757
758         tty->driver_data = portp;
759         return tty_port_open(&portp->port, tty, filp);
760
761 }
762
763 /*****************************************************************************/
764
765 static int stl_carrier_raised(struct tty_port *port)
766 {
767         struct stlport *portp = container_of(port, struct stlport, port);
768         return (portp->sigs & TIOCM_CD) ? 1 : 0;
769 }
770
771 static void stl_dtr_rts(struct tty_port *port, int on)
772 {
773         struct stlport *portp = container_of(port, struct stlport, port);
774         /* Takes brd_lock internally */
775         stl_setsignals(portp, on, on);
776 }
777
778 /*****************************************************************************/
779
780 static void stl_flushbuffer(struct tty_struct *tty)
781 {
782         struct stlport  *portp;
783
784         pr_debug("stl_flushbuffer(tty=%p)\n", tty);
785
786         portp = tty->driver_data;
787         if (portp == NULL)
788                 return;
789
790         stl_flush(portp);
791         tty_wakeup(tty);
792 }
793
794 /*****************************************************************************/
795
796 static void stl_waituntilsent(struct tty_struct *tty, int timeout)
797 {
798         struct stlport  *portp;
799         unsigned long   tend;
800
801         pr_debug("stl_waituntilsent(tty=%p,timeout=%d)\n", tty, timeout);
802
803         portp = tty->driver_data;
804         if (portp == NULL)
805                 return;
806
807         if (timeout == 0)
808                 timeout = HZ;
809         tend = jiffies + timeout;
810
811         while (stl_datastate(portp)) {
812                 if (signal_pending(current))
813                         break;
814                 msleep_interruptible(20);
815                 if (time_after_eq(jiffies, tend))
816                         break;
817         }
818 }
819
820 /*****************************************************************************/
821
822 static void stl_shutdown(struct tty_port *port)
823 {
824         struct stlport *portp = container_of(port, struct stlport, port);
825         stl_disableintrs(portp);
826         stl_enablerxtx(portp, 0, 0);
827         stl_flush(portp);
828         portp->istate = 0;
829         if (portp->tx.buf != NULL) {
830                 kfree(portp->tx.buf);
831                 portp->tx.buf = NULL;
832                 portp->tx.head = NULL;
833                 portp->tx.tail = NULL;
834         }
835 }
836
837 static void stl_close(struct tty_struct *tty, struct file *filp)
838 {
839         struct stlport*portp;
840         pr_debug("stl_close(tty=%p,filp=%p)\n", tty, filp);
841
842         portp = tty->driver_data;
843         if(portp == NULL)
844                 return;
845         tty_port_close(&portp->port, tty, filp);
846 }
847
848 /*****************************************************************************/
849
850 /*
851  *      Write routine. Take data and stuff it in to the TX ring queue.
852  *      If transmit interrupts are not running then start them.
853  */
854
855 static int stl_write(struct tty_struct *tty, const unsigned char *buf, int count)
856 {
857         struct stlport  *portp;
858         unsigned int    len, stlen;
859         unsigned char   *chbuf;
860         char            *head, *tail;
861
862         pr_debug("stl_write(tty=%p,buf=%p,count=%d)\n", tty, buf, count);
863
864         portp = tty->driver_data;
865         if (portp == NULL)
866                 return 0;
867         if (portp->tx.buf == NULL)
868                 return 0;
869
870 /*
871  *      If copying direct from user space we must cater for page faults,
872  *      causing us to "sleep" here for a while. To handle this copy in all
873  *      the data we need now, into a local buffer. Then when we got it all
874  *      copy it into the TX buffer.
875  */
876         chbuf = (unsigned char *) buf;
877
878         head = portp->tx.head;
879         tail = portp->tx.tail;
880         if (head >= tail) {
881                 len = STL_TXBUFSIZE - (head - tail) - 1;
882                 stlen = STL_TXBUFSIZE - (head - portp->tx.buf);
883         } else {
884                 len = tail - head - 1;
885                 stlen = len;
886         }
887
888         len = min(len, (unsigned int)count);
889         count = 0;
890         while (len > 0) {
891                 stlen = min(len, stlen);
892                 memcpy(head, chbuf, stlen);
893                 len -= stlen;
894                 chbuf += stlen;
895                 count += stlen;
896                 head += stlen;
897                 if (head >= (portp->tx.buf + STL_TXBUFSIZE)) {
898                         head = portp->tx.buf;
899                         stlen = tail - head;
900                 }
901         }
902         portp->tx.head = head;
903
904         clear_bit(ASYI_TXLOW, &portp->istate);
905         stl_startrxtx(portp, -1, 1);
906
907         return count;
908 }
909
910 /*****************************************************************************/
911
912 static int stl_putchar(struct tty_struct *tty, unsigned char ch)
913 {
914         struct stlport  *portp;
915         unsigned int    len;
916         char            *head, *tail;
917
918         pr_debug("stl_putchar(tty=%p,ch=%x)\n", tty, ch);
919
920         portp = tty->driver_data;
921         if (portp == NULL)
922                 return -EINVAL;
923         if (portp->tx.buf == NULL)
924                 return -EINVAL;
925
926         head = portp->tx.head;
927         tail = portp->tx.tail;
928
929         len = (head >= tail) ? (STL_TXBUFSIZE - (head - tail)) : (tail - head);
930         len--;
931
932         if (len > 0) {
933                 *head++ = ch;
934                 if (head >= (portp->tx.buf + STL_TXBUFSIZE))
935                         head = portp->tx.buf;
936         }       
937         portp->tx.head = head;
938         return 0;
939 }
940
941 /*****************************************************************************/
942
943 /*
944  *      If there are any characters in the buffer then make sure that TX
945  *      interrupts are on and get'em out. Normally used after the putchar
946  *      routine has been called.
947  */
948
949 static void stl_flushchars(struct tty_struct *tty)
950 {
951         struct stlport  *portp;
952
953         pr_debug("stl_flushchars(tty=%p)\n", tty);
954
955         portp = tty->driver_data;
956         if (portp == NULL)
957                 return;
958         if (portp->tx.buf == NULL)
959                 return;
960
961         stl_startrxtx(portp, -1, 1);
962 }
963
964 /*****************************************************************************/
965
966 static int stl_writeroom(struct tty_struct *tty)
967 {
968         struct stlport  *portp;
969         char            *head, *tail;
970
971         pr_debug("stl_writeroom(tty=%p)\n", tty);
972
973         portp = tty->driver_data;
974         if (portp == NULL)
975                 return 0;
976         if (portp->tx.buf == NULL)
977                 return 0;
978
979         head = portp->tx.head;
980         tail = portp->tx.tail;
981         return (head >= tail) ? (STL_TXBUFSIZE - (head - tail) - 1) : (tail - head - 1);
982 }
983
984 /*****************************************************************************/
985
986 /*
987  *      Return number of chars in the TX buffer. Normally we would just
988  *      calculate the number of chars in the buffer and return that, but if
989  *      the buffer is empty and TX interrupts are still on then we return
990  *      that the buffer still has 1 char in it. This way whoever called us
991  *      will not think that ALL chars have drained - since the UART still
992  *      must have some chars in it (we are busy after all).
993  */
994
995 static int stl_charsinbuffer(struct tty_struct *tty)
996 {
997         struct stlport  *portp;
998         unsigned int    size;
999         char            *head, *tail;
1000
1001         pr_debug("stl_charsinbuffer(tty=%p)\n", tty);
1002
1003         portp = tty->driver_data;
1004         if (portp == NULL)
1005                 return 0;
1006         if (portp->tx.buf == NULL)
1007                 return 0;
1008
1009         head = portp->tx.head;
1010         tail = portp->tx.tail;
1011         size = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
1012         if ((size == 0) && test_bit(ASYI_TXBUSY, &portp->istate))
1013                 size = 1;
1014         return size;
1015 }
1016
1017 /*****************************************************************************/
1018
1019 /*
1020  *      Generate the serial struct info.
1021  */
1022
1023 static int stl_getserial(struct stlport *portp, struct serial_struct __user *sp)
1024 {
1025         struct serial_struct    sio;
1026         struct stlbrd           *brdp;
1027
1028         pr_debug("stl_getserial(portp=%p,sp=%p)\n", portp, sp);
1029
1030         memset(&sio, 0, sizeof(struct serial_struct));
1031
1032         mutex_lock(&portp->port.mutex);
1033         sio.line = portp->portnr;
1034         sio.port = portp->ioaddr;
1035         sio.flags = portp->port.flags;
1036         sio.baud_base = portp->baud_base;
1037         sio.close_delay = portp->close_delay;
1038         sio.closing_wait = portp->closing_wait;
1039         sio.custom_divisor = portp->custom_divisor;
1040         sio.hub6 = 0;
1041         if (portp->uartp == &stl_cd1400uart) {
1042                 sio.type = PORT_CIRRUS;
1043                 sio.xmit_fifo_size = CD1400_TXFIFOSIZE;
1044         } else {
1045                 sio.type = PORT_UNKNOWN;
1046                 sio.xmit_fifo_size = SC26198_TXFIFOSIZE;
1047         }
1048
1049         brdp = stl_brds[portp->brdnr];
1050         if (brdp != NULL)
1051                 sio.irq = brdp->irq;
1052         mutex_unlock(&portp->port.mutex);
1053
1054         return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ? -EFAULT : 0;
1055 }
1056
1057 /*****************************************************************************/
1058
1059 /*
1060  *      Set port according to the serial struct info.
1061  *      At this point we do not do any auto-configure stuff, so we will
1062  *      just quietly ignore any requests to change irq, etc.
1063  */
1064
1065 static int stl_setserial(struct tty_struct *tty, struct serial_struct __user *sp)
1066 {
1067         struct stlport *        portp = tty->driver_data;
1068         struct serial_struct    sio;
1069
1070         pr_debug("stl_setserial(portp=%p,sp=%p)\n", portp, sp);
1071
1072         if (copy_from_user(&sio, sp, sizeof(struct serial_struct)))
1073                 return -EFAULT;
1074         mutex_lock(&portp->port.mutex);
1075         if (!capable(CAP_SYS_ADMIN)) {
1076                 if ((sio.baud_base != portp->baud_base) ||
1077                     (sio.close_delay != portp->close_delay) ||
1078                     ((sio.flags & ~ASYNC_USR_MASK) !=
1079                     (portp->port.flags & ~ASYNC_USR_MASK))) {
1080                         mutex_unlock(&portp->port.mutex);
1081                         return -EPERM;
1082                 }
1083         } 
1084
1085         portp->port.flags = (portp->port.flags & ~ASYNC_USR_MASK) |
1086                 (sio.flags & ASYNC_USR_MASK);
1087         portp->baud_base = sio.baud_base;
1088         portp->close_delay = sio.close_delay;
1089         portp->closing_wait = sio.closing_wait;
1090         portp->custom_divisor = sio.custom_divisor;
1091         mutex_unlock(&portp->port.mutex);
1092         stl_setport(portp, tty->termios);
1093         return 0;
1094 }
1095
1096 /*****************************************************************************/
1097
1098 static int stl_tiocmget(struct tty_struct *tty, struct file *file)
1099 {
1100         struct stlport  *portp;
1101
1102         portp = tty->driver_data;
1103         if (portp == NULL)
1104                 return -ENODEV;
1105         if (tty->flags & (1 << TTY_IO_ERROR))
1106                 return -EIO;
1107
1108         return stl_getsignals(portp);
1109 }
1110
1111 static int stl_tiocmset(struct tty_struct *tty, struct file *file,
1112                         unsigned int set, unsigned int clear)
1113 {
1114         struct stlport  *portp;
1115         int rts = -1, dtr = -1;
1116
1117         portp = tty->driver_data;
1118         if (portp == NULL)
1119                 return -ENODEV;
1120         if (tty->flags & (1 << TTY_IO_ERROR))
1121                 return -EIO;
1122
1123         if (set & TIOCM_RTS)
1124                 rts = 1;
1125         if (set & TIOCM_DTR)
1126                 dtr = 1;
1127         if (clear & TIOCM_RTS)
1128                 rts = 0;
1129         if (clear & TIOCM_DTR)
1130                 dtr = 0;
1131
1132         stl_setsignals(portp, dtr, rts);
1133         return 0;
1134 }
1135
1136 static int stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
1137 {
1138         struct stlport  *portp;
1139         int             rc;
1140         void __user *argp = (void __user *)arg;
1141
1142         pr_debug("stl_ioctl(tty=%p,file=%p,cmd=%x,arg=%lx)\n", tty, file, cmd,
1143                         arg);
1144
1145         portp = tty->driver_data;
1146         if (portp == NULL)
1147                 return -ENODEV;
1148
1149         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
1150             (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS))
1151                 if (tty->flags & (1 << TTY_IO_ERROR))
1152                         return -EIO;
1153
1154         rc = 0;
1155
1156         switch (cmd) {
1157         case TIOCGSERIAL:
1158                 rc = stl_getserial(portp, argp);
1159                 break;
1160         case TIOCSSERIAL:
1161                 rc = stl_setserial(tty, argp);
1162                 break;
1163         case COM_GETPORTSTATS:
1164                 rc = stl_getportstats(tty, portp, argp);
1165                 break;
1166         case COM_CLRPORTSTATS:
1167                 rc = stl_clrportstats(portp, argp);
1168                 break;
1169         case TIOCSERCONFIG:
1170         case TIOCSERGWILD:
1171         case TIOCSERSWILD:
1172         case TIOCSERGETLSR:
1173         case TIOCSERGSTRUCT:
1174         case TIOCSERGETMULTI:
1175         case TIOCSERSETMULTI:
1176         default:
1177                 rc = -ENOIOCTLCMD;
1178                 break;
1179         }
1180         return rc;
1181 }
1182
1183 /*****************************************************************************/
1184
1185 /*
1186  *      Start the transmitter again. Just turn TX interrupts back on.
1187  */
1188
1189 static void stl_start(struct tty_struct *tty)
1190 {
1191         struct stlport  *portp;
1192
1193         pr_debug("stl_start(tty=%p)\n", tty);
1194
1195         portp = tty->driver_data;
1196         if (portp == NULL)
1197                 return;
1198         stl_startrxtx(portp, -1, 1);
1199 }
1200
1201 /*****************************************************************************/
1202
1203 static void stl_settermios(struct tty_struct *tty, struct ktermios *old)
1204 {
1205         struct stlport  *portp;
1206         struct ktermios *tiosp;
1207
1208         pr_debug("stl_settermios(tty=%p,old=%p)\n", tty, old);
1209
1210         portp = tty->driver_data;
1211         if (portp == NULL)
1212                 return;
1213
1214         tiosp = tty->termios;
1215         if ((tiosp->c_cflag == old->c_cflag) &&
1216             (tiosp->c_iflag == old->c_iflag))
1217                 return;
1218
1219         stl_setport(portp, tiosp);
1220         stl_setsignals(portp, ((tiosp->c_cflag & (CBAUD & ~CBAUDEX)) ? 1 : 0),
1221                 -1);
1222         if ((old->c_cflag & CRTSCTS) && ((tiosp->c_cflag & CRTSCTS) == 0)) {
1223                 tty->hw_stopped = 0;
1224                 stl_start(tty);
1225         }
1226         if (((old->c_cflag & CLOCAL) == 0) && (tiosp->c_cflag & CLOCAL))
1227                 wake_up_interruptible(&portp->port.open_wait);
1228 }
1229
1230 /*****************************************************************************/
1231
1232 /*
1233  *      Attempt to flow control who ever is sending us data. Based on termios
1234  *      settings use software or/and hardware flow control.
1235  */
1236
1237 static void stl_throttle(struct tty_struct *tty)
1238 {
1239         struct stlport  *portp;
1240
1241         pr_debug("stl_throttle(tty=%p)\n", tty);
1242
1243         portp = tty->driver_data;
1244         if (portp == NULL)
1245                 return;
1246         stl_flowctrl(portp, 0);
1247 }
1248
1249 /*****************************************************************************/
1250
1251 /*
1252  *      Unflow control the device sending us data...
1253  */
1254
1255 static void stl_unthrottle(struct tty_struct *tty)
1256 {
1257         struct stlport  *portp;
1258
1259         pr_debug("stl_unthrottle(tty=%p)\n", tty);
1260
1261         portp = tty->driver_data;
1262         if (portp == NULL)
1263                 return;
1264         stl_flowctrl(portp, 1);
1265 }
1266
1267 /*****************************************************************************/
1268
1269 /*
1270  *      Stop the transmitter. Basically to do this we will just turn TX
1271  *      interrupts off.
1272  */
1273
1274 static void stl_stop(struct tty_struct *tty)
1275 {
1276         struct stlport  *portp;
1277
1278         pr_debug("stl_stop(tty=%p)\n", tty);
1279
1280         portp = tty->driver_data;
1281         if (portp == NULL)
1282                 return;
1283         stl_startrxtx(portp, -1, 0);
1284 }
1285
1286 /*****************************************************************************/
1287
1288 /*
1289  *      Hangup this port. This is pretty much like closing the port, only
1290  *      a little more brutal. No waiting for data to drain. Shutdown the
1291  *      port and maybe drop signals.
1292  */
1293
1294 static void stl_hangup(struct tty_struct *tty)
1295 {
1296         struct stlport  *portp = tty->driver_data;
1297         pr_debug("stl_hangup(tty=%p)\n", tty);
1298
1299         if (portp == NULL)
1300                 return;
1301         tty_port_hangup(&portp->port);
1302 }
1303
1304 /*****************************************************************************/
1305
1306 static int stl_breakctl(struct tty_struct *tty, int state)
1307 {
1308         struct stlport  *portp;
1309
1310         pr_debug("stl_breakctl(tty=%p,state=%d)\n", tty, state);
1311
1312         portp = tty->driver_data;
1313         if (portp == NULL)
1314                 return -EINVAL;
1315
1316         stl_sendbreak(portp, ((state == -1) ? 1 : 2));
1317         return 0;
1318 }
1319
1320 /*****************************************************************************/
1321
1322 static void stl_sendxchar(struct tty_struct *tty, char ch)
1323 {
1324         struct stlport  *portp;
1325
1326         pr_debug("stl_sendxchar(tty=%p,ch=%x)\n", tty, ch);
1327
1328         portp = tty->driver_data;
1329         if (portp == NULL)
1330                 return;
1331
1332         if (ch == STOP_CHAR(tty))
1333                 stl_sendflow(portp, 0);
1334         else if (ch == START_CHAR(tty))
1335                 stl_sendflow(portp, 1);
1336         else
1337                 stl_putchar(tty, ch);
1338 }
1339
1340 static void stl_portinfo(struct seq_file *m, struct stlport *portp, int portnr)
1341 {
1342         int     sigs;
1343         char sep;
1344
1345         seq_printf(m, "%d: uart:%s tx:%d rx:%d",
1346                 portnr, (portp->hwid == 1) ? "SC26198" : "CD1400",
1347                 (int) portp->stats.txtotal, (int) portp->stats.rxtotal);
1348
1349         if (portp->stats.rxframing)
1350                 seq_printf(m, " fe:%d", (int) portp->stats.rxframing);
1351         if (portp->stats.rxparity)
1352                 seq_printf(m, " pe:%d", (int) portp->stats.rxparity);
1353         if (portp->stats.rxbreaks)
1354                 seq_printf(m, " brk:%d", (int) portp->stats.rxbreaks);
1355         if (portp->stats.rxoverrun)
1356                 seq_printf(m, " oe:%d", (int) portp->stats.rxoverrun);
1357
1358         sigs = stl_getsignals(portp);
1359         sep = ' ';
1360         if (sigs & TIOCM_RTS) {
1361                 seq_printf(m, "%c%s", sep, "RTS");
1362                 sep = '|';
1363         }
1364         if (sigs & TIOCM_CTS) {
1365                 seq_printf(m, "%c%s", sep, "CTS");
1366                 sep = '|';
1367         }
1368         if (sigs & TIOCM_DTR) {
1369                 seq_printf(m, "%c%s", sep, "DTR");
1370                 sep = '|';
1371         }
1372         if (sigs & TIOCM_CD) {
1373                 seq_printf(m, "%c%s", sep, "DCD");
1374                 sep = '|';
1375         }
1376         if (sigs & TIOCM_DSR) {
1377                 seq_printf(m, "%c%s", sep, "DSR");
1378                 sep = '|';
1379         }
1380         seq_putc(m, '\n');
1381 }
1382
1383 /*****************************************************************************/
1384
1385 /*
1386  *      Port info, read from the /proc file system.
1387  */
1388
1389 static int stl_proc_show(struct seq_file *m, void *v)
1390 {
1391         struct stlbrd   *brdp;
1392         struct stlpanel *panelp;
1393         struct stlport  *portp;
1394         unsigned int    brdnr, panelnr, portnr;
1395         int             totalport;
1396
1397         totalport = 0;
1398
1399         seq_printf(m, "%s: version %s\n", stl_drvtitle, stl_drvversion);
1400
1401 /*
1402  *      We scan through for each board, panel and port. The offset is
1403  *      calculated on the fly, and irrelevant ports are skipped.
1404  */
1405         for (brdnr = 0; brdnr < stl_nrbrds; brdnr++) {
1406                 brdp = stl_brds[brdnr];
1407                 if (brdp == NULL)
1408                         continue;
1409                 if (brdp->state == 0)
1410                         continue;
1411
1412                 totalport = brdnr * STL_MAXPORTS;
1413                 for (panelnr = 0; panelnr < brdp->nrpanels; panelnr++) {
1414                         panelp = brdp->panels[panelnr];
1415                         if (panelp == NULL)
1416                                 continue;
1417
1418                         for (portnr = 0; portnr < panelp->nrports; portnr++,
1419                             totalport++) {
1420                                 portp = panelp->ports[portnr];
1421                                 if (portp == NULL)
1422                                         continue;
1423                                 stl_portinfo(m, portp, totalport);
1424                         }
1425                 }
1426         }
1427         return 0;
1428 }
1429
1430 static int stl_proc_open(struct inode *inode, struct file *file)
1431 {
1432         return single_open(file, stl_proc_show, NULL);
1433 }
1434
1435 static const struct file_operations stl_proc_fops = {
1436         .owner          = THIS_MODULE,
1437         .open           = stl_proc_open,
1438         .read           = seq_read,
1439         .llseek         = seq_lseek,
1440         .release        = single_release,
1441 };
1442
1443 /*****************************************************************************/
1444
1445 /*
1446  *      All board interrupts are vectored through here first. This code then
1447  *      calls off to the approrpriate board interrupt handlers.
1448  */
1449
1450 static irqreturn_t stl_intr(int irq, void *dev_id)
1451 {
1452         struct stlbrd *brdp = dev_id;
1453
1454         pr_debug("stl_intr(brdp=%p,irq=%d)\n", brdp, brdp->irq);
1455
1456         return IRQ_RETVAL((* brdp->isr)(brdp));
1457 }
1458
1459 /*****************************************************************************/
1460
1461 /*
1462  *      Interrupt service routine for EasyIO board types.
1463  */
1464
1465 static int stl_eiointr(struct stlbrd *brdp)
1466 {
1467         struct stlpanel *panelp;
1468         unsigned int    iobase;
1469         int             handled = 0;
1470
1471         spin_lock(&brd_lock);
1472         panelp = brdp->panels[0];
1473         iobase = panelp->iobase;
1474         while (inb(brdp->iostatus) & EIO_INTRPEND) {
1475                 handled = 1;
1476                 (* panelp->isr)(panelp, iobase);
1477         }
1478         spin_unlock(&brd_lock);
1479         return handled;
1480 }
1481
1482 /*****************************************************************************/
1483
1484 /*
1485  *      Interrupt service routine for ECH-AT board types.
1486  */
1487
1488 static int stl_echatintr(struct stlbrd *brdp)
1489 {
1490         struct stlpanel *panelp;
1491         unsigned int    ioaddr, bnknr;
1492         int             handled = 0;
1493
1494         outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl);
1495
1496         while (inb(brdp->iostatus) & ECH_INTRPEND) {
1497                 handled = 1;
1498                 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1499                         ioaddr = brdp->bnkstataddr[bnknr];
1500                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1501                                 panelp = brdp->bnk2panel[bnknr];
1502                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1503                         }
1504                 }
1505         }
1506
1507         outb((brdp->ioctrlval | ECH_BRDDISABLE), brdp->ioctrl);
1508
1509         return handled;
1510 }
1511
1512 /*****************************************************************************/
1513
1514 /*
1515  *      Interrupt service routine for ECH-MCA board types.
1516  */
1517
1518 static int stl_echmcaintr(struct stlbrd *brdp)
1519 {
1520         struct stlpanel *panelp;
1521         unsigned int    ioaddr, bnknr;
1522         int             handled = 0;
1523
1524         while (inb(brdp->iostatus) & ECH_INTRPEND) {
1525                 handled = 1;
1526                 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1527                         ioaddr = brdp->bnkstataddr[bnknr];
1528                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1529                                 panelp = brdp->bnk2panel[bnknr];
1530                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1531                         }
1532                 }
1533         }
1534         return handled;
1535 }
1536
1537 /*****************************************************************************/
1538
1539 /*
1540  *      Interrupt service routine for ECH-PCI board types.
1541  */
1542
1543 static int stl_echpciintr(struct stlbrd *brdp)
1544 {
1545         struct stlpanel *panelp;
1546         unsigned int    ioaddr, bnknr, recheck;
1547         int             handled = 0;
1548
1549         while (1) {
1550                 recheck = 0;
1551                 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1552                         outb(brdp->bnkpageaddr[bnknr], brdp->ioctrl);
1553                         ioaddr = brdp->bnkstataddr[bnknr];
1554                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1555                                 panelp = brdp->bnk2panel[bnknr];
1556                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1557                                 recheck++;
1558                                 handled = 1;
1559                         }
1560                 }
1561                 if (! recheck)
1562                         break;
1563         }
1564         return handled;
1565 }
1566
1567 /*****************************************************************************/
1568
1569 /*
1570  *      Interrupt service routine for ECH-8/64-PCI board types.
1571  */
1572
1573 static int stl_echpci64intr(struct stlbrd *brdp)
1574 {
1575         struct stlpanel *panelp;
1576         unsigned int    ioaddr, bnknr;
1577         int             handled = 0;
1578
1579         while (inb(brdp->ioctrl) & 0x1) {
1580                 handled = 1;
1581                 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1582                         ioaddr = brdp->bnkstataddr[bnknr];
1583                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1584                                 panelp = brdp->bnk2panel[bnknr];
1585                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1586                         }
1587                 }
1588         }
1589
1590         return handled;
1591 }
1592
1593 /*****************************************************************************/
1594
1595 /*
1596  *      Initialize all the ports on a panel.
1597  */
1598
1599 static int __devinit stl_initports(struct stlbrd *brdp, struct stlpanel *panelp)
1600 {
1601         struct stlport *portp;
1602         unsigned int i;
1603         int chipmask;
1604
1605         pr_debug("stl_initports(brdp=%p,panelp=%p)\n", brdp, panelp);
1606
1607         chipmask = stl_panelinit(brdp, panelp);
1608
1609 /*
1610  *      All UART's are initialized (if found!). Now go through and setup
1611  *      each ports data structures.
1612  */
1613         for (i = 0; i < panelp->nrports; i++) {
1614                 portp = kzalloc(sizeof(struct stlport), GFP_KERNEL);
1615                 if (!portp) {
1616                         printk("STALLION: failed to allocate memory "
1617                                 "(size=%Zd)\n", sizeof(struct stlport));
1618                         break;
1619                 }
1620                 tty_port_init(&portp->port);
1621                 portp->port.ops = &stl_port_ops;
1622                 portp->magic = STL_PORTMAGIC;
1623                 portp->portnr = i;
1624                 portp->brdnr = panelp->brdnr;
1625                 portp->panelnr = panelp->panelnr;
1626                 portp->uartp = panelp->uartp;
1627                 portp->clk = brdp->clk;
1628                 portp->baud_base = STL_BAUDBASE;
1629                 portp->close_delay = STL_CLOSEDELAY;
1630                 portp->closing_wait = 30 * HZ;
1631                 init_waitqueue_head(&portp->port.open_wait);
1632                 init_waitqueue_head(&portp->port.close_wait);
1633                 portp->stats.brd = portp->brdnr;
1634                 portp->stats.panel = portp->panelnr;
1635                 portp->stats.port = portp->portnr;
1636                 panelp->ports[i] = portp;
1637                 stl_portinit(brdp, panelp, portp);
1638         }
1639
1640         return 0;
1641 }
1642
1643 static void stl_cleanup_panels(struct stlbrd *brdp)
1644 {
1645         struct stlpanel *panelp;
1646         struct stlport *portp;
1647         unsigned int j, k;
1648         struct tty_struct *tty;
1649
1650         for (j = 0; j < STL_MAXPANELS; j++) {
1651                 panelp = brdp->panels[j];
1652                 if (panelp == NULL)
1653                         continue;
1654                 for (k = 0; k < STL_PORTSPERPANEL; k++) {
1655                         portp = panelp->ports[k];
1656                         if (portp == NULL)
1657                                 continue;
1658                         tty = tty_port_tty_get(&portp->port);
1659                         if (tty != NULL) {
1660                                 stl_hangup(tty);
1661                                 tty_kref_put(tty);
1662                         }
1663                         kfree(portp->tx.buf);
1664                         kfree(portp);
1665                 }
1666                 kfree(panelp);
1667         }
1668 }
1669
1670 /*****************************************************************************/
1671
1672 /*
1673  *      Try to find and initialize an EasyIO board.
1674  */
1675
1676 static int __devinit stl_initeio(struct stlbrd *brdp)
1677 {
1678         struct stlpanel *panelp;
1679         unsigned int    status;
1680         char            *name;
1681         int             retval;
1682
1683         pr_debug("stl_initeio(brdp=%p)\n", brdp);
1684
1685         brdp->ioctrl = brdp->ioaddr1 + 1;
1686         brdp->iostatus = brdp->ioaddr1 + 2;
1687
1688         status = inb(brdp->iostatus);
1689         if ((status & EIO_IDBITMASK) == EIO_MK3)
1690                 brdp->ioctrl++;
1691
1692 /*
1693  *      Handle board specific stuff now. The real difference is PCI
1694  *      or not PCI.
1695  */
1696         if (brdp->brdtype == BRD_EASYIOPCI) {
1697                 brdp->iosize1 = 0x80;
1698                 brdp->iosize2 = 0x80;
1699                 name = "serial(EIO-PCI)";
1700                 outb(0x41, (brdp->ioaddr2 + 0x4c));
1701         } else {
1702                 brdp->iosize1 = 8;
1703                 name = "serial(EIO)";
1704                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
1705                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
1706                         printk("STALLION: invalid irq=%d for brd=%d\n",
1707                                 brdp->irq, brdp->brdnr);
1708                         retval = -EINVAL;
1709                         goto err;
1710                 }
1711                 outb((stl_vecmap[brdp->irq] | EIO_0WS |
1712                         ((brdp->irqtype) ? EIO_INTLEVEL : EIO_INTEDGE)),
1713                         brdp->ioctrl);
1714         }
1715
1716         retval = -EBUSY;
1717         if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) {
1718                 printk(KERN_WARNING "STALLION: Warning, board %d I/O address "
1719                         "%x conflicts with another device\n", brdp->brdnr, 
1720                         brdp->ioaddr1);
1721                 goto err;
1722         }
1723         
1724         if (brdp->iosize2 > 0)
1725                 if (!request_region(brdp->ioaddr2, brdp->iosize2, name)) {
1726                         printk(KERN_WARNING "STALLION: Warning, board %d I/O "
1727                                 "address %x conflicts with another device\n",
1728                                 brdp->brdnr, brdp->ioaddr2);
1729                         printk(KERN_WARNING "STALLION: Warning, also "
1730                                 "releasing board %d I/O address %x \n", 
1731                                 brdp->brdnr, brdp->ioaddr1);
1732                         goto err_rel1;
1733                 }
1734
1735 /*
1736  *      Everything looks OK, so let's go ahead and probe for the hardware.
1737  */
1738         brdp->clk = CD1400_CLK;
1739         brdp->isr = stl_eiointr;
1740
1741         retval = -ENODEV;
1742         switch (status & EIO_IDBITMASK) {
1743         case EIO_8PORTM:
1744                 brdp->clk = CD1400_CLK8M;
1745                 /* fall thru */
1746         case EIO_8PORTRS:
1747         case EIO_8PORTDI:
1748                 brdp->nrports = 8;
1749                 break;
1750         case EIO_4PORTRS:
1751                 brdp->nrports = 4;
1752                 break;
1753         case EIO_MK3:
1754                 switch (status & EIO_BRDMASK) {
1755                 case ID_BRD4:
1756                         brdp->nrports = 4;
1757                         break;
1758                 case ID_BRD8:
1759                         brdp->nrports = 8;
1760                         break;
1761                 case ID_BRD16:
1762                         brdp->nrports = 16;
1763                         break;
1764                 default:
1765                         goto err_rel2;
1766                 }
1767                 break;
1768         default:
1769                 goto err_rel2;
1770         }
1771
1772 /*
1773  *      We have verified that the board is actually present, so now we
1774  *      can complete the setup.
1775  */
1776
1777         panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL);
1778         if (!panelp) {
1779                 printk(KERN_WARNING "STALLION: failed to allocate memory "
1780                         "(size=%Zd)\n", sizeof(struct stlpanel));
1781                 retval = -ENOMEM;
1782                 goto err_rel2;
1783         }
1784
1785         panelp->magic = STL_PANELMAGIC;
1786         panelp->brdnr = brdp->brdnr;
1787         panelp->panelnr = 0;
1788         panelp->nrports = brdp->nrports;
1789         panelp->iobase = brdp->ioaddr1;
1790         panelp->hwid = status;
1791         if ((status & EIO_IDBITMASK) == EIO_MK3) {
1792                 panelp->uartp = &stl_sc26198uart;
1793                 panelp->isr = stl_sc26198intr;
1794         } else {
1795                 panelp->uartp = &stl_cd1400uart;
1796                 panelp->isr = stl_cd1400eiointr;
1797         }
1798
1799         brdp->panels[0] = panelp;
1800         brdp->nrpanels = 1;
1801         brdp->state |= BRD_FOUND;
1802         brdp->hwid = status;
1803         if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) {
1804                 printk("STALLION: failed to register interrupt "
1805                     "routine for %s irq=%d\n", name, brdp->irq);
1806                 retval = -ENODEV;
1807                 goto err_fr;
1808         }
1809
1810         return 0;
1811 err_fr:
1812         stl_cleanup_panels(brdp);
1813 err_rel2:
1814         if (brdp->iosize2 > 0)
1815                 release_region(brdp->ioaddr2, brdp->iosize2);
1816 err_rel1:
1817         release_region(brdp->ioaddr1, brdp->iosize1);
1818 err:
1819         return retval;
1820 }
1821
1822 /*****************************************************************************/
1823
1824 /*
1825  *      Try to find an ECH board and initialize it. This code is capable of
1826  *      dealing with all types of ECH board.
1827  */
1828
1829 static int __devinit stl_initech(struct stlbrd *brdp)
1830 {
1831         struct stlpanel *panelp;
1832         unsigned int    status, nxtid, ioaddr, conflict, panelnr, banknr, i;
1833         int             retval;
1834         char            *name;
1835
1836         pr_debug("stl_initech(brdp=%p)\n", brdp);
1837
1838         status = 0;
1839         conflict = 0;
1840
1841 /*
1842  *      Set up the initial board register contents for boards. This varies a
1843  *      bit between the different board types. So we need to handle each
1844  *      separately. Also do a check that the supplied IRQ is good.
1845  */
1846         switch (brdp->brdtype) {
1847
1848         case BRD_ECH:
1849                 brdp->isr = stl_echatintr;
1850                 brdp->ioctrl = brdp->ioaddr1 + 1;
1851                 brdp->iostatus = brdp->ioaddr1 + 1;
1852                 status = inb(brdp->iostatus);
1853                 if ((status & ECH_IDBITMASK) != ECH_ID) {
1854                         retval = -ENODEV;
1855                         goto err;
1856                 }
1857                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
1858                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
1859                         printk("STALLION: invalid irq=%d for brd=%d\n",
1860                                 brdp->irq, brdp->brdnr);
1861                         retval = -EINVAL;
1862                         goto err;
1863                 }
1864                 status = ((brdp->ioaddr2 & ECH_ADDR2MASK) >> 1);
1865                 status |= (stl_vecmap[brdp->irq] << 1);
1866                 outb((status | ECH_BRDRESET), brdp->ioaddr1);
1867                 brdp->ioctrlval = ECH_INTENABLE |
1868                         ((brdp->irqtype) ? ECH_INTLEVEL : ECH_INTEDGE);
1869                 for (i = 0; i < 10; i++)
1870                         outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl);
1871                 brdp->iosize1 = 2;
1872                 brdp->iosize2 = 32;
1873                 name = "serial(EC8/32)";
1874                 outb(status, brdp->ioaddr1);
1875                 break;
1876
1877         case BRD_ECHMC:
1878                 brdp->isr = stl_echmcaintr;
1879                 brdp->ioctrl = brdp->ioaddr1 + 0x20;
1880                 brdp->iostatus = brdp->ioctrl;
1881                 status = inb(brdp->iostatus);
1882                 if ((status & ECH_IDBITMASK) != ECH_ID) {
1883                         retval = -ENODEV;
1884                         goto err;
1885                 }
1886                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
1887                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
1888                         printk("STALLION: invalid irq=%d for brd=%d\n",
1889                                 brdp->irq, brdp->brdnr);
1890                         retval = -EINVAL;
1891                         goto err;
1892                 }
1893                 outb(ECHMC_BRDRESET, brdp->ioctrl);
1894                 outb(ECHMC_INTENABLE, brdp->ioctrl);
1895                 brdp->iosize1 = 64;
1896                 name = "serial(EC8/32-MC)";
1897                 break;
1898
1899         case BRD_ECHPCI:
1900                 brdp->isr = stl_echpciintr;
1901                 brdp->ioctrl = brdp->ioaddr1 + 2;
1902                 brdp->iosize1 = 4;
1903                 brdp->iosize2 = 8;
1904                 name = "serial(EC8/32-PCI)";
1905                 break;
1906
1907         case BRD_ECH64PCI:
1908                 brdp->isr = stl_echpci64intr;
1909                 brdp->ioctrl = brdp->ioaddr2 + 0x40;
1910                 outb(0x43, (brdp->ioaddr1 + 0x4c));
1911                 brdp->iosize1 = 0x80;
1912                 brdp->iosize2 = 0x80;
1913                 name = "serial(EC8/64-PCI)";
1914                 break;
1915
1916         default:
1917                 printk("STALLION: unknown board type=%d\n", brdp->brdtype);
1918                 retval = -EINVAL;
1919                 goto err;
1920         }
1921
1922 /*
1923  *      Check boards for possible IO address conflicts and return fail status 
1924  *      if an IO conflict found.
1925  */
1926         retval = -EBUSY;
1927         if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) {
1928                 printk(KERN_WARNING "STALLION: Warning, board %d I/O address "
1929                         "%x conflicts with another device\n", brdp->brdnr, 
1930                         brdp->ioaddr1);
1931                 goto err;
1932         }
1933         
1934         if (brdp->iosize2 > 0)
1935                 if (!request_region(brdp->ioaddr2, brdp->iosize2, name)) {
1936                         printk(KERN_WARNING "STALLION: Warning, board %d I/O "
1937                                 "address %x conflicts with another device\n",
1938                                 brdp->brdnr, brdp->ioaddr2);
1939                         printk(KERN_WARNING "STALLION: Warning, also "
1940                                 "releasing board %d I/O address %x \n", 
1941                                 brdp->brdnr, brdp->ioaddr1);
1942                         goto err_rel1;
1943                 }
1944
1945 /*
1946  *      Scan through the secondary io address space looking for panels.
1947  *      As we find'em allocate and initialize panel structures for each.
1948  */
1949         brdp->clk = CD1400_CLK;
1950         brdp->hwid = status;
1951
1952         ioaddr = brdp->ioaddr2;
1953         banknr = 0;
1954         panelnr = 0;
1955         nxtid = 0;
1956
1957         for (i = 0; i < STL_MAXPANELS; i++) {
1958                 if (brdp->brdtype == BRD_ECHPCI) {
1959                         outb(nxtid, brdp->ioctrl);
1960                         ioaddr = brdp->ioaddr2;
1961                 }
1962                 status = inb(ioaddr + ECH_PNLSTATUS);
1963                 if ((status & ECH_PNLIDMASK) != nxtid)
1964                         break;
1965                 panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL);
1966                 if (!panelp) {
1967                         printk("STALLION: failed to allocate memory "
1968                                 "(size=%Zd)\n", sizeof(struct stlpanel));
1969                         retval = -ENOMEM;
1970                         goto err_fr;
1971                 }
1972                 panelp->magic = STL_PANELMAGIC;
1973                 panelp->brdnr = brdp->brdnr;
1974                 panelp->panelnr = panelnr;
1975                 panelp->iobase = ioaddr;
1976                 panelp->pagenr = nxtid;
1977                 panelp->hwid = status;
1978                 brdp->bnk2panel[banknr] = panelp;
1979                 brdp->bnkpageaddr[banknr] = nxtid;
1980                 brdp->bnkstataddr[banknr++] = ioaddr + ECH_PNLSTATUS;
1981
1982                 if (status & ECH_PNLXPID) {
1983                         panelp->uartp = &stl_sc26198uart;
1984                         panelp->isr = stl_sc26198intr;
1985                         if (status & ECH_PNL16PORT) {
1986                                 panelp->nrports = 16;
1987                                 brdp->bnk2panel[banknr] = panelp;
1988                                 brdp->bnkpageaddr[banknr] = nxtid;
1989                                 brdp->bnkstataddr[banknr++] = ioaddr + 4 +
1990                                         ECH_PNLSTATUS;
1991                         } else
1992                                 panelp->nrports = 8;
1993                 } else {
1994                         panelp->uartp = &stl_cd1400uart;
1995                         panelp->isr = stl_cd1400echintr;
1996                         if (status & ECH_PNL16PORT) {
1997                                 panelp->nrports = 16;
1998                                 panelp->ackmask = 0x80;
1999                                 if (brdp->brdtype != BRD_ECHPCI)
2000                                         ioaddr += EREG_BANKSIZE;
2001                                 brdp->bnk2panel[banknr] = panelp;
2002                                 brdp->bnkpageaddr[banknr] = ++nxtid;
2003                                 brdp->bnkstataddr[banknr++] = ioaddr +
2004                                         ECH_PNLSTATUS;
2005                         } else {
2006                                 panelp->nrports = 8;
2007                                 panelp->ackmask = 0xc0;
2008                         }
2009                 }
2010
2011                 nxtid++;
2012                 ioaddr += EREG_BANKSIZE;
2013                 brdp->nrports += panelp->nrports;
2014                 brdp->panels[panelnr++] = panelp;
2015                 if ((brdp->brdtype != BRD_ECHPCI) &&
2016                     (ioaddr >= (brdp->ioaddr2 + brdp->iosize2))) {
2017                         retval = -EINVAL;
2018                         goto err_fr;
2019                 }
2020         }
2021
2022         brdp->nrpanels = panelnr;
2023         brdp->nrbnks = banknr;
2024         if (brdp->brdtype == BRD_ECH)
2025                 outb((brdp->ioctrlval | ECH_BRDDISABLE), brdp->ioctrl);
2026
2027         brdp->state |= BRD_FOUND;
2028         if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) {
2029                 printk("STALLION: failed to register interrupt "
2030                     "routine for %s irq=%d\n", name, brdp->irq);
2031                 retval = -ENODEV;
2032                 goto err_fr;
2033         }
2034
2035         return 0;
2036 err_fr:
2037         stl_cleanup_panels(brdp);
2038         if (brdp->iosize2 > 0)
2039                 release_region(brdp->ioaddr2, brdp->iosize2);
2040 err_rel1:
2041         release_region(brdp->ioaddr1, brdp->iosize1);
2042 err:
2043         return retval;
2044 }
2045
2046 /*****************************************************************************/
2047
2048 /*
2049  *      Initialize and configure the specified board.
2050  *      Scan through all the boards in the configuration and see what we
2051  *      can find. Handle EIO and the ECH boards a little differently here
2052  *      since the initial search and setup is very different.
2053  */
2054
2055 static int __devinit stl_brdinit(struct stlbrd *brdp)
2056 {
2057         int i, retval;
2058
2059         pr_debug("stl_brdinit(brdp=%p)\n", brdp);
2060
2061         switch (brdp->brdtype) {
2062         case BRD_EASYIO:
2063         case BRD_EASYIOPCI:
2064                 retval = stl_initeio(brdp);
2065                 if (retval)
2066                         goto err;
2067                 break;
2068         case BRD_ECH:
2069         case BRD_ECHMC:
2070         case BRD_ECHPCI:
2071         case BRD_ECH64PCI:
2072                 retval = stl_initech(brdp);
2073                 if (retval)
2074                         goto err;
2075                 break;
2076         default:
2077                 printk("STALLION: board=%d is unknown board type=%d\n",
2078                         brdp->brdnr, brdp->brdtype);
2079                 retval = -ENODEV;
2080                 goto err;
2081         }
2082
2083         if ((brdp->state & BRD_FOUND) == 0) {
2084                 printk("STALLION: %s board not found, board=%d io=%x irq=%d\n",
2085                         stl_brdnames[brdp->brdtype], brdp->brdnr,
2086                         brdp->ioaddr1, brdp->irq);
2087                 goto err_free;
2088         }
2089
2090         for (i = 0; i < STL_MAXPANELS; i++)
2091                 if (brdp->panels[i] != NULL)
2092                         stl_initports(brdp, brdp->panels[i]);
2093
2094         printk("STALLION: %s found, board=%d io=%x irq=%d "
2095                 "nrpanels=%d nrports=%d\n", stl_brdnames[brdp->brdtype],
2096                 brdp->brdnr, brdp->ioaddr1, brdp->irq, brdp->nrpanels,
2097                 brdp->nrports);
2098
2099         return 0;
2100 err_free:
2101         free_irq(brdp->irq, brdp);
2102
2103         stl_cleanup_panels(brdp);
2104
2105         release_region(brdp->ioaddr1, brdp->iosize1);
2106         if (brdp->iosize2 > 0)
2107                 release_region(brdp->ioaddr2, brdp->iosize2);
2108 err:
2109         return retval;
2110 }
2111
2112 /*****************************************************************************/
2113
2114 /*
2115  *      Find the next available board number that is free.
2116  */
2117
2118 static int __devinit stl_getbrdnr(void)
2119 {
2120         unsigned int i;
2121
2122         for (i = 0; i < STL_MAXBRDS; i++)
2123                 if (stl_brds[i] == NULL) {
2124                         if (i >= stl_nrbrds)
2125                                 stl_nrbrds = i + 1;
2126                         return i;
2127                 }
2128
2129         return -1;
2130 }
2131
2132 /*****************************************************************************/
2133 /*
2134  *      We have a Stallion board. Allocate a board structure and
2135  *      initialize it. Read its IO and IRQ resources from PCI
2136  *      configuration space.
2137  */
2138
2139 static int __devinit stl_pciprobe(struct pci_dev *pdev,
2140                 const struct pci_device_id *ent)
2141 {
2142         struct stlbrd *brdp;
2143         unsigned int i, brdtype = ent->driver_data;
2144         int brdnr, retval = -ENODEV;
2145
2146         if ((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE)
2147                 goto err;
2148
2149         retval = pci_enable_device(pdev);
2150         if (retval)
2151                 goto err;
2152         brdp = stl_allocbrd();
2153         if (brdp == NULL) {
2154                 retval = -ENOMEM;
2155                 goto err;
2156         }
2157         mutex_lock(&stl_brdslock);
2158         brdnr = stl_getbrdnr();
2159         if (brdnr < 0) {
2160                 dev_err(&pdev->dev, "too many boards found, "
2161                         "maximum supported %d\n", STL_MAXBRDS);
2162                 mutex_unlock(&stl_brdslock);
2163                 retval = -ENODEV;
2164                 goto err_fr;
2165         }
2166         brdp->brdnr = (unsigned int)brdnr;
2167         stl_brds[brdp->brdnr] = brdp;
2168         mutex_unlock(&stl_brdslock);
2169
2170         brdp->brdtype = brdtype;
2171         brdp->state |= STL_PROBED;
2172
2173 /*
2174  *      We have all resources from the board, so let's setup the actual
2175  *      board structure now.
2176  */
2177         switch (brdtype) {
2178         case BRD_ECHPCI:
2179                 brdp->ioaddr2 = pci_resource_start(pdev, 0);
2180                 brdp->ioaddr1 = pci_resource_start(pdev, 1);
2181                 break;
2182         case BRD_ECH64PCI:
2183                 brdp->ioaddr2 = pci_resource_start(pdev, 2);
2184                 brdp->ioaddr1 = pci_resource_start(pdev, 1);
2185                 break;
2186         case BRD_EASYIOPCI:
2187                 brdp->ioaddr1 = pci_resource_start(pdev, 2);
2188                 brdp->ioaddr2 = pci_resource_start(pdev, 1);
2189                 break;
2190         default:
2191                 dev_err(&pdev->dev, "unknown PCI board type=%u\n", brdtype);
2192                 break;
2193         }
2194
2195         brdp->irq = pdev->irq;
2196         retval = stl_brdinit(brdp);
2197         if (retval)
2198                 goto err_null;
2199
2200         pci_set_drvdata(pdev, brdp);
2201
2202         for (i = 0; i < brdp->nrports; i++)
2203                 tty_register_device(stl_serial,
2204                                 brdp->brdnr * STL_MAXPORTS + i, &pdev->dev);
2205
2206         return 0;
2207 err_null:
2208         stl_brds[brdp->brdnr] = NULL;
2209 err_fr:
2210         kfree(brdp);
2211 err:
2212         return retval;
2213 }
2214
2215 static void __devexit stl_pciremove(struct pci_dev *pdev)
2216 {
2217         struct stlbrd *brdp = pci_get_drvdata(pdev);
2218         unsigned int i;
2219
2220         free_irq(brdp->irq, brdp);
2221
2222         stl_cleanup_panels(brdp);
2223
2224         release_region(brdp->ioaddr1, brdp->iosize1);
2225         if (brdp->iosize2 > 0)
2226                 release_region(brdp->ioaddr2, brdp->iosize2);
2227
2228         for (i = 0; i < brdp->nrports; i++)
2229                 tty_unregister_device(stl_serial,
2230                                 brdp->brdnr * STL_MAXPORTS + i);
2231
2232         stl_brds[brdp->brdnr] = NULL;
2233         kfree(brdp);
2234 }
2235
2236 static struct pci_driver stl_pcidriver = {
2237         .name = "stallion",
2238         .id_table = stl_pcibrds,
2239         .probe = stl_pciprobe,
2240         .remove = __devexit_p(stl_pciremove)
2241 };
2242
2243 /*****************************************************************************/
2244
2245 /*
2246  *      Return the board stats structure to user app.
2247  */
2248
2249 static int stl_getbrdstats(combrd_t __user *bp)
2250 {
2251         combrd_t        stl_brdstats;
2252         struct stlbrd   *brdp;
2253         struct stlpanel *panelp;
2254         unsigned int i;
2255
2256         if (copy_from_user(&stl_brdstats, bp, sizeof(combrd_t)))
2257                 return -EFAULT;
2258         if (stl_brdstats.brd >= STL_MAXBRDS)
2259                 return -ENODEV;
2260         brdp = stl_brds[stl_brdstats.brd];
2261         if (brdp == NULL)
2262                 return -ENODEV;
2263
2264         memset(&stl_brdstats, 0, sizeof(combrd_t));
2265         stl_brdstats.brd = brdp->brdnr;
2266         stl_brdstats.type = brdp->brdtype;
2267         stl_brdstats.hwid = brdp->hwid;
2268         stl_brdstats.state = brdp->state;
2269         stl_brdstats.ioaddr = brdp->ioaddr1;
2270         stl_brdstats.ioaddr2 = brdp->ioaddr2;
2271         stl_brdstats.irq = brdp->irq;
2272         stl_brdstats.nrpanels = brdp->nrpanels;
2273         stl_brdstats.nrports = brdp->nrports;
2274         for (i = 0; i < brdp->nrpanels; i++) {
2275                 panelp = brdp->panels[i];
2276                 stl_brdstats.panels[i].panel = i;
2277                 stl_brdstats.panels[i].hwid = panelp->hwid;
2278                 stl_brdstats.panels[i].nrports = panelp->nrports;
2279         }
2280
2281         return copy_to_user(bp, &stl_brdstats, sizeof(combrd_t)) ? -EFAULT : 0;
2282 }
2283
2284 /*****************************************************************************/
2285
2286 /*
2287  *      Resolve the referenced port number into a port struct pointer.
2288  */
2289
2290 static struct stlport *stl_getport(int brdnr, int panelnr, int portnr)
2291 {
2292         struct stlbrd   *brdp;
2293         struct stlpanel *panelp;
2294
2295         if (brdnr < 0 || brdnr >= STL_MAXBRDS)
2296                 return NULL;
2297         brdp = stl_brds[brdnr];
2298         if (brdp == NULL)
2299                 return NULL;
2300         if (panelnr < 0 || (unsigned int)panelnr >= brdp->nrpanels)
2301                 return NULL;
2302         panelp = brdp->panels[panelnr];
2303         if (panelp == NULL)
2304                 return NULL;
2305         if (portnr < 0 || (unsigned int)portnr >= panelp->nrports)
2306                 return NULL;
2307         return panelp->ports[portnr];
2308 }
2309
2310 /*****************************************************************************/
2311
2312 /*
2313  *      Return the port stats structure to user app. A NULL port struct
2314  *      pointer passed in means that we need to find out from the app
2315  *      what port to get stats for (used through board control device).
2316  */
2317
2318 static int stl_getportstats(struct tty_struct *tty, struct stlport *portp, comstats_t __user *cp)
2319 {
2320         comstats_t      stl_comstats;
2321         unsigned char   *head, *tail;
2322         unsigned long   flags;
2323
2324         if (!portp) {
2325                 if (copy_from_user(&stl_comstats, cp, sizeof(comstats_t)))
2326                         return -EFAULT;
2327                 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2328                         stl_comstats.port);
2329                 if (portp == NULL)
2330                         return -ENODEV;
2331         }
2332
2333         mutex_lock(&portp->port.mutex);
2334         portp->stats.state = portp->istate;
2335         portp->stats.flags = portp->port.flags;
2336         portp->stats.hwid = portp->hwid;
2337
2338         portp->stats.ttystate = 0;
2339         portp->stats.cflags = 0;
2340         portp->stats.iflags = 0;
2341         portp->stats.oflags = 0;
2342         portp->stats.lflags = 0;
2343         portp->stats.rxbuffered = 0;
2344
2345         spin_lock_irqsave(&stallion_lock, flags);
2346         if (tty != NULL && portp->port.tty == tty) {
2347                 portp->stats.ttystate = tty->flags;
2348                 /* No longer available as a statistic */
2349                 portp->stats.rxbuffered = 1; /*tty->flip.count; */
2350                 if (tty->termios != NULL) {
2351                         portp->stats.cflags = tty->termios->c_cflag;
2352                         portp->stats.iflags = tty->termios->c_iflag;
2353                         portp->stats.oflags = tty->termios->c_oflag;
2354                         portp->stats.lflags = tty->termios->c_lflag;
2355                 }
2356         }
2357         spin_unlock_irqrestore(&stallion_lock, flags);
2358
2359         head = portp->tx.head;
2360         tail = portp->tx.tail;
2361         portp->stats.txbuffered = (head >= tail) ? (head - tail) :
2362                 (STL_TXBUFSIZE - (tail - head));
2363
2364         portp->stats.signals = (unsigned long) stl_getsignals(portp);
2365         mutex_unlock(&portp->port.mutex);
2366
2367         return copy_to_user(cp, &portp->stats,
2368                             sizeof(comstats_t)) ? -EFAULT : 0;
2369 }
2370
2371 /*****************************************************************************/
2372
2373 /*
2374  *      Clear the port stats structure. We also return it zeroed out...
2375  */
2376
2377 static int stl_clrportstats(struct stlport *portp, comstats_t __user *cp)
2378 {
2379         comstats_t      stl_comstats;
2380
2381         if (!portp) {
2382                 if (copy_from_user(&stl_comstats, cp, sizeof(comstats_t)))
2383                         return -EFAULT;
2384                 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2385                         stl_comstats.port);
2386                 if (portp == NULL)
2387                         return -ENODEV;
2388         }
2389
2390         mutex_lock(&portp->port.mutex);
2391         memset(&portp->stats, 0, sizeof(comstats_t));
2392         portp->stats.brd = portp->brdnr;
2393         portp->stats.panel = portp->panelnr;
2394         portp->stats.port = portp->portnr;
2395         mutex_unlock(&portp->port.mutex);
2396         return copy_to_user(cp, &portp->stats,
2397                             sizeof(comstats_t)) ? -EFAULT : 0;
2398 }
2399
2400 /*****************************************************************************/
2401
2402 /*
2403  *      Return the entire driver ports structure to a user app.
2404  */
2405
2406 static int stl_getportstruct(struct stlport __user *arg)
2407 {
2408         struct stlport  stl_dummyport;
2409         struct stlport  *portp;
2410
2411         if (copy_from_user(&stl_dummyport, arg, sizeof(struct stlport)))
2412                 return -EFAULT;
2413         portp = stl_getport(stl_dummyport.brdnr, stl_dummyport.panelnr,
2414                  stl_dummyport.portnr);
2415         if (!portp)
2416                 return -ENODEV;
2417         return copy_to_user(arg, portp, sizeof(struct stlport)) ? -EFAULT : 0;
2418 }
2419
2420 /*****************************************************************************/
2421
2422 /*
2423  *      Return the entire driver board structure to a user app.
2424  */
2425
2426 static int stl_getbrdstruct(struct stlbrd __user *arg)
2427 {
2428         struct stlbrd   stl_dummybrd;
2429         struct stlbrd   *brdp;
2430
2431         if (copy_from_user(&stl_dummybrd, arg, sizeof(struct stlbrd)))
2432                 return -EFAULT;
2433         if (stl_dummybrd.brdnr >= STL_MAXBRDS)
2434                 return -ENODEV;
2435         brdp = stl_brds[stl_dummybrd.brdnr];
2436         if (!brdp)
2437                 return -ENODEV;
2438         return copy_to_user(arg, brdp, sizeof(struct stlbrd)) ? -EFAULT : 0;
2439 }
2440
2441 /*****************************************************************************/
2442
2443 /*
2444  *      The "staliomem" device is also required to do some special operations
2445  *      on the board and/or ports. In this driver it is mostly used for stats
2446  *      collection.
2447  */
2448
2449 static long stl_memioctl(struct file *fp, unsigned int cmd, unsigned long arg)
2450 {
2451         int     brdnr, rc;
2452         void __user *argp = (void __user *)arg;
2453
2454         pr_debug("stl_memioctl(fp=%p,cmd=%x,arg=%lx)\n", fp, cmd,arg);
2455
2456         brdnr = iminor(fp->f_dentry->d_inode);
2457         if (brdnr >= STL_MAXBRDS)
2458                 return -ENODEV;
2459         rc = 0;
2460
2461         switch (cmd) {
2462         case COM_GETPORTSTATS:
2463                 rc = stl_getportstats(NULL, NULL, argp);
2464                 break;
2465         case COM_CLRPORTSTATS:
2466                 rc = stl_clrportstats(NULL, argp);
2467                 break;
2468         case COM_GETBRDSTATS:
2469                 rc = stl_getbrdstats(argp);
2470                 break;
2471         case COM_READPORT:
2472                 rc = stl_getportstruct(argp);
2473                 break;
2474         case COM_READBOARD:
2475                 rc = stl_getbrdstruct(argp);
2476                 break;
2477         default:
2478                 rc = -ENOIOCTLCMD;
2479                 break;
2480         }
2481         return rc;
2482 }
2483
2484 static const struct tty_operations stl_ops = {
2485         .open = stl_open,
2486         .close = stl_close,
2487         .write = stl_write,
2488         .put_char = stl_putchar,
2489         .flush_chars = stl_flushchars,
2490         .write_room = stl_writeroom,
2491         .chars_in_buffer = stl_charsinbuffer,
2492         .ioctl = stl_ioctl,
2493         .set_termios = stl_settermios,
2494         .throttle = stl_throttle,
2495         .unthrottle = stl_unthrottle,
2496         .stop = stl_stop,
2497         .start = stl_start,
2498         .hangup = stl_hangup,
2499         .flush_buffer = stl_flushbuffer,
2500         .break_ctl = stl_breakctl,
2501         .wait_until_sent = stl_waituntilsent,
2502         .send_xchar = stl_sendxchar,
2503         .tiocmget = stl_tiocmget,
2504         .tiocmset = stl_tiocmset,
2505         .proc_fops = &stl_proc_fops,
2506 };
2507
2508 static const struct tty_port_operations stl_port_ops = {
2509         .carrier_raised = stl_carrier_raised,
2510         .dtr_rts = stl_dtr_rts,
2511         .activate = stl_activate,
2512         .shutdown = stl_shutdown,
2513 };
2514
2515 /*****************************************************************************/
2516 /*                       CD1400 HARDWARE FUNCTIONS                           */
2517 /*****************************************************************************/
2518
2519 /*
2520  *      These functions get/set/update the registers of the cd1400 UARTs.
2521  *      Access to the cd1400 registers is via an address/data io port pair.
2522  *      (Maybe should make this inline...)
2523  */
2524
2525 static int stl_cd1400getreg(struct stlport *portp, int regnr)
2526 {
2527         outb((regnr + portp->uartaddr), portp->ioaddr);
2528         return inb(portp->ioaddr + EREG_DATA);
2529 }
2530
2531 static void stl_cd1400setreg(struct stlport *portp, int regnr, int value)
2532 {
2533         outb(regnr + portp->uartaddr, portp->ioaddr);
2534         outb(value, portp->ioaddr + EREG_DATA);
2535 }
2536
2537 static int stl_cd1400updatereg(struct stlport *portp, int regnr, int value)
2538 {
2539         outb(regnr + portp->uartaddr, portp->ioaddr);
2540         if (inb(portp->ioaddr + EREG_DATA) != value) {
2541                 outb(value, portp->ioaddr + EREG_DATA);
2542                 return 1;
2543         }
2544         return 0;
2545 }
2546
2547 /*****************************************************************************/
2548
2549 /*
2550  *      Inbitialize the UARTs in a panel. We don't care what sort of board
2551  *      these ports are on - since the port io registers are almost
2552  *      identical when dealing with ports.
2553  */
2554
2555 static int stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp)
2556 {
2557         unsigned int    gfrcr;
2558         int             chipmask, i, j;
2559         int             nrchips, uartaddr, ioaddr;
2560         unsigned long   flags;
2561
2562         pr_debug("stl_panelinit(brdp=%p,panelp=%p)\n", brdp, panelp);
2563
2564         spin_lock_irqsave(&brd_lock, flags);
2565         BRDENABLE(panelp->brdnr, panelp->pagenr);
2566
2567 /*
2568  *      Check that each chip is present and started up OK.
2569  */
2570         chipmask = 0;
2571         nrchips = panelp->nrports / CD1400_PORTS;
2572         for (i = 0; i < nrchips; i++) {
2573                 if (brdp->brdtype == BRD_ECHPCI) {
2574                         outb((panelp->pagenr + (i >> 1)), brdp->ioctrl);
2575                         ioaddr = panelp->iobase;
2576                 } else
2577                         ioaddr = panelp->iobase + (EREG_BANKSIZE * (i >> 1));
2578                 uartaddr = (i & 0x01) ? 0x080 : 0;
2579                 outb((GFRCR + uartaddr), ioaddr);
2580                 outb(0, (ioaddr + EREG_DATA));
2581                 outb((CCR + uartaddr), ioaddr);
2582                 outb(CCR_RESETFULL, (ioaddr + EREG_DATA));
2583                 outb(CCR_RESETFULL, (ioaddr + EREG_DATA));
2584                 outb((GFRCR + uartaddr), ioaddr);
2585                 for (j = 0; j < CCR_MAXWAIT; j++)
2586                         if ((gfrcr = inb(ioaddr + EREG_DATA)) != 0)
2587                                 break;
2588
2589                 if ((j >= CCR_MAXWAIT) || (gfrcr < 0x40) || (gfrcr > 0x60)) {
2590                         printk("STALLION: cd1400 not responding, "
2591                                 "brd=%d panel=%d chip=%d\n",
2592                                 panelp->brdnr, panelp->panelnr, i);
2593                         continue;
2594                 }
2595                 chipmask |= (0x1 << i);
2596                 outb((PPR + uartaddr), ioaddr);
2597                 outb(PPR_SCALAR, (ioaddr + EREG_DATA));
2598         }
2599
2600         BRDDISABLE(panelp->brdnr);
2601         spin_unlock_irqrestore(&brd_lock, flags);
2602         return chipmask;
2603 }
2604
2605 /*****************************************************************************/
2606
2607 /*
2608  *      Initialize hardware specific port registers.
2609  */
2610
2611 static void stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp)
2612 {
2613         unsigned long flags;
2614         pr_debug("stl_cd1400portinit(brdp=%p,panelp=%p,portp=%p)\n", brdp,
2615                         panelp, portp);
2616
2617         if ((brdp == NULL) || (panelp == NULL) ||
2618             (portp == NULL))
2619                 return;
2620
2621         spin_lock_irqsave(&brd_lock, flags);
2622         portp->ioaddr = panelp->iobase + (((brdp->brdtype == BRD_ECHPCI) ||
2623                 (portp->portnr < 8)) ? 0 : EREG_BANKSIZE);
2624         portp->uartaddr = (portp->portnr & 0x04) << 5;
2625         portp->pagenr = panelp->pagenr + (portp->portnr >> 3);
2626
2627         BRDENABLE(portp->brdnr, portp->pagenr);
2628         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2629         stl_cd1400setreg(portp, LIVR, (portp->portnr << 3));
2630         portp->hwid = stl_cd1400getreg(portp, GFRCR);
2631         BRDDISABLE(portp->brdnr);
2632         spin_unlock_irqrestore(&brd_lock, flags);
2633 }
2634
2635 /*****************************************************************************/
2636
2637 /*
2638  *      Wait for the command register to be ready. We will poll this,
2639  *      since it won't usually take too long to be ready.
2640  */
2641
2642 static void stl_cd1400ccrwait(struct stlport *portp)
2643 {
2644         int     i;
2645
2646         for (i = 0; i < CCR_MAXWAIT; i++)
2647                 if (stl_cd1400getreg(portp, CCR) == 0)
2648                         return;
2649
2650         printk("STALLION: cd1400 not responding, port=%d panel=%d brd=%d\n",
2651                 portp->portnr, portp->panelnr, portp->brdnr);
2652 }
2653
2654 /*****************************************************************************/
2655
2656 /*
2657  *      Set up the cd1400 registers for a port based on the termios port
2658  *      settings.
2659  */
2660
2661 static void stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp)
2662 {
2663         struct stlbrd   *brdp;
2664         unsigned long   flags;
2665         unsigned int    clkdiv, baudrate;
2666         unsigned char   cor1, cor2, cor3;
2667         unsigned char   cor4, cor5, ccr;
2668         unsigned char   srer, sreron, sreroff;
2669         unsigned char   mcor1, mcor2, rtpr;
2670         unsigned char   clk, div;
2671
2672         cor1 = 0;
2673         cor2 = 0;
2674         cor3 = 0;
2675         cor4 = 0;
2676         cor5 = 0;
2677         ccr = 0;
2678         rtpr = 0;
2679         clk = 0;
2680         div = 0;
2681         mcor1 = 0;
2682         mcor2 = 0;
2683         sreron = 0;
2684         sreroff = 0;
2685
2686         brdp = stl_brds[portp->brdnr];
2687         if (brdp == NULL)
2688                 return;
2689
2690 /*
2691  *      Set up the RX char ignore mask with those RX error types we
2692  *      can ignore. We can get the cd1400 to help us out a little here,
2693  *      it will ignore parity errors and breaks for us.
2694  */
2695         portp->rxignoremsk = 0;
2696         if (tiosp->c_iflag & IGNPAR) {
2697                 portp->rxignoremsk |= (ST_PARITY | ST_FRAMING | ST_OVERRUN);
2698                 cor1 |= COR1_PARIGNORE;
2699         }
2700         if (tiosp->c_iflag & IGNBRK) {
2701                 portp->rxignoremsk |= ST_BREAK;
2702                 cor4 |= COR4_IGNBRK;
2703         }
2704
2705         portp->rxmarkmsk = ST_OVERRUN;
2706         if (tiosp->c_iflag & (INPCK | PARMRK))
2707                 portp->rxmarkmsk |= (ST_PARITY | ST_FRAMING);
2708         if (tiosp->c_iflag & BRKINT)
2709                 portp->rxmarkmsk |= ST_BREAK;
2710
2711 /*
2712  *      Go through the char size, parity and stop bits and set all the
2713  *      option register appropriately.
2714  */
2715         switch (tiosp->c_cflag & CSIZE) {
2716         case CS5:
2717                 cor1 |= COR1_CHL5;
2718                 break;
2719         case CS6:
2720                 cor1 |= COR1_CHL6;
2721                 break;
2722         case CS7:
2723                 cor1 |= COR1_CHL7;
2724                 break;
2725         default:
2726                 cor1 |= COR1_CHL8;
2727                 break;
2728         }
2729
2730         if (tiosp->c_cflag & CSTOPB)
2731                 cor1 |= COR1_STOP2;
2732         else
2733                 cor1 |= COR1_STOP1;
2734
2735         if (tiosp->c_cflag & PARENB) {
2736                 if (tiosp->c_cflag & PARODD)
2737                         cor1 |= (COR1_PARENB | COR1_PARODD);
2738                 else
2739                         cor1 |= (COR1_PARENB | COR1_PAREVEN);
2740         } else {
2741                 cor1 |= COR1_PARNONE;
2742         }
2743
2744 /*
2745  *      Set the RX FIFO threshold at 6 chars. This gives a bit of breathing
2746  *      space for hardware flow control and the like. This should be set to
2747  *      VMIN. Also here we will set the RX data timeout to 10ms - this should
2748  *      really be based on VTIME.
2749  */
2750         cor3 |= FIFO_RXTHRESHOLD;
2751         rtpr = 2;
2752
2753 /*
2754  *      Calculate the baud rate timers. For now we will just assume that
2755  *      the input and output baud are the same. Could have used a baud
2756  *      table here, but this way we can generate virtually any baud rate
2757  *      we like!
2758  */
2759         baudrate = tiosp->c_cflag & CBAUD;
2760         if (baudrate & CBAUDEX) {
2761                 baudrate &= ~CBAUDEX;
2762                 if ((baudrate < 1) || (baudrate > 4))
2763                         tiosp->c_cflag &= ~CBAUDEX;
2764                 else
2765                         baudrate += 15;
2766         }
2767         baudrate = stl_baudrates[baudrate];
2768         if ((tiosp->c_cflag & CBAUD) == B38400) {
2769                 if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2770                         baudrate = 57600;
2771                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2772                         baudrate = 115200;
2773                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2774                         baudrate = 230400;
2775                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2776                         baudrate = 460800;
2777                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
2778                         baudrate = (portp->baud_base / portp->custom_divisor);
2779         }
2780         if (baudrate > STL_CD1400MAXBAUD)
2781                 baudrate = STL_CD1400MAXBAUD;
2782
2783         if (baudrate > 0) {
2784                 for (clk = 0; clk < CD1400_NUMCLKS; clk++) {
2785                         clkdiv = (portp->clk / stl_cd1400clkdivs[clk]) / baudrate;
2786                         if (clkdiv < 0x100)
2787                                 break;
2788                 }
2789                 div = (unsigned char) clkdiv;
2790         }
2791
2792 /*
2793  *      Check what form of modem signaling is required and set it up.
2794  */
2795         if ((tiosp->c_cflag & CLOCAL) == 0) {
2796                 mcor1 |= MCOR1_DCD;
2797                 mcor2 |= MCOR2_DCD;
2798                 sreron |= SRER_MODEM;
2799                 portp->port.flags |= ASYNC_CHECK_CD;
2800         } else
2801                 portp->port.flags &= ~ASYNC_CHECK_CD;
2802
2803 /*
2804  *      Setup cd1400 enhanced modes if we can. In particular we want to
2805  *      handle as much of the flow control as possible automatically. As
2806  *      well as saving a few CPU cycles it will also greatly improve flow
2807  *      control reliability.
2808  */
2809         if (tiosp->c_iflag & IXON) {
2810                 cor2 |= COR2_TXIBE;
2811                 cor3 |= COR3_SCD12;
2812                 if (tiosp->c_iflag & IXANY)
2813                         cor2 |= COR2_IXM;
2814         }
2815
2816         if (tiosp->c_cflag & CRTSCTS) {
2817                 cor2 |= COR2_CTSAE;
2818                 mcor1 |= FIFO_RTSTHRESHOLD;
2819         }
2820
2821 /*
2822  *      All cd1400 register values calculated so go through and set
2823  *      them all up.
2824  */
2825
2826         pr_debug("SETPORT: portnr=%d panelnr=%d brdnr=%d\n",
2827                 portp->portnr, portp->panelnr, portp->brdnr);
2828         pr_debug("    cor1=%x cor2=%x cor3=%x cor4=%x cor5=%x\n",
2829                 cor1, cor2, cor3, cor4, cor5);
2830         pr_debug("    mcor1=%x mcor2=%x rtpr=%x sreron=%x sreroff=%x\n",
2831                 mcor1, mcor2, rtpr, sreron, sreroff);
2832         pr_debug("    tcor=%x tbpr=%x rcor=%x rbpr=%x\n", clk, div, clk, div);
2833         pr_debug("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
2834                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP],
2835                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
2836
2837         spin_lock_irqsave(&brd_lock, flags);
2838         BRDENABLE(portp->brdnr, portp->pagenr);
2839         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
2840         srer = stl_cd1400getreg(portp, SRER);
2841         stl_cd1400setreg(portp, SRER, 0);
2842         if (stl_cd1400updatereg(portp, COR1, cor1))
2843                 ccr = 1;
2844         if (stl_cd1400updatereg(portp, COR2, cor2))
2845                 ccr = 1;
2846         if (stl_cd1400updatereg(portp, COR3, cor3))
2847                 ccr = 1;
2848         if (ccr) {
2849                 stl_cd1400ccrwait(portp);
2850                 stl_cd1400setreg(portp, CCR, CCR_CORCHANGE);
2851         }
2852         stl_cd1400setreg(portp, COR4, cor4);
2853         stl_cd1400setreg(portp, COR5, cor5);
2854         stl_cd1400setreg(portp, MCOR1, mcor1);
2855         stl_cd1400setreg(portp, MCOR2, mcor2);
2856         if (baudrate > 0) {
2857                 stl_cd1400setreg(portp, TCOR, clk);
2858                 stl_cd1400setreg(portp, TBPR, div);
2859                 stl_cd1400setreg(portp, RCOR, clk);
2860                 stl_cd1400setreg(portp, RBPR, div);
2861         }
2862         stl_cd1400setreg(portp, SCHR1, tiosp->c_cc[VSTART]);
2863         stl_cd1400setreg(portp, SCHR2, tiosp->c_cc[VSTOP]);
2864         stl_cd1400setreg(portp, SCHR3, tiosp->c_cc[VSTART]);
2865         stl_cd1400setreg(portp, SCHR4, tiosp->c_cc[VSTOP]);
2866         stl_cd1400setreg(portp, RTPR, rtpr);
2867         mcor1 = stl_cd1400getreg(portp, MSVR1);
2868         if (mcor1 & MSVR1_DCD)
2869                 portp->sigs |= TIOCM_CD;
2870         else
2871                 portp->sigs &= ~TIOCM_CD;
2872         stl_cd1400setreg(portp, SRER, ((srer & ~sreroff) | sreron));
2873         BRDDISABLE(portp->brdnr);
2874         spin_unlock_irqrestore(&brd_lock, flags);
2875 }
2876
2877 /*****************************************************************************/
2878
2879 /*
2880  *      Set the state of the DTR and RTS signals.
2881  */
2882
2883 static void stl_cd1400setsignals(struct stlport *portp, int dtr, int rts)
2884 {
2885         unsigned char   msvr1, msvr2;
2886         unsigned long   flags;
2887
2888         pr_debug("stl_cd1400setsignals(portp=%p,dtr=%d,rts=%d)\n",
2889                         portp, dtr, rts);
2890
2891         msvr1 = 0;
2892         msvr2 = 0;
2893         if (dtr > 0)
2894                 msvr1 = MSVR1_DTR;
2895         if (rts > 0)
2896                 msvr2 = MSVR2_RTS;
2897
2898         spin_lock_irqsave(&brd_lock, flags);
2899         BRDENABLE(portp->brdnr, portp->pagenr);
2900         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2901         if (rts >= 0)
2902                 stl_cd1400setreg(portp, MSVR2, msvr2);
2903         if (dtr >= 0)
2904                 stl_cd1400setreg(portp, MSVR1, msvr1);
2905         BRDDISABLE(portp->brdnr);
2906         spin_unlock_irqrestore(&brd_lock, flags);
2907 }
2908
2909 /*****************************************************************************/
2910
2911 /*
2912  *      Return the state of the signals.
2913  */
2914
2915 static int stl_cd1400getsignals(struct stlport *portp)
2916 {
2917         unsigned char   msvr1, msvr2;
2918         unsigned long   flags;
2919         int             sigs;
2920
2921         pr_debug("stl_cd1400getsignals(portp=%p)\n", portp);
2922
2923         spin_lock_irqsave(&brd_lock, flags);
2924         BRDENABLE(portp->brdnr, portp->pagenr);
2925         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2926         msvr1 = stl_cd1400getreg(portp, MSVR1);
2927         msvr2 = stl_cd1400getreg(portp, MSVR2);
2928         BRDDISABLE(portp->brdnr);
2929         spin_unlock_irqrestore(&brd_lock, flags);
2930
2931         sigs = 0;
2932         sigs |= (msvr1 & MSVR1_DCD) ? TIOCM_CD : 0;
2933         sigs |= (msvr1 & MSVR1_CTS) ? TIOCM_CTS : 0;
2934         sigs |= (msvr1 & MSVR1_DTR) ? TIOCM_DTR : 0;
2935         sigs |= (msvr2 & MSVR2_RTS) ? TIOCM_RTS : 0;
2936 #if 0
2937         sigs |= (msvr1 & MSVR1_RI) ? TIOCM_RI : 0;
2938         sigs |= (msvr1 & MSVR1_DSR) ? TIOCM_DSR : 0;
2939 #else
2940         sigs |= TIOCM_DSR;
2941 #endif
2942         return sigs;
2943 }
2944
2945 /*****************************************************************************/
2946
2947 /*
2948  *      Enable/Disable the Transmitter and/or Receiver.
2949  */
2950
2951 static void stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx)
2952 {
2953         unsigned char   ccr;
2954         unsigned long   flags;
2955
2956         pr_debug("stl_cd1400enablerxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
2957
2958         ccr = 0;
2959
2960         if (tx == 0)
2961                 ccr |= CCR_TXDISABLE;
2962         else if (tx > 0)
2963                 ccr |= CCR_TXENABLE;
2964         if (rx == 0)
2965                 ccr |= CCR_RXDISABLE;
2966         else if (rx > 0)
2967                 ccr |= CCR_RXENABLE;
2968
2969         spin_lock_irqsave(&brd_lock, flags);
2970         BRDENABLE(portp->brdnr, portp->pagenr);
2971         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2972         stl_cd1400ccrwait(portp);
2973         stl_cd1400setreg(portp, CCR, ccr);
2974         stl_cd1400ccrwait(portp);
2975         BRDDISABLE(portp->brdnr);
2976         spin_unlock_irqrestore(&brd_lock, flags);
2977 }
2978
2979 /*****************************************************************************/
2980
2981 /*
2982  *      Start/stop the Transmitter and/or Receiver.
2983  */
2984
2985 static void stl_cd1400startrxtx(struct stlport *portp, int rx, int tx)
2986 {
2987         unsigned char   sreron, sreroff;
2988         unsigned long   flags;
2989
2990         pr_debug("stl_cd1400startrxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
2991
2992         sreron = 0;
2993         sreroff = 0;
2994         if (tx == 0)
2995                 sreroff |= (SRER_TXDATA | SRER_TXEMPTY);
2996         else if (tx == 1)
2997                 sreron |= SRER_TXDATA;
2998         else if (tx >= 2)
2999                 sreron |= SRER_TXEMPTY;
3000         if (rx == 0)
3001                 sreroff |= SRER_RXDATA;
3002         else if (rx > 0)
3003                 sreron |= SRER_RXDATA;
3004
3005         spin_lock_irqsave(&brd_lock, flags);
3006         BRDENABLE(portp->brdnr, portp->pagenr);
3007         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3008         stl_cd1400setreg(portp, SRER,
3009                 ((stl_cd1400getreg(portp, SRER) & ~sreroff) | sreron));
3010         BRDDISABLE(portp->brdnr);
3011         if (tx > 0)
3012                 set_bit(ASYI_TXBUSY, &portp->istate);
3013         spin_unlock_irqrestore(&brd_lock, flags);
3014 }
3015
3016 /*****************************************************************************/
3017
3018 /*
3019  *      Disable all interrupts from this port.
3020  */
3021
3022 static void stl_cd1400disableintrs(struct stlport *portp)
3023 {
3024         unsigned long   flags;
3025
3026         pr_debug("stl_cd1400disableintrs(portp=%p)\n", portp);
3027
3028         spin_lock_irqsave(&brd_lock, flags);
3029         BRDENABLE(portp->brdnr, portp->pagenr);
3030         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3031         stl_cd1400setreg(portp, SRER, 0);
3032         BRDDISABLE(portp->brdnr);
3033         spin_unlock_irqrestore(&brd_lock, flags);
3034 }
3035
3036 /*****************************************************************************/
3037
3038 static void stl_cd1400sendbreak(struct stlport *portp, int len)
3039 {
3040         unsigned long   flags;
3041
3042         pr_debug("stl_cd1400sendbreak(portp=%p,len=%d)\n", portp, len);
3043
3044         spin_lock_irqsave(&brd_lock, flags);
3045         BRDENABLE(portp->brdnr, portp->pagenr);
3046         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3047         stl_cd1400setreg(portp, SRER,
3048                 ((stl_cd1400getreg(portp, SRER) & ~SRER_TXDATA) |
3049                 SRER_TXEMPTY));
3050         BRDDISABLE(portp->brdnr);
3051         portp->brklen = len;
3052         if (len == 1)
3053                 portp->stats.txbreaks++;
3054         spin_unlock_irqrestore(&brd_lock, flags);
3055 }
3056
3057 /*****************************************************************************/
3058
3059 /*
3060  *      Take flow control actions...
3061  */
3062
3063 static void stl_cd1400flowctrl(struct stlport *portp, int state)
3064 {
3065         struct tty_struct       *tty;
3066         unsigned long           flags;
3067
3068         pr_debug("stl_cd1400flowctrl(portp=%p,state=%x)\n", portp, state);
3069
3070         if (portp == NULL)
3071                 return;
3072         tty = tty_port_tty_get(&portp->port);
3073         if (tty == NULL)
3074                 return;
3075
3076         spin_lock_irqsave(&brd_lock, flags);
3077         BRDENABLE(portp->brdnr, portp->pagenr);
3078         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3079
3080         if (state) {
3081                 if (tty->termios->c_iflag & IXOFF) {
3082                         stl_cd1400ccrwait(portp);
3083                         stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1);
3084                         portp->stats.rxxon++;
3085                         stl_cd1400ccrwait(portp);
3086                 }
3087 /*
3088  *              Question: should we return RTS to what it was before? It may
3089  *              have been set by an ioctl... Suppose not, since if you have
3090  *              hardware flow control set then it is pretty silly to go and
3091  *              set the RTS line by hand.
3092  */
3093                 if (tty->termios->c_cflag & CRTSCTS) {
3094                         stl_cd1400setreg(portp, MCOR1,
3095                                 (stl_cd1400getreg(portp, MCOR1) |
3096                                 FIFO_RTSTHRESHOLD));
3097                         stl_cd1400setreg(portp, MSVR2, MSVR2_RTS);
3098                         portp->stats.rxrtson++;
3099                 }
3100         } else {
3101                 if (tty->termios->c_iflag & IXOFF) {
3102                         stl_cd1400ccrwait(portp);
3103                         stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2);
3104                         portp->stats.rxxoff++;
3105                         stl_cd1400ccrwait(portp);
3106                 }
3107                 if (tty->termios->c_cflag & CRTSCTS) {
3108                         stl_cd1400setreg(portp, MCOR1,
3109                                 (stl_cd1400getreg(portp, MCOR1) & 0xf0));
3110                         stl_cd1400setreg(portp, MSVR2, 0);
3111                         portp->stats.rxrtsoff++;
3112                 }
3113         }
3114
3115         BRDDISABLE(portp->brdnr);
3116         spin_unlock_irqrestore(&brd_lock, flags);
3117         tty_kref_put(tty);
3118 }
3119
3120 /*****************************************************************************/
3121
3122 /*
3123  *      Send a flow control character...
3124  */
3125
3126 static void stl_cd1400sendflow(struct stlport *portp, int state)
3127 {
3128         struct tty_struct       *tty;
3129         unsigned long           flags;
3130
3131         pr_debug("stl_cd1400sendflow(portp=%p,state=%x)\n", portp, state);
3132
3133         if (portp == NULL)
3134                 return;
3135         tty = tty_port_tty_get(&portp->port);
3136         if (tty == NULL)
3137                 return;
3138
3139         spin_lock_irqsave(&brd_lock, flags);
3140         BRDENABLE(portp->brdnr, portp->pagenr);
3141         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3142         if (state) {
3143                 stl_cd1400ccrwait(portp);
3144                 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1);
3145                 portp->stats.rxxon++;
3146                 stl_cd1400ccrwait(portp);
3147         } else {
3148                 stl_cd1400ccrwait(portp);
3149                 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2);
3150                 portp->stats.rxxoff++;
3151                 stl_cd1400ccrwait(portp);
3152         }
3153         BRDDISABLE(portp->brdnr);
3154         spin_unlock_irqrestore(&brd_lock, flags);
3155         tty_kref_put(tty);
3156 }
3157
3158 /*****************************************************************************/
3159
3160 static void stl_cd1400flush(struct stlport *portp)
3161 {
3162         unsigned long   flags;
3163
3164         pr_debug("stl_cd1400flush(portp=%p)\n", portp);
3165
3166         if (portp == NULL)
3167                 return;
3168
3169         spin_lock_irqsave(&brd_lock, flags);
3170         BRDENABLE(portp->brdnr, portp->pagenr);
3171         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3172         stl_cd1400ccrwait(portp);
3173         stl_cd1400setreg(portp, CCR, CCR_TXFLUSHFIFO);
3174         stl_cd1400ccrwait(portp);
3175         portp->tx.tail = portp->tx.head;
3176         BRDDISABLE(portp->brdnr);
3177         spin_unlock_irqrestore(&brd_lock, flags);
3178 }
3179
3180 /*****************************************************************************/
3181
3182 /*
3183  *      Return the current state of data flow on this port. This is only
3184  *      really interesting when determining if data has fully completed
3185  *      transmission or not... This is easy for the cd1400, it accurately
3186  *      maintains the busy port flag.
3187  */
3188
3189 static int stl_cd1400datastate(struct stlport *portp)
3190 {
3191         pr_debug("stl_cd1400datastate(portp=%p)\n", portp);
3192
3193         if (portp == NULL)
3194                 return 0;
3195
3196         return test_bit(ASYI_TXBUSY, &portp->istate) ? 1 : 0;
3197 }
3198
3199 /*****************************************************************************/
3200
3201 /*
3202  *      Interrupt service routine for cd1400 EasyIO boards.
3203  */
3204
3205 static void stl_cd1400eiointr(struct stlpanel *panelp, unsigned int iobase)
3206 {
3207         unsigned char   svrtype;
3208
3209         pr_debug("stl_cd1400eiointr(panelp=%p,iobase=%x)\n", panelp, iobase);
3210
3211         spin_lock(&brd_lock);
3212         outb(SVRR, iobase);
3213         svrtype = inb(iobase + EREG_DATA);
3214         if (panelp->nrports > 4) {
3215                 outb((SVRR + 0x80), iobase);
3216                 svrtype |= inb(iobase + EREG_DATA);
3217         }
3218
3219         if (svrtype & SVRR_RX)
3220                 stl_cd1400rxisr(panelp, iobase);
3221         else if (svrtype & SVRR_TX)
3222                 stl_cd1400txisr(panelp, iobase);
3223         else if (svrtype & SVRR_MDM)
3224                 stl_cd1400mdmisr(panelp, iobase);
3225
3226         spin_unlock(&brd_lock);
3227 }
3228
3229 /*****************************************************************************/
3230
3231 /*
3232  *      Interrupt service routine for cd1400 panels.
3233  */
3234
3235 static void stl_cd1400echintr(struct stlpanel *panelp, unsigned int iobase)
3236 {
3237         unsigned char   svrtype;
3238
3239         pr_debug("stl_cd1400echintr(panelp=%p,iobase=%x)\n", panelp, iobase);
3240
3241         outb(SVRR, iobase);
3242         svrtype = inb(iobase + EREG_DATA);
3243         outb((SVRR + 0x80), iobase);
3244         svrtype |= inb(iobase + EREG_DATA);
3245         if (svrtype & SVRR_RX)
3246                 stl_cd1400rxisr(panelp, iobase);
3247         else if (svrtype & SVRR_TX)
3248                 stl_cd1400txisr(panelp, iobase);
3249         else if (svrtype & SVRR_MDM)
3250                 stl_cd1400mdmisr(panelp, iobase);
3251 }
3252
3253
3254 /*****************************************************************************/
3255
3256 /*
3257  *      Unfortunately we need to handle breaks in the TX data stream, since
3258  *      this is the only way to generate them on the cd1400.
3259  */
3260
3261 static int stl_cd1400breakisr(struct stlport *portp, int ioaddr)
3262 {
3263         if (portp->brklen == 1) {
3264                 outb((COR2 + portp->uartaddr), ioaddr);
3265                 outb((inb(ioaddr + EREG_DATA) | COR2_ETC),
3266                         (ioaddr + EREG_DATA));
3267                 outb((TDR + portp->uartaddr), ioaddr);
3268                 outb(ETC_CMD, (ioaddr + EREG_DATA));
3269                 outb(ETC_STARTBREAK, (ioaddr + EREG_DATA));
3270                 outb((SRER + portp->uartaddr), ioaddr);
3271                 outb((inb(ioaddr + EREG_DATA) & ~(SRER_TXDATA | SRER_TXEMPTY)),
3272                         (ioaddr + EREG_DATA));
3273                 return 1;
3274         } else if (portp->brklen > 1) {
3275                 outb((TDR + portp->uartaddr), ioaddr);
3276                 outb(ETC_CMD, (ioaddr + EREG_DATA));
3277                 outb(ETC_STOPBREAK, (ioaddr + EREG_DATA));
3278                 portp->brklen = -1;
3279                 return 1;
3280         } else {
3281                 outb((COR2 + portp->uartaddr), ioaddr);
3282                 outb((inb(ioaddr + EREG_DATA) & ~COR2_ETC),
3283                         (ioaddr + EREG_DATA));
3284                 portp->brklen = 0;
3285         }
3286         return 0;
3287 }
3288
3289 /*****************************************************************************/
3290
3291 /*
3292  *      Transmit interrupt handler. This has gotta be fast!  Handling TX
3293  *      chars is pretty simple, stuff as many as possible from the TX buffer
3294  *      into the cd1400 FIFO. Must also handle TX breaks here, since they
3295  *      are embedded as commands in the data stream. Oh no, had to use a goto!
3296  *      This could be optimized more, will do when I get time...
3297  *      In practice it is possible that interrupts are enabled but that the
3298  *      port has been hung up. Need to handle not having any TX buffer here,
3299  *      this is done by using the side effect that head and tail will also
3300  *      be NULL if the buffer has been freed.
3301  */
3302
3303 static void stl_cd1400txisr(struct stlpanel *panelp, int ioaddr)
3304 {
3305         struct stlport  *portp;
3306         int             len, stlen;
3307         char            *head, *tail;
3308         unsigned char   ioack, srer;
3309         struct tty_struct *tty;
3310
3311         pr_debug("stl_cd1400txisr(panelp=%p,ioaddr=%x)\n", panelp, ioaddr);
3312
3313         ioack = inb(ioaddr + EREG_TXACK);
3314         if (((ioack & panelp->ackmask) != 0) ||
3315             ((ioack & ACK_TYPMASK) != ACK_TYPTX)) {
3316                 printk("STALLION: bad TX interrupt ack value=%x\n", ioack);
3317                 return;
3318         }
3319         portp = panelp->ports[(ioack >> 3)];
3320
3321 /*
3322  *      Unfortunately we need to handle breaks in the data stream, since
3323  *      this is the only way to generate them on the cd1400. Do it now if
3324  *      a break is to be sent.
3325  */
3326         if (portp->brklen != 0)
3327                 if (stl_cd1400breakisr(portp, ioaddr))
3328                         goto stl_txalldone;
3329
3330         head = portp->tx.head;
3331         tail = portp->tx.tail;
3332         len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
3333         if ((len == 0) || ((len < STL_TXBUFLOW) &&
3334             (test_bit(ASYI_TXLOW, &portp->istate) == 0))) {
3335                 set_bit(ASYI_TXLOW, &portp->istate);
3336                 tty = tty_port_tty_get(&portp->port);
3337                 if (tty) {
3338                         tty_wakeup(tty);
3339                         tty_kref_put(tty);
3340                 }
3341         }
3342
3343         if (len == 0) {
3344                 outb((SRER + portp->uartaddr), ioaddr);
3345                 srer = inb(ioaddr + EREG_DATA);
3346                 if (srer & SRER_TXDATA) {
3347                         srer = (srer & ~SRER_TXDATA) | SRER_TXEMPTY;
3348                 } else {
3349                         srer &= ~(SRER_TXDATA | SRER_TXEMPTY);
3350                         clear_bit(ASYI_TXBUSY, &portp->istate);
3351                 }
3352                 outb(srer, (ioaddr + EREG_DATA));
3353         } else {
3354                 len = min(len, CD1400_TXFIFOSIZE);
3355                 portp->stats.txtotal += len;
3356                 stlen = min_t(unsigned int, len,
3357                                 (portp->tx.buf + STL_TXBUFSIZE) - tail);
3358                 outb((TDR + portp->uartaddr), ioaddr);
3359                 outsb((ioaddr + EREG_DATA), tail, stlen);
3360                 len -= stlen;
3361                 tail += stlen;
3362                 if (tail >= (portp->tx.buf + STL_TXBUFSIZE))
3363                         tail = portp->tx.buf;
3364                 if (len > 0) {
3365                         outsb((ioaddr + EREG_DATA), tail, len);
3366                         tail += len;
3367                 }
3368                 portp->tx.tail = tail;
3369         }
3370
3371 stl_txalldone:
3372         outb((EOSRR + portp->uartaddr), ioaddr);
3373         outb(0, (ioaddr + EREG_DATA));
3374 }
3375
3376 /*****************************************************************************/
3377
3378 /*
3379  *      Receive character interrupt handler. Determine if we have good chars
3380  *      or bad chars and then process appropriately. Good chars are easy
3381  *      just shove the lot into the RX buffer and set all status byte to 0.
3382  *      If a bad RX char then process as required. This routine needs to be
3383  *      fast!  In practice it is possible that we get an interrupt on a port
3384  *      that is closed. This can happen on hangups - since they completely
3385  *      shutdown a port not in user context. Need to handle this case.
3386  */
3387
3388 static void stl_cd1400rxisr(struct stlpanel *panelp, int ioaddr)
3389 {
3390         struct stlport          *portp;
3391         struct tty_struct       *tty;
3392         unsigned int            ioack, len, buflen;
3393         unsigned char           status;
3394         char                    ch;
3395
3396         pr_debug("stl_cd1400rxisr(panelp=%p,ioaddr=%x)\n", panelp, ioaddr);
3397
3398         ioack = inb(ioaddr + EREG_RXACK);
3399         if ((ioack & panelp->ackmask) != 0) {
3400                 printk("STALLION: bad RX interrupt ack value=%x\n", ioack);
3401                 return;
3402         }
3403         portp = panelp->ports[(ioack >> 3)];
3404         tty = tty_port_tty_get(&portp->port);
3405
3406         if ((ioack & ACK_TYPMASK) == ACK_TYPRXGOOD) {
3407                 outb((RDCR + portp->uartaddr), ioaddr);
3408                 len = inb(ioaddr + EREG_DATA);
3409                 if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) {
3410                         len = min_t(unsigned int, len, sizeof(stl_unwanted));
3411                         outb((RDSR + portp->uartaddr), ioaddr);
3412                         insb((ioaddr + EREG_DATA), &stl_unwanted[0], len);
3413                         portp->stats.rxlost += len;
3414                         portp->stats.rxtotal += len;
3415                 } else {
3416                         len = min(len, buflen);
3417                         if (len > 0) {
3418                                 unsigned char *ptr;
3419                                 outb((RDSR + portp->uartaddr), ioaddr);
3420                                 tty_prepare_flip_string(tty, &ptr, len);
3421                                 insb((ioaddr + EREG_DATA), ptr, len);
3422                                 tty_schedule_flip(tty);
3423                                 portp->stats.rxtotal += len;
3424                         }
3425                 }
3426         } else if ((ioack & ACK_TYPMASK) == ACK_TYPRXBAD) {
3427                 outb((RDSR + portp->uartaddr), ioaddr);
3428                 status = inb(ioaddr + EREG_DATA);
3429                 ch = inb(ioaddr + EREG_DATA);
3430                 if (status & ST_PARITY)
3431                         portp->stats.rxparity++;
3432                 if (status & ST_FRAMING)
3433                         portp->stats.rxframing++;
3434                 if (status & ST_OVERRUN)
3435                         portp->stats.rxoverrun++;
3436                 if (status & ST_BREAK)
3437                         portp->stats.rxbreaks++;
3438                 if (status & ST_SCHARMASK) {
3439                         if ((status & ST_SCHARMASK) == ST_SCHAR1)
3440                                 portp->stats.txxon++;
3441                         if ((status & ST_SCHARMASK) == ST_SCHAR2)
3442                                 portp->stats.txxoff++;
3443                         goto stl_rxalldone;
3444                 }
3445                 if (tty != NULL && (portp->rxignoremsk & status) == 0) {
3446                         if (portp->rxmarkmsk & status) {
3447                                 if (status & ST_BREAK) {
3448                                         status = TTY_BREAK;
3449                                         if (portp->port.flags & ASYNC_SAK) {
3450                                                 do_SAK(tty);
3451                                                 BRDENABLE(portp->brdnr, portp->pagenr);
3452                                         }
3453                                 } else if (status & ST_PARITY)
3454                                         status = TTY_PARITY;
3455                                 else if (status & ST_FRAMING)
3456                                         status = TTY_FRAME;
3457                                 else if(status & ST_OVERRUN)
3458                                         status = TTY_OVERRUN;
3459                                 else
3460                                         status = 0;
3461                         } else
3462                                 status = 0;
3463                         tty_insert_flip_char(tty, ch, status);
3464                         tty_schedule_flip(tty);
3465                 }
3466         } else {
3467                 printk("STALLION: bad RX interrupt ack value=%x\n", ioack);
3468                 tty_kref_put(tty);
3469                 return;
3470         }
3471
3472 stl_rxalldone:
3473         tty_kref_put(tty);
3474         outb((EOSRR + portp->uartaddr), ioaddr);
3475         outb(0, (ioaddr + EREG_DATA));
3476 }
3477
3478 /*****************************************************************************/
3479
3480 /*
3481  *      Modem interrupt handler. The is called when the modem signal line
3482  *      (DCD) has changed state. Leave most of the work to the off-level
3483  *      processing routine.
3484  */
3485
3486 static void stl_cd1400mdmisr(struct stlpanel *panelp, int ioaddr)
3487 {
3488         struct stlport  *portp;
3489         unsigned int    ioack;
3490         unsigned char   misr;
3491
3492         pr_debug("stl_cd1400mdmisr(panelp=%p)\n", panelp);
3493
3494         ioack = inb(ioaddr + EREG_MDACK);
3495         if (((ioack & panelp->ackmask) != 0) ||
3496             ((ioack & ACK_TYPMASK) != ACK_TYPMDM)) {
3497                 printk("STALLION: bad MODEM interrupt ack value=%x\n", ioack);
3498                 return;
3499         }
3500         portp = panelp->ports[(ioack >> 3)];
3501
3502         outb((MISR + portp->uartaddr), ioaddr);
3503         misr = inb(ioaddr + EREG_DATA);
3504         if (misr & MISR_DCD) {
3505                 stl_cd_change(portp);
3506                 portp->stats.modem++;
3507         }
3508
3509         outb((EOSRR + portp->uartaddr), ioaddr);
3510         outb(0, (ioaddr + EREG_DATA));
3511 }
3512
3513 /*****************************************************************************/
3514 /*                      SC26198 HARDWARE FUNCTIONS                           */
3515 /*****************************************************************************/
3516
3517 /*
3518  *      These functions get/set/update the registers of the sc26198 UARTs.
3519  *      Access to the sc26198 registers is via an address/data io port pair.
3520  *      (Maybe should make this inline...)
3521  */
3522
3523 static int stl_sc26198getreg(struct stlport *portp, int regnr)
3524 {
3525         outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
3526         return inb(portp->ioaddr + XP_DATA);
3527 }
3528
3529 static void stl_sc26198setreg(struct stlport *portp, int regnr, int value)
3530 {
3531         outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
3532         outb(value, (portp->ioaddr + XP_DATA));
3533 }
3534
3535 static int stl_sc26198updatereg(struct stlport *portp, int regnr, int value)
3536 {
3537         outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
3538         if (inb(portp->ioaddr + XP_DATA) != value) {
3539                 outb(value, (portp->ioaddr + XP_DATA));
3540                 return 1;
3541         }
3542         return 0;
3543 }
3544
3545 /*****************************************************************************/
3546
3547 /*
3548  *      Functions to get and set the sc26198 global registers.
3549  */
3550
3551 static int stl_sc26198getglobreg(struct stlport *portp, int regnr)
3552 {
3553         outb(regnr, (portp->ioaddr + XP_ADDR));
3554         return inb(portp->ioaddr + XP_DATA);
3555 }
3556
3557 #if 0
3558 static void stl_sc26198setglobreg(struct stlport *portp, int regnr, int value)
3559 {
3560         outb(regnr, (portp->ioaddr + XP_ADDR));
3561         outb(value, (portp->ioaddr + XP_DATA));
3562 }
3563 #endif
3564
3565 /*****************************************************************************/
3566
3567 /*
3568  *      Inbitialize the UARTs in a panel. We don't care what sort of board
3569  *      these ports are on - since the port io registers are almost
3570  *      identical when dealing with ports.
3571  */
3572
3573 static int stl_sc26198panelinit(struct stlbrd *brdp, struct stlpanel *panelp)
3574 {
3575         int     chipmask, i;
3576         int     nrchips, ioaddr;
3577
3578         pr_debug("stl_sc26198panelinit(brdp=%p,panelp=%p)\n", brdp, panelp);
3579
3580         BRDENABLE(panelp->brdnr, panelp->pagenr);
3581
3582 /*
3583  *      Check that each chip is present and started up OK.
3584  */
3585         chipmask = 0;
3586         nrchips = (panelp->nrports + 4) / SC26198_PORTS;
3587         if (brdp->brdtype == BRD_ECHPCI)
3588                 outb(panelp->pagenr, brdp->ioctrl);
3589
3590         for (i = 0; i < nrchips; i++) {
3591                 ioaddr = panelp->iobase + (i * 4); 
3592                 outb(SCCR, (ioaddr + XP_ADDR));
3593                 outb(CR_RESETALL, (ioaddr + XP_DATA));
3594                 outb(TSTR, (ioaddr + XP_ADDR));
3595                 if (inb(ioaddr + XP_DATA) != 0) {
3596                         printk("STALLION: sc26198 not responding, "
3597                                 "brd=%d panel=%d chip=%d\n",
3598                                 panelp->brdnr, panelp->panelnr, i);
3599                         continue;
3600                 }
3601                 chipmask |= (0x1 << i);
3602                 outb(GCCR, (ioaddr + XP_ADDR));
3603                 outb(GCCR_IVRTYPCHANACK, (ioaddr + XP_DATA));
3604                 outb(WDTRCR, (ioaddr + XP_ADDR));
3605                 outb(0xff, (ioaddr + XP_DATA));
3606         }
3607
3608         BRDDISABLE(panelp->brdnr);
3609         return chipmask;
3610 }
3611
3612 /*****************************************************************************/
3613
3614 /*
3615  *      Initialize hardware specific port registers.
3616  */
3617
3618 static void stl_sc26198portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp)
3619 {
3620         pr_debug("stl_sc26198portinit(brdp=%p,panelp=%p,portp=%p)\n", brdp,
3621                         panelp, portp);
3622
3623         if ((brdp == NULL) || (panelp == NULL) ||
3624             (portp == NULL))
3625                 return;
3626
3627         portp->ioaddr = panelp->iobase + ((portp->portnr < 8) ? 0 : 4);
3628         portp->uartaddr = (portp->portnr & 0x07) << 4;
3629         portp->pagenr = panelp->pagenr;
3630         portp->hwid = 0x1;
3631
3632         BRDENABLE(portp->brdnr, portp->pagenr);
3633         stl_sc26198setreg(portp, IOPCR, IOPCR_SETSIGS);
3634         BRDDISABLE(portp->brdnr);
3635 }
3636
3637 /*****************************************************************************/
3638
3639 /*
3640  *      Set up the sc26198 registers for a port based on the termios port
3641  *      settings.
3642  */
3643
3644 static void stl_sc26198setport(struct stlport *portp, struct ktermios *tiosp)
3645 {
3646         struct stlbrd   *brdp;
3647         unsigned long   flags;
3648         unsigned int    baudrate;
3649         unsigned char   mr0, mr1, mr2, clk;
3650         unsigned char   imron, imroff, iopr, ipr;
3651
3652         mr0 = 0;
3653         mr1 = 0;
3654         mr2 = 0;
3655         clk = 0;
3656         iopr = 0;
3657         imron = 0;
3658         imroff = 0;
3659
3660         brdp = stl_brds[portp->brdnr];
3661         if (brdp == NULL)
3662                 return;
3663
3664 /*
3665  *      Set up the RX char ignore mask with those RX error types we
3666  *      can ignore.
3667  */
3668         portp->rxignoremsk = 0;
3669         if (tiosp->c_iflag & IGNPAR)
3670                 portp->rxignoremsk |= (SR_RXPARITY | SR_RXFRAMING |
3671                         SR_RXOVERRUN);
3672         if (tiosp->c_iflag & IGNBRK)
3673                 portp->rxignoremsk |= SR_RXBREAK;
3674
3675         portp->rxmarkmsk = SR_RXOVERRUN;
3676         if (tiosp->c_iflag & (INPCK | PARMRK))
3677                 portp->rxmarkmsk |= (SR_RXPARITY | SR_RXFRAMING);
3678         if (tiosp->c_iflag & BRKINT)
3679                 portp->rxmarkmsk |= SR_RXBREAK;
3680
3681 /*
3682  *      Go through the char size, parity and stop bits and set all the
3683  *      option register appropriately.
3684  */
3685         switch (tiosp->c_cflag & CSIZE) {
3686         case CS5:
3687                 mr1 |= MR1_CS5;
3688                 break;
3689         case CS6:
3690                 mr1 |= MR1_CS6;
3691                 break;
3692         case CS7:
3693                 mr1 |= MR1_CS7;
3694                 break;
3695         default:
3696                 mr1 |= MR1_CS8;
3697                 break;
3698         }
3699
3700         if (tiosp->c_cflag & CSTOPB)
3701                 mr2 |= MR2_STOP2;
3702         else
3703                 mr2 |= MR2_STOP1;
3704
3705         if (tiosp->c_cflag & PARENB) {
3706                 if (tiosp->c_cflag & PARODD)
3707                         mr1 |= (MR1_PARENB | MR1_PARODD);
3708                 else
3709                         mr1 |= (MR1_PARENB | MR1_PAREVEN);
3710         } else
3711                 mr1 |= MR1_PARNONE;
3712
3713         mr1 |= MR1_ERRBLOCK;
3714
3715 /*
3716  *      Set the RX FIFO threshold at 8 chars. This gives a bit of breathing
3717  *      space for hardware flow control and the like. This should be set to
3718  *      VMIN.
3719  */
3720         mr2 |= MR2_RXFIFOHALF;
3721
3722 /*
3723  *      Calculate the baud rate timers. For now we will just assume that
3724  *      the input and output baud are the same. The sc26198 has a fixed
3725  *      baud rate table, so only discrete baud rates possible.
3726  */
3727         baudrate = tiosp->c_cflag & CBAUD;
3728         if (baudrate & CBAUDEX) {
3729                 baudrate &= ~CBAUDEX;
3730                 if ((baudrate < 1) || (baudrate > 4))
3731                         tiosp->c_cflag &= ~CBAUDEX;
3732                 else
3733                         baudrate += 15;
3734         }
3735         baudrate = stl_baudrates[baudrate];
3736         if ((tiosp->c_cflag & CBAUD) == B38400) {
3737                 if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
3738                         baudrate = 57600;
3739                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
3740                         baudrate = 115200;
3741                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
3742                         baudrate = 230400;
3743                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
3744                         baudrate = 460800;
3745                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
3746                         baudrate = (portp->baud_base / portp->custom_divisor);
3747         }
3748         if (baudrate > STL_SC26198MAXBAUD)
3749                 baudrate = STL_SC26198MAXBAUD;
3750
3751         if (baudrate > 0)
3752                 for (clk = 0; clk < SC26198_NRBAUDS; clk++)
3753                         if (baudrate <= sc26198_baudtable[clk])
3754                                 break;
3755
3756 /*
3757  *      Check what form of modem signaling is required and set it up.
3758  */
3759         if (tiosp->c_cflag & CLOCAL) {
3760                 portp->port.flags &= ~ASYNC_CHECK_CD;
3761         } else {
3762                 iopr |= IOPR_DCDCOS;
3763                 imron |= IR_IOPORT;
3764                 portp->port.flags |= ASYNC_CHECK_CD;
3765         }
3766
3767 /*
3768  *      Setup sc26198 enhanced modes if we can. In particular we want to
3769  *      handle as much of the flow control as possible automatically. As
3770  *      well as saving a few CPU cycles it will also greatly improve flow
3771  *      control reliability.
3772  */
3773         if (tiosp->c_iflag & IXON) {
3774                 mr0 |= MR0_SWFTX | MR0_SWFT;
3775                 imron |= IR_XONXOFF;
3776         } else
3777                 imroff |= IR_XONXOFF;
3778
3779         if (tiosp->c_iflag & IXOFF)
3780                 mr0 |= MR0_SWFRX;
3781
3782         if (tiosp->c_cflag & CRTSCTS) {
3783                 mr2 |= MR2_AUTOCTS;
3784                 mr1 |= MR1_AUTORTS;
3785         }
3786
3787 /*
3788  *      All sc26198 register values calculated so go through and set
3789  *      them all up.
3790  */
3791
3792         pr_debug("SETPORT: portnr=%d panelnr=%d brdnr=%d\n",
3793                 portp->portnr, portp->panelnr, portp->brdnr);
3794         pr_debug("    mr0=%x mr1=%x mr2=%x clk=%x\n", mr0, mr1, mr2, clk);
3795         pr_debug("    iopr=%x imron=%x imroff=%x\n", iopr, imron, imroff);
3796         pr_debug("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
3797                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP],
3798                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
3799
3800         spin_lock_irqsave(&brd_lock, flags);
3801         BRDENABLE(portp->brdnr, portp->pagenr);
3802         stl_sc26198setreg(portp, IMR, 0);
3803         stl_sc26198updatereg(portp, MR0, mr0);
3804         stl_sc26198updatereg(portp, MR1, mr1);
3805         stl_sc26198setreg(portp, SCCR, CR_RXERRBLOCK);
3806         stl_sc26198updatereg(portp, MR2, mr2);
3807         stl_sc26198updatereg(portp, IOPIOR,
3808                 ((stl_sc26198getreg(portp, IOPIOR) & ~IPR_CHANGEMASK) | iopr));
3809
3810         if (baudrate > 0) {
3811                 stl_sc26198setreg(portp, TXCSR, clk);
3812                 stl_sc26198setreg(portp, RXCSR, clk);
3813         }
3814
3815         stl_sc26198setreg(portp, XONCR, tiosp->c_cc[VSTART]);
3816         stl_sc26198setreg(portp, XOFFCR, tiosp->c_cc[VSTOP]);
3817
3818         ipr = stl_sc26198getreg(portp, IPR);
3819         if (ipr & IPR_DCD)
3820                 portp->sigs &= ~TIOCM_CD;
3821         else
3822                 portp->sigs |= TIOCM_CD;
3823
3824         portp->imr = (portp->imr & ~imroff) | imron;
3825         stl_sc26198setreg(portp, IMR, portp->imr);
3826         BRDDISABLE(portp->brdnr);
3827         spin_unlock_irqrestore(&brd_lock, flags);
3828 }
3829
3830 /*****************************************************************************/
3831
3832 /*
3833  *      Set the state of the DTR and RTS signals.
3834  */
3835
3836 static void stl_sc26198setsignals(struct stlport *portp, int dtr, int rts)
3837 {
3838         unsigned char   iopioron, iopioroff;
3839         unsigned long   flags;
3840
3841         pr_debug("stl_sc26198setsignals(portp=%p,dtr=%d,rts=%d)\n", portp,
3842                         dtr, rts);
3843
3844         iopioron = 0;
3845         iopioroff = 0;
3846         if (dtr == 0)
3847                 iopioroff |= IPR_DTR;
3848         else if (dtr > 0)
3849                 iopioron |= IPR_DTR;
3850         if (rts == 0)
3851                 iopioroff |= IPR_RTS;
3852         else if (rts > 0)
3853                 iopioron |= IPR_RTS;
3854
3855         spin_lock_irqsave(&brd_lock, flags);
3856         BRDENABLE(portp->brdnr, portp->pagenr);
3857         stl_sc26198setreg(portp, IOPIOR,
3858                 ((stl_sc26198getreg(portp, IOPIOR) & ~iopioroff) | iopioron));
3859         BRDDISABLE(portp->brdnr);
3860         spin_unlock_irqrestore(&brd_lock, flags);
3861 }
3862
3863 /*****************************************************************************/
3864
3865 /*
3866  *      Return the state of the signals.
3867  */
3868
3869 static int stl_sc26198getsignals(struct stlport *portp)
3870 {
3871         unsigned char   ipr;
3872         unsigned long   flags;
3873         int             sigs;
3874
3875         pr_debug("stl_sc26198getsignals(portp=%p)\n", portp);
3876
3877         spin_lock_irqsave(&brd_lock, flags);
3878         BRDENABLE(portp->brdnr, portp->pagenr);
3879         ipr = stl_sc26198getreg(portp, IPR);
3880         BRDDISABLE(portp->brdnr);
3881         spin_unlock_irqrestore(&brd_lock, flags);
3882
3883         sigs = 0;
3884         sigs |= (ipr & IPR_DCD) ? 0 : TIOCM_CD;
3885         sigs |= (ipr & IPR_CTS) ? 0 : TIOCM_CTS;
3886         sigs |= (ipr & IPR_DTR) ? 0: TIOCM_DTR;
3887         sigs |= (ipr & IPR_RTS) ? 0: TIOCM_RTS;
3888         sigs |= TIOCM_DSR;
3889         return sigs;
3890 }
3891
3892 /*****************************************************************************/
3893
3894 /*
3895  *      Enable/Disable the Transmitter and/or Receiver.
3896  */
3897
3898 static void stl_sc26198enablerxtx(struct stlport *portp, int rx, int tx)
3899 {
3900         unsigned char   ccr;
3901         unsigned long   flags;
3902
3903         pr_debug("stl_sc26198enablerxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx,tx);
3904
3905         ccr = portp->crenable;
3906         if (tx == 0)
3907                 ccr &= ~CR_TXENABLE;
3908         else if (tx > 0)
3909                 ccr |= CR_TXENABLE;
3910         if (rx == 0)
3911                 ccr &= ~CR_RXENABLE;
3912         else if (rx > 0)
3913                 ccr |= CR_RXENABLE;
3914
3915         spin_lock_irqsave(&brd_lock, flags);
3916         BRDENABLE(portp->brdnr, portp->pagenr);
3917         stl_sc26198setreg(portp, SCCR, ccr);
3918         BRDDISABLE(portp->brdnr);
3919         portp->crenable = ccr;
3920         spin_unlock_irqrestore(&brd_lock, flags);
3921 }
3922
3923 /*****************************************************************************/
3924
3925 /*
3926  *      Start/stop the Transmitter and/or Receiver.
3927  */
3928
3929 static void stl_sc26198startrxtx(struct stlport *portp, int rx, int tx)
3930 {
3931         unsigned char   imr;
3932         unsigned long   flags;
3933
3934         pr_debug("stl_sc26198startrxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
3935
3936         imr = portp->imr;
3937         if (tx == 0)
3938                 imr &= ~IR_TXRDY;
3939         else if (tx == 1)
3940                 imr |= IR_TXRDY;
3941         if (rx == 0)
3942                 imr &= ~(IR_RXRDY | IR_RXBREAK | IR_RXWATCHDOG);
3943         else if (rx > 0)
3944                 imr |= IR_RXRDY | IR_RXBREAK | IR_RXWATCHDOG;
3945
3946         spin_lock_irqsave(&brd_lock, flags);
3947         BRDENABLE(portp->brdnr, portp->pagenr);
3948         stl_sc26198setreg(portp, IMR, imr);
3949         BRDDISABLE(portp->brdnr);
3950         portp->imr = imr;
3951         if (tx > 0)
3952                 set_bit(ASYI_TXBUSY, &portp->istate);
3953         spin_unlock_irqrestore(&brd_lock, flags);
3954 }
3955
3956 /*****************************************************************************/
3957
3958 /*
3959  *      Disable all interrupts from this port.
3960  */
3961
3962 static void stl_sc26198disableintrs(struct stlport *portp)
3963 {
3964         unsigned long   flags;
3965
3966         pr_debug("stl_sc26198disableintrs(portp=%p)\n", portp);
3967
3968         spin_lock_irqsave(&brd_lock, flags);
3969         BRDENABLE(portp->brdnr, portp->pagenr);
3970         portp->imr = 0;
3971         stl_sc26198setreg(portp, IMR, 0);
3972         BRDDISABLE(portp->brdnr);
3973         spin_unlock_irqrestore(&brd_lock, flags);
3974 }
3975
3976 /*****************************************************************************/
3977
3978 static void stl_sc26198sendbreak(struct stlport *portp, int len)
3979 {
3980         unsigned long   flags;
3981
3982         pr_debug("stl_sc26198sendbreak(portp=%p,len=%d)\n", portp, len);
3983
3984         spin_lock_irqsave(&brd_lock, flags);
3985         BRDENABLE(portp->brdnr, portp->pagenr);
3986         if (len == 1) {
3987                 stl_sc26198setreg(portp, SCCR, CR_TXSTARTBREAK);
3988                 portp->stats.txbreaks++;
3989         } else
3990                 stl_sc26198setreg(portp, SCCR, CR_TXSTOPBREAK);
3991
3992         BRDDISABLE(portp->brdnr);
3993         spin_unlock_irqrestore(&brd_lock, flags);
3994 }
3995
3996 /*****************************************************************************/
3997
3998 /*
3999  *      Take flow control actions...
4000  */
4001
4002 static void stl_sc26198flowctrl(struct stlport *portp, int state)
4003 {
4004         struct tty_struct       *tty;
4005         unsigned long           flags;
4006         unsigned char           mr0;
4007
4008         pr_debug("stl_sc26198flowctrl(portp=%p,state=%x)\n", portp, state);
4009
4010         if (portp == NULL)
4011                 return;
4012         tty = tty_port_tty_get(&portp->port);
4013         if (tty == NULL)
4014                 return;
4015
4016         spin_lock_irqsave(&brd_lock, flags);
4017         BRDENABLE(portp->brdnr, portp->pagenr);
4018
4019         if (state) {
4020                 if (tty->termios->c_iflag & IXOFF) {
4021                         mr0 = stl_sc26198getreg(portp, MR0);
4022                         stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4023                         stl_sc26198setreg(portp, SCCR, CR_TXSENDXON);
4024                         mr0 |= MR0_SWFRX;
4025                         portp->stats.rxxon++;
4026                         stl_sc26198wait(portp);
4027                         stl_sc26198setreg(portp, MR0, mr0);
4028                 }
4029 /*
4030  *              Question: should we return RTS to what it was before? It may
4031  *              have been set by an ioctl... Suppose not, since if you have
4032  *              hardware flow control set then it is pretty silly to go and
4033  *              set the RTS line by hand.
4034  */
4035                 if (tty->termios->c_cflag & CRTSCTS) {
4036                         stl_sc26198setreg(portp, MR1,
4037                                 (stl_sc26198getreg(portp, MR1) | MR1_AUTORTS));
4038                         stl_sc26198setreg(portp, IOPIOR,
4039                                 (stl_sc26198getreg(portp, IOPIOR) | IOPR_RTS));
4040                         portp->stats.rxrtson++;
4041                 }
4042         } else {
4043                 if (tty->termios->c_iflag & IXOFF) {
4044                         mr0 = stl_sc26198getreg(portp, MR0);
4045                         stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4046                         stl_sc26198setreg(portp, SCCR, CR_TXSENDXOFF);
4047                         mr0 &= ~MR0_SWFRX;
4048                         portp->stats.rxxoff++;
4049                         stl_sc26198wait(portp);
4050                         stl_sc26198setreg(portp, MR0, mr0);
4051                 }
4052                 if (tty->termios->c_cflag & CRTSCTS) {
4053                         stl_sc26198setreg(portp, MR1,
4054                                 (stl_sc26198getreg(portp, MR1) & ~MR1_AUTORTS));
4055                         stl_sc26198setreg(portp, IOPIOR,
4056                                 (stl_sc26198getreg(portp, IOPIOR) & ~IOPR_RTS));
4057                         portp->stats.rxrtsoff++;
4058                 }
4059         }
4060
4061         BRDDISABLE(portp->brdnr);
4062         spin_unlock_irqrestore(&brd_lock, flags);
4063         tty_kref_put(tty);
4064 }
4065
4066 /*****************************************************************************/
4067
4068 /*
4069  *      Send a flow control character.
4070  */
4071
4072 static void stl_sc26198sendflow(struct stlport *portp, int state)
4073 {
4074         struct tty_struct       *tty;
4075         unsigned long           flags;
4076         unsigned char           mr0;
4077
4078         pr_debug("stl_sc26198sendflow(portp=%p,state=%x)\n", portp, state);
4079
4080         if (portp == NULL)
4081                 return;
4082         tty = tty_port_tty_get(&portp->port);
4083         if (tty == NULL)
4084                 return;
4085
4086         spin_lock_irqsave(&brd_lock, flags);
4087         BRDENABLE(portp->brdnr, portp->pagenr);
4088         if (state) {
4089                 mr0 = stl_sc26198getreg(portp, MR0);
4090                 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4091                 stl_sc26198setreg(portp, SCCR, CR_TXSENDXON);
4092                 mr0 |= MR0_SWFRX;
4093                 portp->stats.rxxon++;
4094                 stl_sc26198wait(portp);
4095                 stl_sc26198setreg(portp, MR0, mr0);
4096         } else {
4097                 mr0 = stl_sc26198getreg(portp, MR0);
4098                 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4099                 stl_sc26198setreg(portp, SCCR, CR_TXSENDXOFF);
4100                 mr0 &= ~MR0_SWFRX;
4101                 portp->stats.rxxoff++;
4102                 stl_sc26198wait(portp);
4103                 stl_sc26198setreg(portp, MR0, mr0);
4104         }
4105         BRDDISABLE(portp->brdnr);
4106         spin_unlock_irqrestore(&brd_lock, flags);
4107         tty_kref_put(tty);
4108 }
4109
4110 /*****************************************************************************/
4111
4112 static void stl_sc26198flush(struct stlport *portp)
4113 {
4114         unsigned long   flags;
4115
4116         pr_debug("stl_sc26198flush(portp=%p)\n", portp);
4117
4118         if (portp == NULL)
4119                 return;
4120
4121         spin_lock_irqsave(&brd_lock, flags);
4122         BRDENABLE(portp->brdnr, portp->pagenr);
4123         stl_sc26198setreg(portp, SCCR, CR_TXRESET);
4124         stl_sc26198setreg(portp, SCCR, portp->crenable);
4125         BRDDISABLE(portp->brdnr);
4126         portp->tx.tail = portp->tx.head;
4127         spin_unlock_irqrestore(&brd_lock, flags);
4128 }
4129
4130 /*****************************************************************************/
4131
4132 /*
4133  *      Return the current state of data flow on this port. This is only
4134  *      really interesting when determining if data has fully completed
4135  *      transmission or not... The sc26198 interrupt scheme cannot
4136  *      determine when all data has actually drained, so we need to
4137  *      check the port statusy register to be sure.
4138  */
4139
4140 static int stl_sc26198datastate(struct stlport *portp)
4141 {
4142         unsigned long   flags;
4143         unsigned char   sr;
4144
4145         pr_debug("stl_sc26198datastate(portp=%p)\n", portp);
4146
4147         if (portp == NULL)
4148                 return 0;
4149         if (test_bit(ASYI_TXBUSY, &portp->istate))
4150                 return 1;
4151
4152         spin_lock_irqsave(&brd_lock, flags);
4153         BRDENABLE(portp->brdnr, portp->pagenr);
4154         sr = stl_sc26198getreg(portp, SR);
4155         BRDDISABLE(portp->brdnr);
4156         spin_unlock_irqrestore(&brd_lock, flags);
4157
4158         return (sr & SR_TXEMPTY) ? 0 : 1;
4159 }
4160
4161 /*****************************************************************************/
4162
4163 /*
4164  *      Delay for a small amount of time, to give the sc26198 a chance
4165  *      to process a command...
4166  */
4167
4168 static void stl_sc26198wait(struct stlport *portp)
4169 {
4170         int     i;
4171
4172         pr_debug("stl_sc26198wait(portp=%p)\n", portp);
4173
4174         if (portp == NULL)
4175                 return;
4176
4177         for (i = 0; i < 20; i++)
4178                 stl_sc26198getglobreg(portp, TSTR);
4179 }
4180
4181 /*****************************************************************************/
4182
4183 /*
4184  *      If we are TX flow controlled and in IXANY mode then we may
4185  *      need to unflow control here. We gotta do this because of the
4186  *      automatic flow control modes of the sc26198.
4187  */
4188
4189 static void stl_sc26198txunflow(struct stlport *portp, struct tty_struct *tty)
4190 {
4191         unsigned char   mr0;
4192
4193         mr0 = stl_sc26198getreg(portp, MR0);
4194         stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4195         stl_sc26198setreg(portp, SCCR, CR_HOSTXON);
4196         stl_sc26198wait(portp);
4197         stl_sc26198setreg(portp, MR0, mr0);
4198         clear_bit(ASYI_TXFLOWED, &portp->istate);
4199 }
4200
4201 /*****************************************************************************/
4202
4203 /*
4204  *      Interrupt service routine for sc26198 panels.
4205  */
4206
4207 static void stl_sc26198intr(struct stlpanel *panelp, unsigned int iobase)
4208 {
4209         struct stlport  *portp;
4210         unsigned int    iack;
4211
4212         spin_lock(&brd_lock);
4213
4214 /* 
4215  *      Work around bug in sc26198 chip... Cannot have A6 address
4216  *      line of UART high, else iack will be returned as 0.
4217  */
4218         outb(0, (iobase + 1));
4219
4220         iack = inb(iobase + XP_IACK);
4221         portp = panelp->ports[(iack & IVR_CHANMASK) + ((iobase & 0x4) << 1)];
4222
4223         if (iack & IVR_RXDATA)
4224                 stl_sc26198rxisr(portp, iack);
4225         else if (iack & IVR_TXDATA)
4226                 stl_sc26198txisr(portp);
4227         else
4228                 stl_sc26198otherisr(portp, iack);
4229
4230         spin_unlock(&brd_lock);
4231 }
4232
4233 /*****************************************************************************/
4234
4235 /*
4236  *      Transmit interrupt handler. This has gotta be fast!  Handling TX
4237  *      chars is pretty simple, stuff as many as possible from the TX buffer
4238  *      into the sc26198 FIFO.
4239  *      In practice it is possible that interrupts are enabled but that the
4240  *      port has been hung up. Need to handle not having any TX buffer here,
4241  *      this is done by using the side effect that head and tail will also
4242  *      be NULL if the buffer has been freed.
4243  */
4244
4245 static void stl_sc26198txisr(struct stlport *portp)
4246 {
4247         struct tty_struct *tty;
4248         unsigned int    ioaddr;
4249         unsigned char   mr0;
4250         int             len, stlen;
4251         char            *head, *tail;
4252
4253         pr_debug("stl_sc26198txisr(portp=%p)\n", portp);
4254
4255         ioaddr = portp->ioaddr;
4256         head = portp->tx.head;
4257         tail = portp->tx.tail;
4258         len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
4259         if ((len == 0) || ((len < STL_TXBUFLOW) &&
4260             (test_bit(ASYI_TXLOW, &portp->istate) == 0))) {
4261                 set_bit(ASYI_TXLOW, &portp->istate);
4262                 tty = tty_port_tty_get(&portp->port);
4263                 if (tty) {
4264                         tty_wakeup(tty);
4265                         tty_kref_put(tty);
4266                 }
4267         }
4268
4269         if (len == 0) {
4270                 outb((MR0 | portp->uartaddr), (ioaddr + XP_ADDR));
4271                 mr0 = inb(ioaddr + XP_DATA);
4272                 if ((mr0 & MR0_TXMASK) == MR0_TXEMPTY) {
4273                         portp->imr &= ~IR_TXRDY;
4274                         outb((IMR | portp->uartaddr), (ioaddr + XP_ADDR));
4275                         outb(portp->imr, (ioaddr + XP_DATA));
4276                         clear_bit(ASYI_TXBUSY, &portp->istate);
4277                 } else {
4278                         mr0 |= ((mr0 & ~MR0_TXMASK) | MR0_TXEMPTY);
4279                         outb(mr0, (ioaddr + XP_DATA));
4280                 }
4281         } else {
4282                 len = min(len, SC26198_TXFIFOSIZE);
4283                 portp->stats.txtotal += len;
4284                 stlen = min_t(unsigned int, len,
4285                                 (portp->tx.buf + STL_TXBUFSIZE) - tail);
4286                 outb(GTXFIFO, (ioaddr + XP_ADDR));
4287                 outsb((ioaddr + XP_DATA), tail, stlen);
4288                 len -= stlen;
4289                 tail += stlen;
4290                 if (tail >= (portp->tx.buf + STL_TXBUFSIZE))
4291                         tail = portp->tx.buf;
4292                 if (len > 0) {
4293                         outsb((ioaddr + XP_DATA), tail, len);
4294                         tail += len;
4295                 }
4296                 portp->tx.tail = tail;
4297         }
4298 }
4299
4300 /*****************************************************************************/
4301
4302 /*
4303  *      Receive character interrupt handler. Determine if we have good chars
4304  *      or bad chars and then process appropriately. Good chars are easy
4305  *      just shove the lot into the RX buffer and set all status byte to 0.
4306  *      If a bad RX char then process as required. This routine needs to be
4307  *      fast!  In practice it is possible that we get an interrupt on a port
4308  *      that is closed. This can happen on hangups - since they completely
4309  *      shutdown a port not in user context. Need to handle this case.
4310  */
4311
4312 static void stl_sc26198rxisr(struct stlport *portp, unsigned int iack)
4313 {
4314         struct tty_struct       *tty;
4315         unsigned int            len, buflen, ioaddr;
4316
4317         pr_debug("stl_sc26198rxisr(portp=%p,iack=%x)\n", portp, iack);
4318
4319         tty = tty_port_tty_get(&portp->port);
4320         ioaddr = portp->ioaddr;
4321         outb(GIBCR, (ioaddr + XP_ADDR));
4322         len = inb(ioaddr + XP_DATA) + 1;
4323
4324         if ((iack & IVR_TYPEMASK) == IVR_RXDATA) {
4325                 if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) {
4326                         len = min_t(unsigned int, len, sizeof(stl_unwanted));
4327                         outb(GRXFIFO, (ioaddr + XP_ADDR));
4328                         insb((ioaddr + XP_DATA), &stl_unwanted[0], len);
4329                         portp->stats.rxlost += len;
4330                         portp->stats.rxtotal += len;
4331                 } else {
4332                         len = min(len, buflen);
4333                         if (len > 0) {
4334                                 unsigned char *ptr;
4335                                 outb(GRXFIFO, (ioaddr + XP_ADDR));
4336                                 tty_prepare_flip_string(tty, &ptr, len);
4337                                 insb((ioaddr + XP_DATA), ptr, len);
4338                                 tty_schedule_flip(tty);
4339                                 portp->stats.rxtotal += len;
4340                         }
4341                 }
4342         } else {
4343                 stl_sc26198rxbadchars(portp);
4344         }
4345
4346 /*
4347  *      If we are TX flow controlled and in IXANY mode then we may need
4348  *      to unflow control here. We gotta do this because of the automatic
4349  *      flow control modes of the sc26198.
4350  */
4351         if (test_bit(ASYI_TXFLOWED, &portp->istate)) {
4352                 if ((tty != NULL) &&
4353                     (tty->termios != NULL) &&
4354                     (tty->termios->c_iflag & IXANY)) {
4355                         stl_sc26198txunflow(portp, tty);
4356                 }
4357         }
4358         tty_kref_put(tty);
4359 }
4360
4361 /*****************************************************************************/
4362
4363 /*
4364  *      Process an RX bad character.
4365  */
4366
4367 static void stl_sc26198rxbadch(struct stlport *portp, unsigned char status, char ch)
4368 {
4369         struct tty_struct       *tty;
4370         unsigned int            ioaddr;
4371
4372         tty = tty_port_tty_get(&portp->port);
4373         ioaddr = portp->ioaddr;
4374
4375         if (status & SR_RXPARITY)
4376                 portp->stats.rxparity++;
4377         if (status & SR_RXFRAMING)
4378                 portp->stats.rxframing++;
4379         if (status & SR_RXOVERRUN)
4380                 portp->stats.rxoverrun++;
4381         if (status & SR_RXBREAK)
4382                 portp->stats.rxbreaks++;
4383
4384         if ((tty != NULL) &&
4385             ((portp->rxignoremsk & status) == 0)) {
4386                 if (portp->rxmarkmsk & status) {
4387                         if (status & SR_RXBREAK) {
4388                                 status = TTY_BREAK;
4389                                 if (portp->port.flags & ASYNC_SAK) {
4390                                         do_SAK(tty);
4391                                         BRDENABLE(portp->brdnr, portp->pagenr);
4392                                 }
4393                         } else if (status & SR_RXPARITY)
4394                                 status = TTY_PARITY;
4395                         else if (status & SR_RXFRAMING)
4396                                 status = TTY_FRAME;
4397                         else if(status & SR_RXOVERRUN)
4398                                 status = TTY_OVERRUN;
4399                         else
4400                                 status = 0;
4401                 } else
4402                         status = 0;
4403
4404                 tty_insert_flip_char(tty, ch, status);
4405                 tty_schedule_flip(tty);
4406
4407                 if (status == 0)
4408                         portp->stats.rxtotal++;
4409         }
4410         tty_kref_put(tty);
4411 }
4412
4413 /*****************************************************************************/
4414
4415 /*
4416  *      Process all characters in the RX FIFO of the UART. Check all char
4417  *      status bytes as well, and process as required. We need to check
4418  *      all bytes in the FIFO, in case some more enter the FIFO while we
4419  *      are here. To get the exact character error type we need to switch
4420  *      into CHAR error mode (that is why we need to make sure we empty
4421  *      the FIFO).
4422  */
4423
4424 static void stl_sc26198rxbadchars(struct stlport *portp)
4425 {
4426         unsigned char   status, mr1;
4427         char            ch;
4428
4429 /*
4430  *      To get the precise error type for each character we must switch
4431  *      back into CHAR error mode.
4432  */
4433         mr1 = stl_sc26198getreg(portp, MR1);
4434         stl_sc26198setreg(portp, MR1, (mr1 & ~MR1_ERRBLOCK));
4435
4436         while ((status = stl_sc26198getreg(portp, SR)) & SR_RXRDY) {
4437                 stl_sc26198setreg(portp, SCCR, CR_CLEARRXERR);
4438                 ch = stl_sc26198getreg(portp, RXFIFO);
4439                 stl_sc26198rxbadch(portp, status, ch);
4440         }
4441
4442 /*
4443  *      To get correct interrupt class we must switch back into BLOCK
4444  *      error mode.
4445  */
4446         stl_sc26198setreg(portp, MR1, mr1);
4447 }
4448
4449 /*****************************************************************************/
4450
4451 /*
4452  *      Other interrupt handler. This includes modem signals, flow
4453  *      control actions, etc. Most stuff is left to off-level interrupt
4454  *      processing time.
4455  */
4456
4457 static void stl_sc26198otherisr(struct stlport *portp, unsigned int iack)
4458 {
4459         unsigned char   cir, ipr, xisr;
4460
4461         pr_debug("stl_sc26198otherisr(portp=%p,iack=%x)\n", portp, iack);
4462
4463         cir = stl_sc26198getglobreg(portp, CIR);
4464
4465         switch (cir & CIR_SUBTYPEMASK) {
4466         case CIR_SUBCOS:
4467                 ipr = stl_sc26198getreg(portp, IPR);
4468                 if (ipr & IPR_DCDCHANGE) {
4469                         stl_cd_change(portp);
4470                         portp->stats.modem++;
4471                 }
4472                 break;
4473         case CIR_SUBXONXOFF:
4474                 xisr = stl_sc26198getreg(portp, XISR);
4475                 if (xisr & XISR_RXXONGOT) {
4476                         set_bit(ASYI_TXFLOWED, &portp->istate);
4477                         portp->stats.txxoff++;
4478                 }
4479                 if (xisr & XISR_RXXOFFGOT) {
4480                         clear_bit(ASYI_TXFLOWED, &portp->istate);
4481                         portp->stats.txxon++;
4482                 }
4483                 break;
4484         case CIR_SUBBREAK:
4485                 stl_sc26198setreg(portp, SCCR, CR_BREAKRESET);
4486                 stl_sc26198rxbadchars(portp);
4487                 break;
4488         default:
4489                 break;
4490         }
4491 }
4492
4493 static void stl_free_isabrds(void)
4494 {
4495         struct stlbrd *brdp;
4496         unsigned int i;
4497
4498         for (i = 0; i < stl_nrbrds; i++) {
4499                 if ((brdp = stl_brds[i]) == NULL || (brdp->state & STL_PROBED))
4500                         continue;
4501
4502                 free_irq(brdp->irq, brdp);
4503
4504                 stl_cleanup_panels(brdp);
4505
4506                 release_region(brdp->ioaddr1, brdp->iosize1);
4507                 if (brdp->iosize2 > 0)
4508                         release_region(brdp->ioaddr2, brdp->iosize2);
4509
4510                 kfree(brdp);
4511                 stl_brds[i] = NULL;
4512         }
4513 }
4514
4515 /*
4516  *      Loadable module initialization stuff.
4517  */
4518 static int __init stallion_module_init(void)
4519 {
4520         struct stlbrd   *brdp;
4521         struct stlconf  conf;
4522         unsigned int i, j;
4523         int retval;
4524
4525         printk(KERN_INFO "%s: version %s\n", stl_drvtitle, stl_drvversion);
4526
4527         spin_lock_init(&stallion_lock);
4528         spin_lock_init(&brd_lock);
4529
4530         stl_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
4531         if (!stl_serial) {
4532                 retval = -ENOMEM;
4533                 goto err;
4534         }
4535
4536         stl_serial->owner = THIS_MODULE;
4537         stl_serial->driver_name = stl_drvname;
4538         stl_serial->name = "ttyE";
4539         stl_serial->major = STL_SERIALMAJOR;
4540         stl_serial->minor_start = 0;
4541         stl_serial->type = TTY_DRIVER_TYPE_SERIAL;
4542         stl_serial->subtype = SERIAL_TYPE_NORMAL;
4543         stl_serial->init_termios = stl_deftermios;
4544         stl_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4545         tty_set_operations(stl_serial, &stl_ops);
4546
4547         retval = tty_register_driver(stl_serial);
4548         if (retval) {
4549                 printk("STALLION: failed to register serial driver\n");
4550                 goto err_frtty;
4551         }
4552
4553 /*
4554  *      Find any dynamically supported boards. That is via module load
4555  *      line options.
4556  */
4557         for (i = stl_nrbrds; i < stl_nargs; i++) {
4558                 memset(&conf, 0, sizeof(conf));
4559                 if (stl_parsebrd(&conf, stl_brdsp[i]) == 0)
4560                         continue;
4561                 if ((brdp = stl_allocbrd()) == NULL)
4562                         continue;
4563                 brdp->brdnr = i;
4564                 brdp->brdtype = conf.brdtype;
4565                 brdp->ioaddr1 = conf.ioaddr1;
4566                 brdp->ioaddr2 = conf.ioaddr2;
4567                 brdp->irq = conf.irq;
4568                 brdp->irqtype = conf.irqtype;
4569                 stl_brds[brdp->brdnr] = brdp;
4570                 if (stl_brdinit(brdp)) {
4571                         stl_brds[brdp->brdnr] = NULL;
4572                         kfree(brdp);
4573                 } else {
4574                         for (j = 0; j < brdp->nrports; j++)
4575                                 tty_register_device(stl_serial,
4576                                         brdp->brdnr * STL_MAXPORTS + j, NULL);
4577                         stl_nrbrds = i + 1;
4578                 }
4579         }
4580
4581         /* this has to be _after_ isa finding because of locking */
4582         retval = pci_register_driver(&stl_pcidriver);
4583         if (retval && stl_nrbrds == 0) {
4584                 printk(KERN_ERR "STALLION: can't register pci driver\n");
4585                 goto err_unrtty;
4586         }
4587
4588 /*
4589  *      Set up a character driver for per board stuff. This is mainly used
4590  *      to do stats ioctls on the ports.
4591  */
4592         if (register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stl_fsiomem))
4593                 printk("STALLION: failed to register serial board device\n");
4594
4595         stallion_class = class_create(THIS_MODULE, "staliomem");
4596         if (IS_ERR(stallion_class))
4597                 printk("STALLION: failed to create class\n");
4598         for (i = 0; i < 4; i++)
4599                 device_create(stallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i),
4600                               NULL, "staliomem%d", i);
4601
4602         return 0;
4603 err_unrtty:
4604         tty_unregister_driver(stl_serial);
4605 err_frtty:
4606         put_tty_driver(stl_serial);
4607 err:
4608         return retval;
4609 }
4610
4611 static void __exit stallion_module_exit(void)
4612 {
4613         struct stlbrd *brdp;
4614         unsigned int i, j;
4615
4616         pr_debug("cleanup_module()\n");
4617
4618         printk(KERN_INFO "Unloading %s: version %s\n", stl_drvtitle,
4619                 stl_drvversion);
4620
4621 /*
4622  *      Free up all allocated resources used by the ports. This includes
4623  *      memory and interrupts. As part of this process we will also do
4624  *      a hangup on every open port - to try to flush out any processes
4625  *      hanging onto ports.
4626  */
4627         for (i = 0; i < stl_nrbrds; i++) {
4628                 if ((brdp = stl_brds[i]) == NULL || (brdp->state & STL_PROBED))
4629                         continue;
4630                 for (j = 0; j < brdp->nrports; j++)
4631                         tty_unregister_device(stl_serial,
4632                                 brdp->brdnr * STL_MAXPORTS + j);
4633         }
4634
4635         for (i = 0; i < 4; i++)
4636                 device_destroy(stallion_class, MKDEV(STL_SIOMEMMAJOR, i));
4637         unregister_chrdev(STL_SIOMEMMAJOR, "staliomem");
4638         class_destroy(stallion_class);
4639
4640         pci_unregister_driver(&stl_pcidriver);
4641
4642         stl_free_isabrds();
4643
4644         tty_unregister_driver(stl_serial);
4645         put_tty_driver(stl_serial);
4646 }
4647
4648 module_init(stallion_module_init);
4649 module_exit(stallion_module_exit);
4650
4651 MODULE_AUTHOR("Greg Ungerer");
4652 MODULE_DESCRIPTION("Stallion Multiport Serial Driver");
4653 MODULE_LICENSE("GPL");