Char: stallion, fix oops during init with ISA cards
[sfrench/cifs-2.6.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/slab.h>
31 #include <linux/interrupt.h>
32 #include <linux/tty.h>
33 #include <linux/tty_flip.h>
34 #include <linux/serial.h>
35 #include <linux/cd1400.h>
36 #include <linux/sc26198.h>
37 #include <linux/comstats.h>
38 #include <linux/stallion.h>
39 #include <linux/ioport.h>
40 #include <linux/init.h>
41 #include <linux/smp_lock.h>
42 #include <linux/device.h>
43 #include <linux/delay.h>
44 #include <linux/ctype.h>
45
46 #include <asm/io.h>
47 #include <asm/uaccess.h>
48
49 #include <linux/pci.h>
50
51 /*****************************************************************************/
52
53 /*
54  *      Define different board types. Use the standard Stallion "assigned"
55  *      board numbers. Boards supported in this driver are abbreviated as
56  *      EIO = EasyIO and ECH = EasyConnection 8/32.
57  */
58 #define BRD_EASYIO      20
59 #define BRD_ECH         21
60 #define BRD_ECHMC       22
61 #define BRD_ECHPCI      26
62 #define BRD_ECH64PCI    27
63 #define BRD_EASYIOPCI   28
64
65 struct stlconf {
66         unsigned int    brdtype;
67         int             ioaddr1;
68         int             ioaddr2;
69         unsigned long   memaddr;
70         int             irq;
71         int             irqtype;
72 };
73
74 static unsigned int stl_nrbrds;
75
76 /*****************************************************************************/
77
78 /*
79  *      Define some important driver characteristics. Device major numbers
80  *      allocated as per Linux Device Registry.
81  */
82 #ifndef STL_SIOMEMMAJOR
83 #define STL_SIOMEMMAJOR         28
84 #endif
85 #ifndef STL_SERIALMAJOR
86 #define STL_SERIALMAJOR         24
87 #endif
88 #ifndef STL_CALLOUTMAJOR
89 #define STL_CALLOUTMAJOR        25
90 #endif
91
92 /*
93  *      Set the TX buffer size. Bigger is better, but we don't want
94  *      to chew too much memory with buffers!
95  */
96 #define STL_TXBUFLOW            512
97 #define STL_TXBUFSIZE           4096
98
99 /*****************************************************************************/
100
101 /*
102  *      Define our local driver identity first. Set up stuff to deal with
103  *      all the local structures required by a serial tty driver.
104  */
105 static char     *stl_drvtitle = "Stallion Multiport Serial Driver";
106 static char     *stl_drvname = "stallion";
107 static char     *stl_drvversion = "5.6.0";
108
109 static struct tty_driver        *stl_serial;
110
111 /*
112  *      Define a local default termios struct. All ports will be created
113  *      with this termios initially. Basically all it defines is a raw port
114  *      at 9600, 8 data bits, 1 stop bit.
115  */
116 static struct ktermios          stl_deftermios = {
117         .c_cflag        = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
118         .c_cc           = INIT_C_CC,
119         .c_ispeed       = 9600,
120         .c_ospeed       = 9600,
121 };
122
123 /*
124  *      Define global place to put buffer overflow characters.
125  */
126 static char             stl_unwanted[SC26198_RXFIFOSIZE];
127
128 /*****************************************************************************/
129
130 static DEFINE_MUTEX(stl_brdslock);
131 static struct stlbrd            *stl_brds[STL_MAXBRDS];
132
133 /*
134  *      Per board state flags. Used with the state field of the board struct.
135  *      Not really much here!
136  */
137 #define BRD_FOUND       0x1
138 #define STL_PROBED      0x2
139
140
141 /*
142  *      Define the port structure istate flags. These set of flags are
143  *      modified at interrupt time - so setting and reseting them needs
144  *      to be atomic. Use the bit clear/setting routines for this.
145  */
146 #define ASYI_TXBUSY     1
147 #define ASYI_TXLOW      2
148 #define ASYI_DCDCHANGE  3
149 #define ASYI_TXFLOWED   4
150
151 /*
152  *      Define an array of board names as printable strings. Handy for
153  *      referencing boards when printing trace and stuff.
154  */
155 static char     *stl_brdnames[] = {
156         NULL,
157         NULL,
158         NULL,
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         "EasyIO",
177         "EC8/32-AT",
178         "EC8/32-MC",
179         NULL,
180         NULL,
181         NULL,
182         "EC8/32-PCI",
183         "EC8/64-PCI",
184         "EasyIO-PCI",
185 };
186
187 /*****************************************************************************/
188
189 /*
190  *      Define some string labels for arguments passed from the module
191  *      load line. These allow for easy board definitions, and easy
192  *      modification of the io, memory and irq resoucres.
193  */
194 static unsigned int stl_nargs;
195 static char     *board0[4];
196 static char     *board1[4];
197 static char     *board2[4];
198 static char     *board3[4];
199
200 static char     **stl_brdsp[] = {
201         (char **) &board0,
202         (char **) &board1,
203         (char **) &board2,
204         (char **) &board3
205 };
206
207 /*
208  *      Define a set of common board names, and types. This is used to
209  *      parse any module arguments.
210  */
211
212 static struct {
213         char    *name;
214         int     type;
215 } stl_brdstr[] = {
216         { "easyio", BRD_EASYIO },
217         { "eio", BRD_EASYIO },
218         { "20", BRD_EASYIO },
219         { "ec8/32", BRD_ECH },
220         { "ec8/32-at", BRD_ECH },
221         { "ec8/32-isa", BRD_ECH },
222         { "ech", BRD_ECH },
223         { "echat", BRD_ECH },
224         { "21", BRD_ECH },
225         { "ec8/32-mc", BRD_ECHMC },
226         { "ec8/32-mca", BRD_ECHMC },
227         { "echmc", BRD_ECHMC },
228         { "echmca", BRD_ECHMC },
229         { "22", BRD_ECHMC },
230         { "ec8/32-pc", BRD_ECHPCI },
231         { "ec8/32-pci", BRD_ECHPCI },
232         { "26", BRD_ECHPCI },
233         { "ec8/64-pc", BRD_ECH64PCI },
234         { "ec8/64-pci", BRD_ECH64PCI },
235         { "ech-pci", BRD_ECH64PCI },
236         { "echpci", BRD_ECH64PCI },
237         { "echpc", BRD_ECH64PCI },
238         { "27", BRD_ECH64PCI },
239         { "easyio-pc", BRD_EASYIOPCI },
240         { "easyio-pci", BRD_EASYIOPCI },
241         { "eio-pci", BRD_EASYIOPCI },
242         { "eiopci", BRD_EASYIOPCI },
243         { "28", BRD_EASYIOPCI },
244 };
245
246 /*
247  *      Define the module agruments.
248  */
249
250 module_param_array(board0, charp, &stl_nargs, 0);
251 MODULE_PARM_DESC(board0, "Board 0 config -> name[,ioaddr[,ioaddr2][,irq]]");
252 module_param_array(board1, charp, &stl_nargs, 0);
253 MODULE_PARM_DESC(board1, "Board 1 config -> name[,ioaddr[,ioaddr2][,irq]]");
254 module_param_array(board2, charp, &stl_nargs, 0);
255 MODULE_PARM_DESC(board2, "Board 2 config -> name[,ioaddr[,ioaddr2][,irq]]");
256 module_param_array(board3, charp, &stl_nargs, 0);
257 MODULE_PARM_DESC(board3, "Board 3 config -> name[,ioaddr[,ioaddr2][,irq]]");
258
259 /*****************************************************************************/
260
261 /*
262  *      Hardware ID bits for the EasyIO and ECH boards. These defines apply
263  *      to the directly accessible io ports of these boards (not the uarts -
264  *      they are in cd1400.h and sc26198.h).
265  */
266 #define EIO_8PORTRS     0x04
267 #define EIO_4PORTRS     0x05
268 #define EIO_8PORTDI     0x00
269 #define EIO_8PORTM      0x06
270 #define EIO_MK3         0x03
271 #define EIO_IDBITMASK   0x07
272
273 #define EIO_BRDMASK     0xf0
274 #define ID_BRD4         0x10
275 #define ID_BRD8         0x20
276 #define ID_BRD16        0x30
277
278 #define EIO_INTRPEND    0x08
279 #define EIO_INTEDGE     0x00
280 #define EIO_INTLEVEL    0x08
281 #define EIO_0WS         0x10
282
283 #define ECH_ID          0xa0
284 #define ECH_IDBITMASK   0xe0
285 #define ECH_BRDENABLE   0x08
286 #define ECH_BRDDISABLE  0x00
287 #define ECH_INTENABLE   0x01
288 #define ECH_INTDISABLE  0x00
289 #define ECH_INTLEVEL    0x02
290 #define ECH_INTEDGE     0x00
291 #define ECH_INTRPEND    0x01
292 #define ECH_BRDRESET    0x01
293
294 #define ECHMC_INTENABLE 0x01
295 #define ECHMC_BRDRESET  0x02
296
297 #define ECH_PNLSTATUS   2
298 #define ECH_PNL16PORT   0x20
299 #define ECH_PNLIDMASK   0x07
300 #define ECH_PNLXPID     0x40
301 #define ECH_PNLINTRPEND 0x80
302
303 #define ECH_ADDR2MASK   0x1e0
304
305 /*
306  *      Define the vector mapping bits for the programmable interrupt board
307  *      hardware. These bits encode the interrupt for the board to use - it
308  *      is software selectable (except the EIO-8M).
309  */
310 static unsigned char    stl_vecmap[] = {
311         0xff, 0xff, 0xff, 0x04, 0x06, 0x05, 0xff, 0x07,
312         0xff, 0xff, 0x00, 0x02, 0x01, 0xff, 0xff, 0x03
313 };
314
315 /*
316  *      Lock ordering is that you may not take stallion_lock holding
317  *      brd_lock.
318  */
319
320 static spinlock_t brd_lock;             /* Guard the board mapping */
321 static spinlock_t stallion_lock;        /* Guard the tty driver */
322
323 /*
324  *      Set up enable and disable macros for the ECH boards. They require
325  *      the secondary io address space to be activated and deactivated.
326  *      This way all ECH boards can share their secondary io region.
327  *      If this is an ECH-PCI board then also need to set the page pointer
328  *      to point to the correct page.
329  */
330 #define BRDENABLE(brdnr,pagenr)                                         \
331         if (stl_brds[(brdnr)]->brdtype == BRD_ECH)                      \
332                 outb((stl_brds[(brdnr)]->ioctrlval | ECH_BRDENABLE),    \
333                         stl_brds[(brdnr)]->ioctrl);                     \
334         else if (stl_brds[(brdnr)]->brdtype == BRD_ECHPCI)              \
335                 outb((pagenr), stl_brds[(brdnr)]->ioctrl);
336
337 #define BRDDISABLE(brdnr)                                               \
338         if (stl_brds[(brdnr)]->brdtype == BRD_ECH)                      \
339                 outb((stl_brds[(brdnr)]->ioctrlval | ECH_BRDDISABLE),   \
340                         stl_brds[(brdnr)]->ioctrl);
341
342 #define STL_CD1400MAXBAUD       230400
343 #define STL_SC26198MAXBAUD      460800
344
345 #define STL_BAUDBASE            115200
346 #define STL_CLOSEDELAY          (5 * HZ / 10)
347
348 /*****************************************************************************/
349
350 /*
351  *      Define the Stallion PCI vendor and device IDs.
352  */
353 #ifndef PCI_VENDOR_ID_STALLION
354 #define PCI_VENDOR_ID_STALLION          0x124d
355 #endif
356 #ifndef PCI_DEVICE_ID_ECHPCI832
357 #define PCI_DEVICE_ID_ECHPCI832         0x0000
358 #endif
359 #ifndef PCI_DEVICE_ID_ECHPCI864
360 #define PCI_DEVICE_ID_ECHPCI864         0x0002
361 #endif
362 #ifndef PCI_DEVICE_ID_EIOPCI
363 #define PCI_DEVICE_ID_EIOPCI            0x0003
364 #endif
365
366 /*
367  *      Define structure to hold all Stallion PCI boards.
368  */
369
370 static struct pci_device_id stl_pcibrds[] = {
371         { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI864),
372                 .driver_data = BRD_ECH64PCI },
373         { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_EIOPCI),
374                 .driver_data = BRD_EASYIOPCI },
375         { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI832),
376                 .driver_data = BRD_ECHPCI },
377         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_87410),
378                 .driver_data = BRD_ECHPCI },
379         { }
380 };
381 MODULE_DEVICE_TABLE(pci, stl_pcibrds);
382
383 /*****************************************************************************/
384
385 /*
386  *      Define macros to extract a brd/port number from a minor number.
387  */
388 #define MINOR2BRD(min)          (((min) & 0xc0) >> 6)
389 #define MINOR2PORT(min)         ((min) & 0x3f)
390
391 /*
392  *      Define a baud rate table that converts termios baud rate selector
393  *      into the actual baud rate value. All baud rate calculations are
394  *      based on the actual baud rate required.
395  */
396 static unsigned int     stl_baudrates[] = {
397         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
398         9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600
399 };
400
401 /*****************************************************************************/
402
403 /*
404  *      Declare all those functions in this driver!
405  */
406
407 static int      stl_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg);
408 static int      stl_brdinit(struct stlbrd *brdp);
409 static int      stl_getportstats(struct stlport *portp, comstats_t __user *cp);
410 static int      stl_clrportstats(struct stlport *portp, comstats_t __user *cp);
411 static int      stl_waitcarrier(struct stlport *portp, struct file *filp);
412
413 /*
414  *      CD1400 uart specific handling functions.
415  */
416 static void     stl_cd1400setreg(struct stlport *portp, int regnr, int value);
417 static int      stl_cd1400getreg(struct stlport *portp, int regnr);
418 static int      stl_cd1400updatereg(struct stlport *portp, int regnr, int value);
419 static int      stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp);
420 static void     stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
421 static void     stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp);
422 static int      stl_cd1400getsignals(struct stlport *portp);
423 static void     stl_cd1400setsignals(struct stlport *portp, int dtr, int rts);
424 static void     stl_cd1400ccrwait(struct stlport *portp);
425 static void     stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx);
426 static void     stl_cd1400startrxtx(struct stlport *portp, int rx, int tx);
427 static void     stl_cd1400disableintrs(struct stlport *portp);
428 static void     stl_cd1400sendbreak(struct stlport *portp, int len);
429 static void     stl_cd1400flowctrl(struct stlport *portp, int state);
430 static void     stl_cd1400sendflow(struct stlport *portp, int state);
431 static void     stl_cd1400flush(struct stlport *portp);
432 static int      stl_cd1400datastate(struct stlport *portp);
433 static void     stl_cd1400eiointr(struct stlpanel *panelp, unsigned int iobase);
434 static void     stl_cd1400echintr(struct stlpanel *panelp, unsigned int iobase);
435 static void     stl_cd1400txisr(struct stlpanel *panelp, int ioaddr);
436 static void     stl_cd1400rxisr(struct stlpanel *panelp, int ioaddr);
437 static void     stl_cd1400mdmisr(struct stlpanel *panelp, int ioaddr);
438
439 static inline int       stl_cd1400breakisr(struct stlport *portp, int ioaddr);
440
441 /*
442  *      SC26198 uart specific handling functions.
443  */
444 static void     stl_sc26198setreg(struct stlport *portp, int regnr, int value);
445 static int      stl_sc26198getreg(struct stlport *portp, int regnr);
446 static int      stl_sc26198updatereg(struct stlport *portp, int regnr, int value);
447 static int      stl_sc26198getglobreg(struct stlport *portp, int regnr);
448 static int      stl_sc26198panelinit(struct stlbrd *brdp, struct stlpanel *panelp);
449 static void     stl_sc26198portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
450 static void     stl_sc26198setport(struct stlport *portp, struct ktermios *tiosp);
451 static int      stl_sc26198getsignals(struct stlport *portp);
452 static void     stl_sc26198setsignals(struct stlport *portp, int dtr, int rts);
453 static void     stl_sc26198enablerxtx(struct stlport *portp, int rx, int tx);
454 static void     stl_sc26198startrxtx(struct stlport *portp, int rx, int tx);
455 static void     stl_sc26198disableintrs(struct stlport *portp);
456 static void     stl_sc26198sendbreak(struct stlport *portp, int len);
457 static void     stl_sc26198flowctrl(struct stlport *portp, int state);
458 static void     stl_sc26198sendflow(struct stlport *portp, int state);
459 static void     stl_sc26198flush(struct stlport *portp);
460 static int      stl_sc26198datastate(struct stlport *portp);
461 static void     stl_sc26198wait(struct stlport *portp);
462 static void     stl_sc26198txunflow(struct stlport *portp, struct tty_struct *tty);
463 static void     stl_sc26198intr(struct stlpanel *panelp, unsigned int iobase);
464 static void     stl_sc26198txisr(struct stlport *port);
465 static void     stl_sc26198rxisr(struct stlport *port, unsigned int iack);
466 static void     stl_sc26198rxbadch(struct stlport *portp, unsigned char status, char ch);
467 static void     stl_sc26198rxbadchars(struct stlport *portp);
468 static void     stl_sc26198otherisr(struct stlport *port, unsigned int iack);
469
470 /*****************************************************************************/
471
472 /*
473  *      Generic UART support structure.
474  */
475 typedef struct uart {
476         int     (*panelinit)(struct stlbrd *brdp, struct stlpanel *panelp);
477         void    (*portinit)(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
478         void    (*setport)(struct stlport *portp, struct ktermios *tiosp);
479         int     (*getsignals)(struct stlport *portp);
480         void    (*setsignals)(struct stlport *portp, int dtr, int rts);
481         void    (*enablerxtx)(struct stlport *portp, int rx, int tx);
482         void    (*startrxtx)(struct stlport *portp, int rx, int tx);
483         void    (*disableintrs)(struct stlport *portp);
484         void    (*sendbreak)(struct stlport *portp, int len);
485         void    (*flowctrl)(struct stlport *portp, int state);
486         void    (*sendflow)(struct stlport *portp, int state);
487         void    (*flush)(struct stlport *portp);
488         int     (*datastate)(struct stlport *portp);
489         void    (*intr)(struct stlpanel *panelp, unsigned int iobase);
490 } uart_t;
491
492 /*
493  *      Define some macros to make calling these functions nice and clean.
494  */
495 #define stl_panelinit           (* ((uart_t *) panelp->uartp)->panelinit)
496 #define stl_portinit            (* ((uart_t *) portp->uartp)->portinit)
497 #define stl_setport             (* ((uart_t *) portp->uartp)->setport)
498 #define stl_getsignals          (* ((uart_t *) portp->uartp)->getsignals)
499 #define stl_setsignals          (* ((uart_t *) portp->uartp)->setsignals)
500 #define stl_enablerxtx          (* ((uart_t *) portp->uartp)->enablerxtx)
501 #define stl_startrxtx           (* ((uart_t *) portp->uartp)->startrxtx)
502 #define stl_disableintrs        (* ((uart_t *) portp->uartp)->disableintrs)
503 #define stl_sendbreak           (* ((uart_t *) portp->uartp)->sendbreak)
504 #define stl_flowctrl            (* ((uart_t *) portp->uartp)->flowctrl)
505 #define stl_sendflow            (* ((uart_t *) portp->uartp)->sendflow)
506 #define stl_flush               (* ((uart_t *) portp->uartp)->flush)
507 #define stl_datastate           (* ((uart_t *) portp->uartp)->datastate)
508
509 /*****************************************************************************/
510
511 /*
512  *      CD1400 UART specific data initialization.
513  */
514 static uart_t stl_cd1400uart = {
515         stl_cd1400panelinit,
516         stl_cd1400portinit,
517         stl_cd1400setport,
518         stl_cd1400getsignals,
519         stl_cd1400setsignals,
520         stl_cd1400enablerxtx,
521         stl_cd1400startrxtx,
522         stl_cd1400disableintrs,
523         stl_cd1400sendbreak,
524         stl_cd1400flowctrl,
525         stl_cd1400sendflow,
526         stl_cd1400flush,
527         stl_cd1400datastate,
528         stl_cd1400eiointr
529 };
530
531 /*
532  *      Define the offsets within the register bank of a cd1400 based panel.
533  *      These io address offsets are common to the EasyIO board as well.
534  */
535 #define EREG_ADDR       0
536 #define EREG_DATA       4
537 #define EREG_RXACK      5
538 #define EREG_TXACK      6
539 #define EREG_MDACK      7
540
541 #define EREG_BANKSIZE   8
542
543 #define CD1400_CLK      25000000
544 #define CD1400_CLK8M    20000000
545
546 /*
547  *      Define the cd1400 baud rate clocks. These are used when calculating
548  *      what clock and divisor to use for the required baud rate. Also
549  *      define the maximum baud rate allowed, and the default base baud.
550  */
551 static int      stl_cd1400clkdivs[] = {
552         CD1400_CLK0, CD1400_CLK1, CD1400_CLK2, CD1400_CLK3, CD1400_CLK4
553 };
554
555 /*****************************************************************************/
556
557 /*
558  *      SC26198 UART specific data initization.
559  */
560 static uart_t stl_sc26198uart = {
561         stl_sc26198panelinit,
562         stl_sc26198portinit,
563         stl_sc26198setport,
564         stl_sc26198getsignals,
565         stl_sc26198setsignals,
566         stl_sc26198enablerxtx,
567         stl_sc26198startrxtx,
568         stl_sc26198disableintrs,
569         stl_sc26198sendbreak,
570         stl_sc26198flowctrl,
571         stl_sc26198sendflow,
572         stl_sc26198flush,
573         stl_sc26198datastate,
574         stl_sc26198intr
575 };
576
577 /*
578  *      Define the offsets within the register bank of a sc26198 based panel.
579  */
580 #define XP_DATA         0
581 #define XP_ADDR         1
582 #define XP_MODID        2
583 #define XP_STATUS       2
584 #define XP_IACK         3
585
586 #define XP_BANKSIZE     4
587
588 /*
589  *      Define the sc26198 baud rate table. Offsets within the table
590  *      represent the actual baud rate selector of sc26198 registers.
591  */
592 static unsigned int     sc26198_baudtable[] = {
593         50, 75, 150, 200, 300, 450, 600, 900, 1200, 1800, 2400, 3600,
594         4800, 7200, 9600, 14400, 19200, 28800, 38400, 57600, 115200,
595         230400, 460800, 921600
596 };
597
598 #define SC26198_NRBAUDS         ARRAY_SIZE(sc26198_baudtable)
599
600 /*****************************************************************************/
601
602 /*
603  *      Define the driver info for a user level control device. Used mainly
604  *      to get at port stats - only not using the port device itself.
605  */
606 static const struct file_operations     stl_fsiomem = {
607         .owner          = THIS_MODULE,
608         .ioctl          = stl_memioctl,
609 };
610
611 static struct class *stallion_class;
612
613 /*
614  *      Check for any arguments passed in on the module load command line.
615  */
616
617 /*****************************************************************************/
618
619 /*
620  *      Parse the supplied argument string, into the board conf struct.
621  */
622
623 static int __init stl_parsebrd(struct stlconf *confp, char **argp)
624 {
625         char    *sp;
626         unsigned int i;
627
628         pr_debug("stl_parsebrd(confp=%p,argp=%p)\n", confp, argp);
629
630         if ((argp[0] == NULL) || (*argp[0] == 0))
631                 return 0;
632
633         for (sp = argp[0], i = 0; (*sp != 0) && (i < 25); sp++, i++)
634                 *sp = tolower(*sp);
635
636         for (i = 0; i < ARRAY_SIZE(stl_brdstr); i++)
637                 if (strcmp(stl_brdstr[i].name, argp[0]) == 0)
638                         break;
639
640         if (i == ARRAY_SIZE(stl_brdstr)) {
641                 printk("STALLION: unknown board name, %s?\n", argp[0]);
642                 return 0;
643         }
644
645         confp->brdtype = stl_brdstr[i].type;
646
647         i = 1;
648         if ((argp[i] != NULL) && (*argp[i] != 0))
649                 confp->ioaddr1 = simple_strtoul(argp[i], NULL, 0);
650         i++;
651         if (confp->brdtype == BRD_ECH) {
652                 if ((argp[i] != NULL) && (*argp[i] != 0))
653                         confp->ioaddr2 = simple_strtoul(argp[i], NULL, 0);
654                 i++;
655         }
656         if ((argp[i] != NULL) && (*argp[i] != 0))
657                 confp->irq = simple_strtoul(argp[i], NULL, 0);
658         return 1;
659 }
660
661 /*****************************************************************************/
662
663 /*
664  *      Allocate a new board structure. Fill out the basic info in it.
665  */
666
667 static struct stlbrd *stl_allocbrd(void)
668 {
669         struct stlbrd   *brdp;
670
671         brdp = kzalloc(sizeof(struct stlbrd), GFP_KERNEL);
672         if (!brdp) {
673                 printk("STALLION: failed to allocate memory (size=%Zd)\n",
674                         sizeof(struct stlbrd));
675                 return NULL;
676         }
677
678         brdp->magic = STL_BOARDMAGIC;
679         return brdp;
680 }
681
682 /*****************************************************************************/
683
684 static int stl_open(struct tty_struct *tty, struct file *filp)
685 {
686         struct stlport  *portp;
687         struct stlbrd   *brdp;
688         unsigned int    minordev, brdnr, panelnr;
689         int             portnr, rc;
690
691         pr_debug("stl_open(tty=%p,filp=%p): device=%s\n", tty, filp, tty->name);
692
693         minordev = tty->index;
694         brdnr = MINOR2BRD(minordev);
695         if (brdnr >= stl_nrbrds)
696                 return -ENODEV;
697         brdp = stl_brds[brdnr];
698         if (brdp == NULL)
699                 return -ENODEV;
700         minordev = MINOR2PORT(minordev);
701         for (portnr = -1, panelnr = 0; panelnr < STL_MAXPANELS; panelnr++) {
702                 if (brdp->panels[panelnr] == NULL)
703                         break;
704                 if (minordev < brdp->panels[panelnr]->nrports) {
705                         portnr = minordev;
706                         break;
707                 }
708                 minordev -= brdp->panels[panelnr]->nrports;
709         }
710         if (portnr < 0)
711                 return -ENODEV;
712
713         portp = brdp->panels[panelnr]->ports[portnr];
714         if (portp == NULL)
715                 return -ENODEV;
716
717 /*
718  *      On the first open of the device setup the port hardware, and
719  *      initialize the per port data structure.
720  */
721         portp->tty = tty;
722         tty->driver_data = portp;
723         portp->refcount++;
724
725         if ((portp->flags & ASYNC_INITIALIZED) == 0) {
726                 if (!portp->tx.buf) {
727                         portp->tx.buf = kmalloc(STL_TXBUFSIZE, GFP_KERNEL);
728                         if (!portp->tx.buf)
729                                 return -ENOMEM;
730                         portp->tx.head = portp->tx.buf;
731                         portp->tx.tail = portp->tx.buf;
732                 }
733                 stl_setport(portp, tty->termios);
734                 portp->sigs = stl_getsignals(portp);
735                 stl_setsignals(portp, 1, 1);
736                 stl_enablerxtx(portp, 1, 1);
737                 stl_startrxtx(portp, 1, 0);
738                 clear_bit(TTY_IO_ERROR, &tty->flags);
739                 portp->flags |= ASYNC_INITIALIZED;
740         }
741
742 /*
743  *      Check if this port is in the middle of closing. If so then wait
744  *      until it is closed then return error status, based on flag settings.
745  *      The sleep here does not need interrupt protection since the wakeup
746  *      for it is done with the same context.
747  */
748         if (portp->flags & ASYNC_CLOSING) {
749                 interruptible_sleep_on(&portp->close_wait);
750                 if (portp->flags & ASYNC_HUP_NOTIFY)
751                         return -EAGAIN;
752                 return -ERESTARTSYS;
753         }
754
755 /*
756  *      Based on type of open being done check if it can overlap with any
757  *      previous opens still in effect. If we are a normal serial device
758  *      then also we might have to wait for carrier.
759  */
760         if (!(filp->f_flags & O_NONBLOCK))
761                 if ((rc = stl_waitcarrier(portp, filp)) != 0)
762                         return rc;
763
764         portp->flags |= ASYNC_NORMAL_ACTIVE;
765
766         return 0;
767 }
768
769 /*****************************************************************************/
770
771 /*
772  *      Possibly need to wait for carrier (DCD signal) to come high. Say
773  *      maybe because if we are clocal then we don't need to wait...
774  */
775
776 static int stl_waitcarrier(struct stlport *portp, struct file *filp)
777 {
778         unsigned long   flags;
779         int             rc, doclocal;
780
781         pr_debug("stl_waitcarrier(portp=%p,filp=%p)\n", portp, filp);
782
783         rc = 0;
784         doclocal = 0;
785
786         spin_lock_irqsave(&stallion_lock, flags);
787
788         if (portp->tty->termios->c_cflag & CLOCAL)
789                 doclocal++;
790
791         portp->openwaitcnt++;
792         if (! tty_hung_up_p(filp))
793                 portp->refcount--;
794
795         for (;;) {
796                 /* Takes brd_lock internally */
797                 stl_setsignals(portp, 1, 1);
798                 if (tty_hung_up_p(filp) ||
799                     ((portp->flags & ASYNC_INITIALIZED) == 0)) {
800                         if (portp->flags & ASYNC_HUP_NOTIFY)
801                                 rc = -EBUSY;
802                         else
803                                 rc = -ERESTARTSYS;
804                         break;
805                 }
806                 if (((portp->flags & ASYNC_CLOSING) == 0) &&
807                     (doclocal || (portp->sigs & TIOCM_CD)))
808                         break;
809                 if (signal_pending(current)) {
810                         rc = -ERESTARTSYS;
811                         break;
812                 }
813                 /* FIXME */
814                 interruptible_sleep_on(&portp->open_wait);
815         }
816
817         if (! tty_hung_up_p(filp))
818                 portp->refcount++;
819         portp->openwaitcnt--;
820         spin_unlock_irqrestore(&stallion_lock, flags);
821
822         return rc;
823 }
824
825 /*****************************************************************************/
826
827 static void stl_flushbuffer(struct tty_struct *tty)
828 {
829         struct stlport  *portp;
830
831         pr_debug("stl_flushbuffer(tty=%p)\n", tty);
832
833         if (tty == NULL)
834                 return;
835         portp = tty->driver_data;
836         if (portp == NULL)
837                 return;
838
839         stl_flush(portp);
840         tty_wakeup(tty);
841 }
842
843 /*****************************************************************************/
844
845 static void stl_waituntilsent(struct tty_struct *tty, int timeout)
846 {
847         struct stlport  *portp;
848         unsigned long   tend;
849
850         pr_debug("stl_waituntilsent(tty=%p,timeout=%d)\n", tty, timeout);
851
852         if (tty == NULL)
853                 return;
854         portp = tty->driver_data;
855         if (portp == NULL)
856                 return;
857
858         if (timeout == 0)
859                 timeout = HZ;
860         tend = jiffies + timeout;
861
862         while (stl_datastate(portp)) {
863                 if (signal_pending(current))
864                         break;
865                 msleep_interruptible(20);
866                 if (time_after_eq(jiffies, tend))
867                         break;
868         }
869 }
870
871 /*****************************************************************************/
872
873 static void stl_close(struct tty_struct *tty, struct file *filp)
874 {
875         struct stlport  *portp;
876         unsigned long   flags;
877
878         pr_debug("stl_close(tty=%p,filp=%p)\n", tty, filp);
879
880         portp = tty->driver_data;
881         if (portp == NULL)
882                 return;
883
884         spin_lock_irqsave(&stallion_lock, flags);
885         if (tty_hung_up_p(filp)) {
886                 spin_unlock_irqrestore(&stallion_lock, flags);
887                 return;
888         }
889         if ((tty->count == 1) && (portp->refcount != 1))
890                 portp->refcount = 1;
891         if (portp->refcount-- > 1) {
892                 spin_unlock_irqrestore(&stallion_lock, flags);
893                 return;
894         }
895
896         portp->refcount = 0;
897         portp->flags |= ASYNC_CLOSING;
898
899 /*
900  *      May want to wait for any data to drain before closing. The BUSY
901  *      flag keeps track of whether we are still sending or not - it is
902  *      very accurate for the cd1400, not quite so for the sc26198.
903  *      (The sc26198 has no "end-of-data" interrupt only empty FIFO)
904  */
905         tty->closing = 1;
906
907         spin_unlock_irqrestore(&stallion_lock, flags);
908
909         if (portp->closing_wait != ASYNC_CLOSING_WAIT_NONE)
910                 tty_wait_until_sent(tty, portp->closing_wait);
911         stl_waituntilsent(tty, (HZ / 2));
912
913
914         spin_lock_irqsave(&stallion_lock, flags);
915         portp->flags &= ~ASYNC_INITIALIZED;
916         spin_unlock_irqrestore(&stallion_lock, flags);
917
918         stl_disableintrs(portp);
919         if (tty->termios->c_cflag & HUPCL)
920                 stl_setsignals(portp, 0, 0);
921         stl_enablerxtx(portp, 0, 0);
922         stl_flushbuffer(tty);
923         portp->istate = 0;
924         if (portp->tx.buf != NULL) {
925                 kfree(portp->tx.buf);
926                 portp->tx.buf = NULL;
927                 portp->tx.head = NULL;
928                 portp->tx.tail = NULL;
929         }
930         set_bit(TTY_IO_ERROR, &tty->flags);
931         tty_ldisc_flush(tty);
932
933         tty->closing = 0;
934         portp->tty = NULL;
935
936         if (portp->openwaitcnt) {
937                 if (portp->close_delay)
938                         msleep_interruptible(jiffies_to_msecs(portp->close_delay));
939                 wake_up_interruptible(&portp->open_wait);
940         }
941
942         portp->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
943         wake_up_interruptible(&portp->close_wait);
944 }
945
946 /*****************************************************************************/
947
948 /*
949  *      Write routine. Take data and stuff it in to the TX ring queue.
950  *      If transmit interrupts are not running then start them.
951  */
952
953 static int stl_write(struct tty_struct *tty, const unsigned char *buf, int count)
954 {
955         struct stlport  *portp;
956         unsigned int    len, stlen;
957         unsigned char   *chbuf;
958         char            *head, *tail;
959
960         pr_debug("stl_write(tty=%p,buf=%p,count=%d)\n", tty, buf, count);
961
962         portp = tty->driver_data;
963         if (portp == NULL)
964                 return 0;
965         if (portp->tx.buf == NULL)
966                 return 0;
967
968 /*
969  *      If copying direct from user space we must cater for page faults,
970  *      causing us to "sleep" here for a while. To handle this copy in all
971  *      the data we need now, into a local buffer. Then when we got it all
972  *      copy it into the TX buffer.
973  */
974         chbuf = (unsigned char *) buf;
975
976         head = portp->tx.head;
977         tail = portp->tx.tail;
978         if (head >= tail) {
979                 len = STL_TXBUFSIZE - (head - tail) - 1;
980                 stlen = STL_TXBUFSIZE - (head - portp->tx.buf);
981         } else {
982                 len = tail - head - 1;
983                 stlen = len;
984         }
985
986         len = min(len, (unsigned int)count);
987         count = 0;
988         while (len > 0) {
989                 stlen = min(len, stlen);
990                 memcpy(head, chbuf, stlen);
991                 len -= stlen;
992                 chbuf += stlen;
993                 count += stlen;
994                 head += stlen;
995                 if (head >= (portp->tx.buf + STL_TXBUFSIZE)) {
996                         head = portp->tx.buf;
997                         stlen = tail - head;
998                 }
999         }
1000         portp->tx.head = head;
1001
1002         clear_bit(ASYI_TXLOW, &portp->istate);
1003         stl_startrxtx(portp, -1, 1);
1004
1005         return count;
1006 }
1007
1008 /*****************************************************************************/
1009
1010 static void stl_putchar(struct tty_struct *tty, unsigned char ch)
1011 {
1012         struct stlport  *portp;
1013         unsigned int    len;
1014         char            *head, *tail;
1015
1016         pr_debug("stl_putchar(tty=%p,ch=%x)\n", tty, ch);
1017
1018         if (tty == NULL)
1019                 return;
1020         portp = tty->driver_data;
1021         if (portp == NULL)
1022                 return;
1023         if (portp->tx.buf == NULL)
1024                 return;
1025
1026         head = portp->tx.head;
1027         tail = portp->tx.tail;
1028
1029         len = (head >= tail) ? (STL_TXBUFSIZE - (head - tail)) : (tail - head);
1030         len--;
1031
1032         if (len > 0) {
1033                 *head++ = ch;
1034                 if (head >= (portp->tx.buf + STL_TXBUFSIZE))
1035                         head = portp->tx.buf;
1036         }       
1037         portp->tx.head = head;
1038 }
1039
1040 /*****************************************************************************/
1041
1042 /*
1043  *      If there are any characters in the buffer then make sure that TX
1044  *      interrupts are on and get'em out. Normally used after the putchar
1045  *      routine has been called.
1046  */
1047
1048 static void stl_flushchars(struct tty_struct *tty)
1049 {
1050         struct stlport  *portp;
1051
1052         pr_debug("stl_flushchars(tty=%p)\n", tty);
1053
1054         if (tty == NULL)
1055                 return;
1056         portp = tty->driver_data;
1057         if (portp == NULL)
1058                 return;
1059         if (portp->tx.buf == NULL)
1060                 return;
1061
1062         stl_startrxtx(portp, -1, 1);
1063 }
1064
1065 /*****************************************************************************/
1066
1067 static int stl_writeroom(struct tty_struct *tty)
1068 {
1069         struct stlport  *portp;
1070         char            *head, *tail;
1071
1072         pr_debug("stl_writeroom(tty=%p)\n", tty);
1073
1074         if (tty == NULL)
1075                 return 0;
1076         portp = tty->driver_data;
1077         if (portp == NULL)
1078                 return 0;
1079         if (portp->tx.buf == NULL)
1080                 return 0;
1081
1082         head = portp->tx.head;
1083         tail = portp->tx.tail;
1084         return (head >= tail) ? (STL_TXBUFSIZE - (head - tail) - 1) : (tail - head - 1);
1085 }
1086
1087 /*****************************************************************************/
1088
1089 /*
1090  *      Return number of chars in the TX buffer. Normally we would just
1091  *      calculate the number of chars in the buffer and return that, but if
1092  *      the buffer is empty and TX interrupts are still on then we return
1093  *      that the buffer still has 1 char in it. This way whoever called us
1094  *      will not think that ALL chars have drained - since the UART still
1095  *      must have some chars in it (we are busy after all).
1096  */
1097
1098 static int stl_charsinbuffer(struct tty_struct *tty)
1099 {
1100         struct stlport  *portp;
1101         unsigned int    size;
1102         char            *head, *tail;
1103
1104         pr_debug("stl_charsinbuffer(tty=%p)\n", tty);
1105
1106         if (tty == NULL)
1107                 return 0;
1108         portp = tty->driver_data;
1109         if (portp == NULL)
1110                 return 0;
1111         if (portp->tx.buf == NULL)
1112                 return 0;
1113
1114         head = portp->tx.head;
1115         tail = portp->tx.tail;
1116         size = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
1117         if ((size == 0) && test_bit(ASYI_TXBUSY, &portp->istate))
1118                 size = 1;
1119         return size;
1120 }
1121
1122 /*****************************************************************************/
1123
1124 /*
1125  *      Generate the serial struct info.
1126  */
1127
1128 static int stl_getserial(struct stlport *portp, struct serial_struct __user *sp)
1129 {
1130         struct serial_struct    sio;
1131         struct stlbrd           *brdp;
1132
1133         pr_debug("stl_getserial(portp=%p,sp=%p)\n", portp, sp);
1134
1135         memset(&sio, 0, sizeof(struct serial_struct));
1136         sio.line = portp->portnr;
1137         sio.port = portp->ioaddr;
1138         sio.flags = portp->flags;
1139         sio.baud_base = portp->baud_base;
1140         sio.close_delay = portp->close_delay;
1141         sio.closing_wait = portp->closing_wait;
1142         sio.custom_divisor = portp->custom_divisor;
1143         sio.hub6 = 0;
1144         if (portp->uartp == &stl_cd1400uart) {
1145                 sio.type = PORT_CIRRUS;
1146                 sio.xmit_fifo_size = CD1400_TXFIFOSIZE;
1147         } else {
1148                 sio.type = PORT_UNKNOWN;
1149                 sio.xmit_fifo_size = SC26198_TXFIFOSIZE;
1150         }
1151
1152         brdp = stl_brds[portp->brdnr];
1153         if (brdp != NULL)
1154                 sio.irq = brdp->irq;
1155
1156         return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ? -EFAULT : 0;
1157 }
1158
1159 /*****************************************************************************/
1160
1161 /*
1162  *      Set port according to the serial struct info.
1163  *      At this point we do not do any auto-configure stuff, so we will
1164  *      just quietly ignore any requests to change irq, etc.
1165  */
1166
1167 static int stl_setserial(struct stlport *portp, struct serial_struct __user *sp)
1168 {
1169         struct serial_struct    sio;
1170
1171         pr_debug("stl_setserial(portp=%p,sp=%p)\n", portp, sp);
1172
1173         if (copy_from_user(&sio, sp, sizeof(struct serial_struct)))
1174                 return -EFAULT;
1175         if (!capable(CAP_SYS_ADMIN)) {
1176                 if ((sio.baud_base != portp->baud_base) ||
1177                     (sio.close_delay != portp->close_delay) ||
1178                     ((sio.flags & ~ASYNC_USR_MASK) !=
1179                     (portp->flags & ~ASYNC_USR_MASK)))
1180                         return -EPERM;
1181         } 
1182
1183         portp->flags = (portp->flags & ~ASYNC_USR_MASK) |
1184                 (sio.flags & ASYNC_USR_MASK);
1185         portp->baud_base = sio.baud_base;
1186         portp->close_delay = sio.close_delay;
1187         portp->closing_wait = sio.closing_wait;
1188         portp->custom_divisor = sio.custom_divisor;
1189         stl_setport(portp, portp->tty->termios);
1190         return 0;
1191 }
1192
1193 /*****************************************************************************/
1194
1195 static int stl_tiocmget(struct tty_struct *tty, struct file *file)
1196 {
1197         struct stlport  *portp;
1198
1199         if (tty == NULL)
1200                 return -ENODEV;
1201         portp = tty->driver_data;
1202         if (portp == NULL)
1203                 return -ENODEV;
1204         if (tty->flags & (1 << TTY_IO_ERROR))
1205                 return -EIO;
1206
1207         return stl_getsignals(portp);
1208 }
1209
1210 static int stl_tiocmset(struct tty_struct *tty, struct file *file,
1211                         unsigned int set, unsigned int clear)
1212 {
1213         struct stlport  *portp;
1214         int rts = -1, dtr = -1;
1215
1216         if (tty == NULL)
1217                 return -ENODEV;
1218         portp = tty->driver_data;
1219         if (portp == NULL)
1220                 return -ENODEV;
1221         if (tty->flags & (1 << TTY_IO_ERROR))
1222                 return -EIO;
1223
1224         if (set & TIOCM_RTS)
1225                 rts = 1;
1226         if (set & TIOCM_DTR)
1227                 dtr = 1;
1228         if (clear & TIOCM_RTS)
1229                 rts = 0;
1230         if (clear & TIOCM_DTR)
1231                 dtr = 0;
1232
1233         stl_setsignals(portp, dtr, rts);
1234         return 0;
1235 }
1236
1237 static int stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
1238 {
1239         struct stlport  *portp;
1240         unsigned int    ival;
1241         int             rc;
1242         void __user *argp = (void __user *)arg;
1243
1244         pr_debug("stl_ioctl(tty=%p,file=%p,cmd=%x,arg=%lx)\n", tty, file, cmd,
1245                         arg);
1246
1247         if (tty == NULL)
1248                 return -ENODEV;
1249         portp = tty->driver_data;
1250         if (portp == NULL)
1251                 return -ENODEV;
1252
1253         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
1254             (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS))
1255                 if (tty->flags & (1 << TTY_IO_ERROR))
1256                         return -EIO;
1257
1258         rc = 0;
1259
1260         switch (cmd) {
1261         case TIOCGSOFTCAR:
1262                 rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
1263                         (unsigned __user *) argp);
1264                 break;
1265         case TIOCSSOFTCAR:
1266                 if (get_user(ival, (unsigned int __user *) arg))
1267                         return -EFAULT;
1268                 tty->termios->c_cflag =
1269                                 (tty->termios->c_cflag & ~CLOCAL) |
1270                                 (ival ? CLOCAL : 0);
1271                 break;
1272         case TIOCGSERIAL:
1273                 rc = stl_getserial(portp, argp);
1274                 break;
1275         case TIOCSSERIAL:
1276                 rc = stl_setserial(portp, argp);
1277                 break;
1278         case COM_GETPORTSTATS:
1279                 rc = stl_getportstats(portp, argp);
1280                 break;
1281         case COM_CLRPORTSTATS:
1282                 rc = stl_clrportstats(portp, argp);
1283                 break;
1284         case TIOCSERCONFIG:
1285         case TIOCSERGWILD:
1286         case TIOCSERSWILD:
1287         case TIOCSERGETLSR:
1288         case TIOCSERGSTRUCT:
1289         case TIOCSERGETMULTI:
1290         case TIOCSERSETMULTI:
1291         default:
1292                 rc = -ENOIOCTLCMD;
1293                 break;
1294         }
1295
1296         return rc;
1297 }
1298
1299 /*****************************************************************************/
1300
1301 /*
1302  *      Start the transmitter again. Just turn TX interrupts back on.
1303  */
1304
1305 static void stl_start(struct tty_struct *tty)
1306 {
1307         struct stlport  *portp;
1308
1309         pr_debug("stl_start(tty=%p)\n", tty);
1310
1311         if (tty == NULL)
1312                 return;
1313         portp = tty->driver_data;
1314         if (portp == NULL)
1315                 return;
1316         stl_startrxtx(portp, -1, 1);
1317 }
1318
1319 /*****************************************************************************/
1320
1321 static void stl_settermios(struct tty_struct *tty, struct ktermios *old)
1322 {
1323         struct stlport  *portp;
1324         struct ktermios *tiosp;
1325
1326         pr_debug("stl_settermios(tty=%p,old=%p)\n", tty, old);
1327
1328         if (tty == NULL)
1329                 return;
1330         portp = tty->driver_data;
1331         if (portp == NULL)
1332                 return;
1333
1334         tiosp = tty->termios;
1335         if ((tiosp->c_cflag == old->c_cflag) &&
1336             (tiosp->c_iflag == old->c_iflag))
1337                 return;
1338
1339         stl_setport(portp, tiosp);
1340         stl_setsignals(portp, ((tiosp->c_cflag & (CBAUD & ~CBAUDEX)) ? 1 : 0),
1341                 -1);
1342         if ((old->c_cflag & CRTSCTS) && ((tiosp->c_cflag & CRTSCTS) == 0)) {
1343                 tty->hw_stopped = 0;
1344                 stl_start(tty);
1345         }
1346         if (((old->c_cflag & CLOCAL) == 0) && (tiosp->c_cflag & CLOCAL))
1347                 wake_up_interruptible(&portp->open_wait);
1348 }
1349
1350 /*****************************************************************************/
1351
1352 /*
1353  *      Attempt to flow control who ever is sending us data. Based on termios
1354  *      settings use software or/and hardware flow control.
1355  */
1356
1357 static void stl_throttle(struct tty_struct *tty)
1358 {
1359         struct stlport  *portp;
1360
1361         pr_debug("stl_throttle(tty=%p)\n", tty);
1362
1363         if (tty == NULL)
1364                 return;
1365         portp = tty->driver_data;
1366         if (portp == NULL)
1367                 return;
1368         stl_flowctrl(portp, 0);
1369 }
1370
1371 /*****************************************************************************/
1372
1373 /*
1374  *      Unflow control the device sending us data...
1375  */
1376
1377 static void stl_unthrottle(struct tty_struct *tty)
1378 {
1379         struct stlport  *portp;
1380
1381         pr_debug("stl_unthrottle(tty=%p)\n", tty);
1382
1383         if (tty == NULL)
1384                 return;
1385         portp = tty->driver_data;
1386         if (portp == NULL)
1387                 return;
1388         stl_flowctrl(portp, 1);
1389 }
1390
1391 /*****************************************************************************/
1392
1393 /*
1394  *      Stop the transmitter. Basically to do this we will just turn TX
1395  *      interrupts off.
1396  */
1397
1398 static void stl_stop(struct tty_struct *tty)
1399 {
1400         struct stlport  *portp;
1401
1402         pr_debug("stl_stop(tty=%p)\n", tty);
1403
1404         if (tty == NULL)
1405                 return;
1406         portp = tty->driver_data;
1407         if (portp == NULL)
1408                 return;
1409         stl_startrxtx(portp, -1, 0);
1410 }
1411
1412 /*****************************************************************************/
1413
1414 /*
1415  *      Hangup this port. This is pretty much like closing the port, only
1416  *      a little more brutal. No waiting for data to drain. Shutdown the
1417  *      port and maybe drop signals.
1418  */
1419
1420 static void stl_hangup(struct tty_struct *tty)
1421 {
1422         struct stlport  *portp;
1423
1424         pr_debug("stl_hangup(tty=%p)\n", tty);
1425
1426         if (tty == NULL)
1427                 return;
1428         portp = tty->driver_data;
1429         if (portp == NULL)
1430                 return;
1431
1432         portp->flags &= ~ASYNC_INITIALIZED;
1433         stl_disableintrs(portp);
1434         if (tty->termios->c_cflag & HUPCL)
1435                 stl_setsignals(portp, 0, 0);
1436         stl_enablerxtx(portp, 0, 0);
1437         stl_flushbuffer(tty);
1438         portp->istate = 0;
1439         set_bit(TTY_IO_ERROR, &tty->flags);
1440         if (portp->tx.buf != NULL) {
1441                 kfree(portp->tx.buf);
1442                 portp->tx.buf = NULL;
1443                 portp->tx.head = NULL;
1444                 portp->tx.tail = NULL;
1445         }
1446         portp->tty = NULL;
1447         portp->flags &= ~ASYNC_NORMAL_ACTIVE;
1448         portp->refcount = 0;
1449         wake_up_interruptible(&portp->open_wait);
1450 }
1451
1452 /*****************************************************************************/
1453
1454 static void stl_breakctl(struct tty_struct *tty, int state)
1455 {
1456         struct stlport  *portp;
1457
1458         pr_debug("stl_breakctl(tty=%p,state=%d)\n", tty, state);
1459
1460         if (tty == NULL)
1461                 return;
1462         portp = tty->driver_data;
1463         if (portp == NULL)
1464                 return;
1465
1466         stl_sendbreak(portp, ((state == -1) ? 1 : 2));
1467 }
1468
1469 /*****************************************************************************/
1470
1471 static void stl_sendxchar(struct tty_struct *tty, char ch)
1472 {
1473         struct stlport  *portp;
1474
1475         pr_debug("stl_sendxchar(tty=%p,ch=%x)\n", tty, ch);
1476
1477         if (tty == NULL)
1478                 return;
1479         portp = tty->driver_data;
1480         if (portp == NULL)
1481                 return;
1482
1483         if (ch == STOP_CHAR(tty))
1484                 stl_sendflow(portp, 0);
1485         else if (ch == START_CHAR(tty))
1486                 stl_sendflow(portp, 1);
1487         else
1488                 stl_putchar(tty, ch);
1489 }
1490
1491 /*****************************************************************************/
1492
1493 #define MAXLINE         80
1494
1495 /*
1496  *      Format info for a specified port. The line is deliberately limited
1497  *      to 80 characters. (If it is too long it will be truncated, if too
1498  *      short then padded with spaces).
1499  */
1500
1501 static int stl_portinfo(struct stlport *portp, int portnr, char *pos)
1502 {
1503         char    *sp;
1504         int     sigs, cnt;
1505
1506         sp = pos;
1507         sp += sprintf(sp, "%d: uart:%s tx:%d rx:%d",
1508                 portnr, (portp->hwid == 1) ? "SC26198" : "CD1400",
1509                 (int) portp->stats.txtotal, (int) portp->stats.rxtotal);
1510
1511         if (portp->stats.rxframing)
1512                 sp += sprintf(sp, " fe:%d", (int) portp->stats.rxframing);
1513         if (portp->stats.rxparity)
1514                 sp += sprintf(sp, " pe:%d", (int) portp->stats.rxparity);
1515         if (portp->stats.rxbreaks)
1516                 sp += sprintf(sp, " brk:%d", (int) portp->stats.rxbreaks);
1517         if (portp->stats.rxoverrun)
1518                 sp += sprintf(sp, " oe:%d", (int) portp->stats.rxoverrun);
1519
1520         sigs = stl_getsignals(portp);
1521         cnt = sprintf(sp, "%s%s%s%s%s ",
1522                 (sigs & TIOCM_RTS) ? "|RTS" : "",
1523                 (sigs & TIOCM_CTS) ? "|CTS" : "",
1524                 (sigs & TIOCM_DTR) ? "|DTR" : "",
1525                 (sigs & TIOCM_CD) ? "|DCD" : "",
1526                 (sigs & TIOCM_DSR) ? "|DSR" : "");
1527         *sp = ' ';
1528         sp += cnt;
1529
1530         for (cnt = sp - pos; cnt < (MAXLINE - 1); cnt++)
1531                 *sp++ = ' ';
1532         if (cnt >= MAXLINE)
1533                 pos[(MAXLINE - 2)] = '+';
1534         pos[(MAXLINE - 1)] = '\n';
1535
1536         return MAXLINE;
1537 }
1538
1539 /*****************************************************************************/
1540
1541 /*
1542  *      Port info, read from the /proc file system.
1543  */
1544
1545 static int stl_readproc(char *page, char **start, off_t off, int count, int *eof, void *data)
1546 {
1547         struct stlbrd   *brdp;
1548         struct stlpanel *panelp;
1549         struct stlport  *portp;
1550         unsigned int    brdnr, panelnr, portnr;
1551         int             totalport, curoff, maxoff;
1552         char            *pos;
1553
1554         pr_debug("stl_readproc(page=%p,start=%p,off=%lx,count=%d,eof=%p,"
1555                 "data=%p\n", page, start, off, count, eof, data);
1556
1557         pos = page;
1558         totalport = 0;
1559         curoff = 0;
1560
1561         if (off == 0) {
1562                 pos += sprintf(pos, "%s: version %s", stl_drvtitle,
1563                         stl_drvversion);
1564                 while (pos < (page + MAXLINE - 1))
1565                         *pos++ = ' ';
1566                 *pos++ = '\n';
1567         }
1568         curoff =  MAXLINE;
1569
1570 /*
1571  *      We scan through for each board, panel and port. The offset is
1572  *      calculated on the fly, and irrelevant ports are skipped.
1573  */
1574         for (brdnr = 0; brdnr < stl_nrbrds; brdnr++) {
1575                 brdp = stl_brds[brdnr];
1576                 if (brdp == NULL)
1577                         continue;
1578                 if (brdp->state == 0)
1579                         continue;
1580
1581                 maxoff = curoff + (brdp->nrports * MAXLINE);
1582                 if (off >= maxoff) {
1583                         curoff = maxoff;
1584                         continue;
1585                 }
1586
1587                 totalport = brdnr * STL_MAXPORTS;
1588                 for (panelnr = 0; panelnr < brdp->nrpanels; panelnr++) {
1589                         panelp = brdp->panels[panelnr];
1590                         if (panelp == NULL)
1591                                 continue;
1592
1593                         maxoff = curoff + (panelp->nrports * MAXLINE);
1594                         if (off >= maxoff) {
1595                                 curoff = maxoff;
1596                                 totalport += panelp->nrports;
1597                                 continue;
1598                         }
1599
1600                         for (portnr = 0; portnr < panelp->nrports; portnr++,
1601                             totalport++) {
1602                                 portp = panelp->ports[portnr];
1603                                 if (portp == NULL)
1604                                         continue;
1605                                 if (off >= (curoff += MAXLINE))
1606                                         continue;
1607                                 if ((pos - page + MAXLINE) > count)
1608                                         goto stl_readdone;
1609                                 pos += stl_portinfo(portp, totalport, pos);
1610                         }
1611                 }
1612         }
1613
1614         *eof = 1;
1615
1616 stl_readdone:
1617         *start = page;
1618         return pos - page;
1619 }
1620
1621 /*****************************************************************************/
1622
1623 /*
1624  *      All board interrupts are vectored through here first. This code then
1625  *      calls off to the approrpriate board interrupt handlers.
1626  */
1627
1628 static irqreturn_t stl_intr(int irq, void *dev_id)
1629 {
1630         struct stlbrd *brdp = dev_id;
1631
1632         pr_debug("stl_intr(brdp=%p,irq=%d)\n", brdp, irq);
1633
1634         return IRQ_RETVAL((* brdp->isr)(brdp));
1635 }
1636
1637 /*****************************************************************************/
1638
1639 /*
1640  *      Interrupt service routine for EasyIO board types.
1641  */
1642
1643 static int stl_eiointr(struct stlbrd *brdp)
1644 {
1645         struct stlpanel *panelp;
1646         unsigned int    iobase;
1647         int             handled = 0;
1648
1649         spin_lock(&brd_lock);
1650         panelp = brdp->panels[0];
1651         iobase = panelp->iobase;
1652         while (inb(brdp->iostatus) & EIO_INTRPEND) {
1653                 handled = 1;
1654                 (* panelp->isr)(panelp, iobase);
1655         }
1656         spin_unlock(&brd_lock);
1657         return handled;
1658 }
1659
1660 /*****************************************************************************/
1661
1662 /*
1663  *      Interrupt service routine for ECH-AT board types.
1664  */
1665
1666 static int stl_echatintr(struct stlbrd *brdp)
1667 {
1668         struct stlpanel *panelp;
1669         unsigned int    ioaddr, bnknr;
1670         int             handled = 0;
1671
1672         outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl);
1673
1674         while (inb(brdp->iostatus) & ECH_INTRPEND) {
1675                 handled = 1;
1676                 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1677                         ioaddr = brdp->bnkstataddr[bnknr];
1678                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1679                                 panelp = brdp->bnk2panel[bnknr];
1680                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1681                         }
1682                 }
1683         }
1684
1685         outb((brdp->ioctrlval | ECH_BRDDISABLE), brdp->ioctrl);
1686
1687         return handled;
1688 }
1689
1690 /*****************************************************************************/
1691
1692 /*
1693  *      Interrupt service routine for ECH-MCA board types.
1694  */
1695
1696 static int stl_echmcaintr(struct stlbrd *brdp)
1697 {
1698         struct stlpanel *panelp;
1699         unsigned int    ioaddr, bnknr;
1700         int             handled = 0;
1701
1702         while (inb(brdp->iostatus) & ECH_INTRPEND) {
1703                 handled = 1;
1704                 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1705                         ioaddr = brdp->bnkstataddr[bnknr];
1706                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1707                                 panelp = brdp->bnk2panel[bnknr];
1708                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1709                         }
1710                 }
1711         }
1712         return handled;
1713 }
1714
1715 /*****************************************************************************/
1716
1717 /*
1718  *      Interrupt service routine for ECH-PCI board types.
1719  */
1720
1721 static int stl_echpciintr(struct stlbrd *brdp)
1722 {
1723         struct stlpanel *panelp;
1724         unsigned int    ioaddr, bnknr, recheck;
1725         int             handled = 0;
1726
1727         while (1) {
1728                 recheck = 0;
1729                 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1730                         outb(brdp->bnkpageaddr[bnknr], brdp->ioctrl);
1731                         ioaddr = brdp->bnkstataddr[bnknr];
1732                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1733                                 panelp = brdp->bnk2panel[bnknr];
1734                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1735                                 recheck++;
1736                                 handled = 1;
1737                         }
1738                 }
1739                 if (! recheck)
1740                         break;
1741         }
1742         return handled;
1743 }
1744
1745 /*****************************************************************************/
1746
1747 /*
1748  *      Interrupt service routine for ECH-8/64-PCI board types.
1749  */
1750
1751 static int stl_echpci64intr(struct stlbrd *brdp)
1752 {
1753         struct stlpanel *panelp;
1754         unsigned int    ioaddr, bnknr;
1755         int             handled = 0;
1756
1757         while (inb(brdp->ioctrl) & 0x1) {
1758                 handled = 1;
1759                 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1760                         ioaddr = brdp->bnkstataddr[bnknr];
1761                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1762                                 panelp = brdp->bnk2panel[bnknr];
1763                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1764                         }
1765                 }
1766         }
1767
1768         return handled;
1769 }
1770
1771 /*****************************************************************************/
1772
1773 /*
1774  *      Service an off-level request for some channel.
1775  */
1776 static void stl_offintr(struct work_struct *work)
1777 {
1778         struct stlport          *portp = container_of(work, struct stlport, tqueue);
1779         struct tty_struct       *tty;
1780         unsigned int            oldsigs;
1781
1782         pr_debug("stl_offintr(portp=%p)\n", portp);
1783
1784         if (portp == NULL)
1785                 return;
1786
1787         tty = portp->tty;
1788         if (tty == NULL)
1789                 return;
1790
1791         lock_kernel();
1792         if (test_bit(ASYI_TXLOW, &portp->istate))
1793                 tty_wakeup(tty);
1794
1795         if (test_bit(ASYI_DCDCHANGE, &portp->istate)) {
1796                 clear_bit(ASYI_DCDCHANGE, &portp->istate);
1797                 oldsigs = portp->sigs;
1798                 portp->sigs = stl_getsignals(portp);
1799                 if ((portp->sigs & TIOCM_CD) && ((oldsigs & TIOCM_CD) == 0))
1800                         wake_up_interruptible(&portp->open_wait);
1801                 if ((oldsigs & TIOCM_CD) && ((portp->sigs & TIOCM_CD) == 0))
1802                         if (portp->flags & ASYNC_CHECK_CD)
1803                                 tty_hangup(tty);        /* FIXME: module removal race here - AKPM */
1804         }
1805         unlock_kernel();
1806 }
1807
1808 /*****************************************************************************/
1809
1810 /*
1811  *      Initialize all the ports on a panel.
1812  */
1813
1814 static int __devinit stl_initports(struct stlbrd *brdp, struct stlpanel *panelp)
1815 {
1816         struct stlport *portp;
1817         unsigned int i;
1818         int chipmask;
1819
1820         pr_debug("stl_initports(brdp=%p,panelp=%p)\n", brdp, panelp);
1821
1822         chipmask = stl_panelinit(brdp, panelp);
1823
1824 /*
1825  *      All UART's are initialized (if found!). Now go through and setup
1826  *      each ports data structures.
1827  */
1828         for (i = 0; i < panelp->nrports; i++) {
1829                 portp = kzalloc(sizeof(struct stlport), GFP_KERNEL);
1830                 if (!portp) {
1831                         printk("STALLION: failed to allocate memory "
1832                                 "(size=%Zd)\n", sizeof(struct stlport));
1833                         break;
1834                 }
1835
1836                 portp->magic = STL_PORTMAGIC;
1837                 portp->portnr = i;
1838                 portp->brdnr = panelp->brdnr;
1839                 portp->panelnr = panelp->panelnr;
1840                 portp->uartp = panelp->uartp;
1841                 portp->clk = brdp->clk;
1842                 portp->baud_base = STL_BAUDBASE;
1843                 portp->close_delay = STL_CLOSEDELAY;
1844                 portp->closing_wait = 30 * HZ;
1845                 INIT_WORK(&portp->tqueue, stl_offintr);
1846                 init_waitqueue_head(&portp->open_wait);
1847                 init_waitqueue_head(&portp->close_wait);
1848                 portp->stats.brd = portp->brdnr;
1849                 portp->stats.panel = portp->panelnr;
1850                 portp->stats.port = portp->portnr;
1851                 panelp->ports[i] = portp;
1852                 stl_portinit(brdp, panelp, portp);
1853         }
1854
1855         return 0;
1856 }
1857
1858 static void stl_cleanup_panels(struct stlbrd *brdp)
1859 {
1860         struct stlpanel *panelp;
1861         struct stlport *portp;
1862         unsigned int j, k;
1863
1864         for (j = 0; j < STL_MAXPANELS; j++) {
1865                 panelp = brdp->panels[j];
1866                 if (panelp == NULL)
1867                         continue;
1868                 for (k = 0; k < STL_PORTSPERPANEL; k++) {
1869                         portp = panelp->ports[k];
1870                         if (portp == NULL)
1871                                 continue;
1872                         if (portp->tty != NULL)
1873                                 stl_hangup(portp->tty);
1874                         kfree(portp->tx.buf);
1875                         kfree(portp);
1876                 }
1877                 kfree(panelp);
1878         }
1879 }
1880
1881 /*****************************************************************************/
1882
1883 /*
1884  *      Try to find and initialize an EasyIO board.
1885  */
1886
1887 static int __devinit stl_initeio(struct stlbrd *brdp)
1888 {
1889         struct stlpanel *panelp;
1890         unsigned int    status;
1891         char            *name;
1892         int             retval;
1893
1894         pr_debug("stl_initeio(brdp=%p)\n", brdp);
1895
1896         brdp->ioctrl = brdp->ioaddr1 + 1;
1897         brdp->iostatus = brdp->ioaddr1 + 2;
1898
1899         status = inb(brdp->iostatus);
1900         if ((status & EIO_IDBITMASK) == EIO_MK3)
1901                 brdp->ioctrl++;
1902
1903 /*
1904  *      Handle board specific stuff now. The real difference is PCI
1905  *      or not PCI.
1906  */
1907         if (brdp->brdtype == BRD_EASYIOPCI) {
1908                 brdp->iosize1 = 0x80;
1909                 brdp->iosize2 = 0x80;
1910                 name = "serial(EIO-PCI)";
1911                 outb(0x41, (brdp->ioaddr2 + 0x4c));
1912         } else {
1913                 brdp->iosize1 = 8;
1914                 name = "serial(EIO)";
1915                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
1916                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
1917                         printk("STALLION: invalid irq=%d for brd=%d\n",
1918                                 brdp->irq, brdp->brdnr);
1919                         retval = -EINVAL;
1920                         goto err;
1921                 }
1922                 outb((stl_vecmap[brdp->irq] | EIO_0WS |
1923                         ((brdp->irqtype) ? EIO_INTLEVEL : EIO_INTEDGE)),
1924                         brdp->ioctrl);
1925         }
1926
1927         retval = -EBUSY;
1928         if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) {
1929                 printk(KERN_WARNING "STALLION: Warning, board %d I/O address "
1930                         "%x conflicts with another device\n", brdp->brdnr, 
1931                         brdp->ioaddr1);
1932                 goto err;
1933         }
1934         
1935         if (brdp->iosize2 > 0)
1936                 if (!request_region(brdp->ioaddr2, brdp->iosize2, name)) {
1937                         printk(KERN_WARNING "STALLION: Warning, board %d I/O "
1938                                 "address %x conflicts with another device\n",
1939                                 brdp->brdnr, brdp->ioaddr2);
1940                         printk(KERN_WARNING "STALLION: Warning, also "
1941                                 "releasing board %d I/O address %x \n", 
1942                                 brdp->brdnr, brdp->ioaddr1);
1943                         goto err_rel1;
1944                 }
1945
1946 /*
1947  *      Everything looks OK, so let's go ahead and probe for the hardware.
1948  */
1949         brdp->clk = CD1400_CLK;
1950         brdp->isr = stl_eiointr;
1951
1952         retval = -ENODEV;
1953         switch (status & EIO_IDBITMASK) {
1954         case EIO_8PORTM:
1955                 brdp->clk = CD1400_CLK8M;
1956                 /* fall thru */
1957         case EIO_8PORTRS:
1958         case EIO_8PORTDI:
1959                 brdp->nrports = 8;
1960                 break;
1961         case EIO_4PORTRS:
1962                 brdp->nrports = 4;
1963                 break;
1964         case EIO_MK3:
1965                 switch (status & EIO_BRDMASK) {
1966                 case ID_BRD4:
1967                         brdp->nrports = 4;
1968                         break;
1969                 case ID_BRD8:
1970                         brdp->nrports = 8;
1971                         break;
1972                 case ID_BRD16:
1973                         brdp->nrports = 16;
1974                         break;
1975                 default:
1976                         goto err_rel2;
1977                 }
1978                 break;
1979         default:
1980                 goto err_rel2;
1981         }
1982
1983 /*
1984  *      We have verified that the board is actually present, so now we
1985  *      can complete the setup.
1986  */
1987
1988         panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL);
1989         if (!panelp) {
1990                 printk(KERN_WARNING "STALLION: failed to allocate memory "
1991                         "(size=%Zd)\n", sizeof(struct stlpanel));
1992                 retval = -ENOMEM;
1993                 goto err_rel2;
1994         }
1995
1996         panelp->magic = STL_PANELMAGIC;
1997         panelp->brdnr = brdp->brdnr;
1998         panelp->panelnr = 0;
1999         panelp->nrports = brdp->nrports;
2000         panelp->iobase = brdp->ioaddr1;
2001         panelp->hwid = status;
2002         if ((status & EIO_IDBITMASK) == EIO_MK3) {
2003                 panelp->uartp = &stl_sc26198uart;
2004                 panelp->isr = stl_sc26198intr;
2005         } else {
2006                 panelp->uartp = &stl_cd1400uart;
2007                 panelp->isr = stl_cd1400eiointr;
2008         }
2009
2010         brdp->panels[0] = panelp;
2011         brdp->nrpanels = 1;
2012         brdp->state |= BRD_FOUND;
2013         brdp->hwid = status;
2014         if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) {
2015                 printk("STALLION: failed to register interrupt "
2016                     "routine for %s irq=%d\n", name, brdp->irq);
2017                 retval = -ENODEV;
2018                 goto err_fr;
2019         }
2020
2021         return 0;
2022 err_fr:
2023         stl_cleanup_panels(brdp);
2024 err_rel2:
2025         if (brdp->iosize2 > 0)
2026                 release_region(brdp->ioaddr2, brdp->iosize2);
2027 err_rel1:
2028         release_region(brdp->ioaddr1, brdp->iosize1);
2029 err:
2030         return retval;
2031 }
2032
2033 /*****************************************************************************/
2034
2035 /*
2036  *      Try to find an ECH board and initialize it. This code is capable of
2037  *      dealing with all types of ECH board.
2038  */
2039
2040 static int __devinit stl_initech(struct stlbrd *brdp)
2041 {
2042         struct stlpanel *panelp;
2043         unsigned int    status, nxtid, ioaddr, conflict, panelnr, banknr, i;
2044         int             retval;
2045         char            *name;
2046
2047         pr_debug("stl_initech(brdp=%p)\n", brdp);
2048
2049         status = 0;
2050         conflict = 0;
2051
2052 /*
2053  *      Set up the initial board register contents for boards. This varies a
2054  *      bit between the different board types. So we need to handle each
2055  *      separately. Also do a check that the supplied IRQ is good.
2056  */
2057         switch (brdp->brdtype) {
2058
2059         case BRD_ECH:
2060                 brdp->isr = stl_echatintr;
2061                 brdp->ioctrl = brdp->ioaddr1 + 1;
2062                 brdp->iostatus = brdp->ioaddr1 + 1;
2063                 status = inb(brdp->iostatus);
2064                 if ((status & ECH_IDBITMASK) != ECH_ID) {
2065                         retval = -ENODEV;
2066                         goto err;
2067                 }
2068                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
2069                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
2070                         printk("STALLION: invalid irq=%d for brd=%d\n",
2071                                 brdp->irq, brdp->brdnr);
2072                         retval = -EINVAL;
2073                         goto err;
2074                 }
2075                 status = ((brdp->ioaddr2 & ECH_ADDR2MASK) >> 1);
2076                 status |= (stl_vecmap[brdp->irq] << 1);
2077                 outb((status | ECH_BRDRESET), brdp->ioaddr1);
2078                 brdp->ioctrlval = ECH_INTENABLE |
2079                         ((brdp->irqtype) ? ECH_INTLEVEL : ECH_INTEDGE);
2080                 for (i = 0; i < 10; i++)
2081                         outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl);
2082                 brdp->iosize1 = 2;
2083                 brdp->iosize2 = 32;
2084                 name = "serial(EC8/32)";
2085                 outb(status, brdp->ioaddr1);
2086                 break;
2087
2088         case BRD_ECHMC:
2089                 brdp->isr = stl_echmcaintr;
2090                 brdp->ioctrl = brdp->ioaddr1 + 0x20;
2091                 brdp->iostatus = brdp->ioctrl;
2092                 status = inb(brdp->iostatus);
2093                 if ((status & ECH_IDBITMASK) != ECH_ID) {
2094                         retval = -ENODEV;
2095                         goto err;
2096                 }
2097                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
2098                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
2099                         printk("STALLION: invalid irq=%d for brd=%d\n",
2100                                 brdp->irq, brdp->brdnr);
2101                         retval = -EINVAL;
2102                         goto err;
2103                 }
2104                 outb(ECHMC_BRDRESET, brdp->ioctrl);
2105                 outb(ECHMC_INTENABLE, brdp->ioctrl);
2106                 brdp->iosize1 = 64;
2107                 name = "serial(EC8/32-MC)";
2108                 break;
2109
2110         case BRD_ECHPCI:
2111                 brdp->isr = stl_echpciintr;
2112                 brdp->ioctrl = brdp->ioaddr1 + 2;
2113                 brdp->iosize1 = 4;
2114                 brdp->iosize2 = 8;
2115                 name = "serial(EC8/32-PCI)";
2116                 break;
2117
2118         case BRD_ECH64PCI:
2119                 brdp->isr = stl_echpci64intr;
2120                 brdp->ioctrl = brdp->ioaddr2 + 0x40;
2121                 outb(0x43, (brdp->ioaddr1 + 0x4c));
2122                 brdp->iosize1 = 0x80;
2123                 brdp->iosize2 = 0x80;
2124                 name = "serial(EC8/64-PCI)";
2125                 break;
2126
2127         default:
2128                 printk("STALLION: unknown board type=%d\n", brdp->brdtype);
2129                 retval = -EINVAL;
2130                 goto err;
2131         }
2132
2133 /*
2134  *      Check boards for possible IO address conflicts and return fail status 
2135  *      if an IO conflict found.
2136  */
2137         retval = -EBUSY;
2138         if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) {
2139                 printk(KERN_WARNING "STALLION: Warning, board %d I/O address "
2140                         "%x conflicts with another device\n", brdp->brdnr, 
2141                         brdp->ioaddr1);
2142                 goto err;
2143         }
2144         
2145         if (brdp->iosize2 > 0)
2146                 if (!request_region(brdp->ioaddr2, brdp->iosize2, name)) {
2147                         printk(KERN_WARNING "STALLION: Warning, board %d I/O "
2148                                 "address %x conflicts with another device\n",
2149                                 brdp->brdnr, brdp->ioaddr2);
2150                         printk(KERN_WARNING "STALLION: Warning, also "
2151                                 "releasing board %d I/O address %x \n", 
2152                                 brdp->brdnr, brdp->ioaddr1);
2153                         goto err_rel1;
2154                 }
2155
2156 /*
2157  *      Scan through the secondary io address space looking for panels.
2158  *      As we find'em allocate and initialize panel structures for each.
2159  */
2160         brdp->clk = CD1400_CLK;
2161         brdp->hwid = status;
2162
2163         ioaddr = brdp->ioaddr2;
2164         banknr = 0;
2165         panelnr = 0;
2166         nxtid = 0;
2167
2168         for (i = 0; i < STL_MAXPANELS; i++) {
2169                 if (brdp->brdtype == BRD_ECHPCI) {
2170                         outb(nxtid, brdp->ioctrl);
2171                         ioaddr = brdp->ioaddr2;
2172                 }
2173                 status = inb(ioaddr + ECH_PNLSTATUS);
2174                 if ((status & ECH_PNLIDMASK) != nxtid)
2175                         break;
2176                 panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL);
2177                 if (!panelp) {
2178                         printk("STALLION: failed to allocate memory "
2179                                 "(size=%Zd)\n", sizeof(struct stlpanel));
2180                         retval = -ENOMEM;
2181                         goto err_fr;
2182                 }
2183                 panelp->magic = STL_PANELMAGIC;
2184                 panelp->brdnr = brdp->brdnr;
2185                 panelp->panelnr = panelnr;
2186                 panelp->iobase = ioaddr;
2187                 panelp->pagenr = nxtid;
2188                 panelp->hwid = status;
2189                 brdp->bnk2panel[banknr] = panelp;
2190                 brdp->bnkpageaddr[banknr] = nxtid;
2191                 brdp->bnkstataddr[banknr++] = ioaddr + ECH_PNLSTATUS;
2192
2193                 if (status & ECH_PNLXPID) {
2194                         panelp->uartp = &stl_sc26198uart;
2195                         panelp->isr = stl_sc26198intr;
2196                         if (status & ECH_PNL16PORT) {
2197                                 panelp->nrports = 16;
2198                                 brdp->bnk2panel[banknr] = panelp;
2199                                 brdp->bnkpageaddr[banknr] = nxtid;
2200                                 brdp->bnkstataddr[banknr++] = ioaddr + 4 +
2201                                         ECH_PNLSTATUS;
2202                         } else
2203                                 panelp->nrports = 8;
2204                 } else {
2205                         panelp->uartp = &stl_cd1400uart;
2206                         panelp->isr = stl_cd1400echintr;
2207                         if (status & ECH_PNL16PORT) {
2208                                 panelp->nrports = 16;
2209                                 panelp->ackmask = 0x80;
2210                                 if (brdp->brdtype != BRD_ECHPCI)
2211                                         ioaddr += EREG_BANKSIZE;
2212                                 brdp->bnk2panel[banknr] = panelp;
2213                                 brdp->bnkpageaddr[banknr] = ++nxtid;
2214                                 brdp->bnkstataddr[banknr++] = ioaddr +
2215                                         ECH_PNLSTATUS;
2216                         } else {
2217                                 panelp->nrports = 8;
2218                                 panelp->ackmask = 0xc0;
2219                         }
2220                 }
2221
2222                 nxtid++;
2223                 ioaddr += EREG_BANKSIZE;
2224                 brdp->nrports += panelp->nrports;
2225                 brdp->panels[panelnr++] = panelp;
2226                 if ((brdp->brdtype != BRD_ECHPCI) &&
2227                     (ioaddr >= (brdp->ioaddr2 + brdp->iosize2))) {
2228                         retval = -EINVAL;
2229                         goto err_fr;
2230                 }
2231         }
2232
2233         brdp->nrpanels = panelnr;
2234         brdp->nrbnks = banknr;
2235         if (brdp->brdtype == BRD_ECH)
2236                 outb((brdp->ioctrlval | ECH_BRDDISABLE), brdp->ioctrl);
2237
2238         brdp->state |= BRD_FOUND;
2239         if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) {
2240                 printk("STALLION: failed to register interrupt "
2241                     "routine for %s irq=%d\n", name, brdp->irq);
2242                 retval = -ENODEV;
2243                 goto err_fr;
2244         }
2245
2246         return 0;
2247 err_fr:
2248         stl_cleanup_panels(brdp);
2249         if (brdp->iosize2 > 0)
2250                 release_region(brdp->ioaddr2, brdp->iosize2);
2251 err_rel1:
2252         release_region(brdp->ioaddr1, brdp->iosize1);
2253 err:
2254         return retval;
2255 }
2256
2257 /*****************************************************************************/
2258
2259 /*
2260  *      Initialize and configure the specified board.
2261  *      Scan through all the boards in the configuration and see what we
2262  *      can find. Handle EIO and the ECH boards a little differently here
2263  *      since the initial search and setup is very different.
2264  */
2265
2266 static int __devinit stl_brdinit(struct stlbrd *brdp)
2267 {
2268         int i, retval;
2269
2270         pr_debug("stl_brdinit(brdp=%p)\n", brdp);
2271
2272         switch (brdp->brdtype) {
2273         case BRD_EASYIO:
2274         case BRD_EASYIOPCI:
2275                 retval = stl_initeio(brdp);
2276                 if (retval)
2277                         goto err;
2278                 break;
2279         case BRD_ECH:
2280         case BRD_ECHMC:
2281         case BRD_ECHPCI:
2282         case BRD_ECH64PCI:
2283                 retval = stl_initech(brdp);
2284                 if (retval)
2285                         goto err;
2286                 break;
2287         default:
2288                 printk("STALLION: board=%d is unknown board type=%d\n",
2289                         brdp->brdnr, brdp->brdtype);
2290                 retval = -ENODEV;
2291                 goto err;
2292         }
2293
2294         if ((brdp->state & BRD_FOUND) == 0) {
2295                 printk("STALLION: %s board not found, board=%d io=%x irq=%d\n",
2296                         stl_brdnames[brdp->brdtype], brdp->brdnr,
2297                         brdp->ioaddr1, brdp->irq);
2298                 goto err_free;
2299         }
2300
2301         for (i = 0; i < STL_MAXPANELS; i++)
2302                 if (brdp->panels[i] != NULL)
2303                         stl_initports(brdp, brdp->panels[i]);
2304
2305         printk("STALLION: %s found, board=%d io=%x irq=%d "
2306                 "nrpanels=%d nrports=%d\n", stl_brdnames[brdp->brdtype],
2307                 brdp->brdnr, brdp->ioaddr1, brdp->irq, brdp->nrpanels,
2308                 brdp->nrports);
2309
2310         return 0;
2311 err_free:
2312         free_irq(brdp->irq, brdp);
2313
2314         stl_cleanup_panels(brdp);
2315
2316         release_region(brdp->ioaddr1, brdp->iosize1);
2317         if (brdp->iosize2 > 0)
2318                 release_region(brdp->ioaddr2, brdp->iosize2);
2319 err:
2320         return retval;
2321 }
2322
2323 /*****************************************************************************/
2324
2325 /*
2326  *      Find the next available board number that is free.
2327  */
2328
2329 static int __devinit stl_getbrdnr(void)
2330 {
2331         unsigned int i;
2332
2333         for (i = 0; i < STL_MAXBRDS; i++)
2334                 if (stl_brds[i] == NULL) {
2335                         if (i >= stl_nrbrds)
2336                                 stl_nrbrds = i + 1;
2337                         return i;
2338                 }
2339
2340         return -1;
2341 }
2342
2343 /*****************************************************************************/
2344 /*
2345  *      We have a Stallion board. Allocate a board structure and
2346  *      initialize it. Read its IO and IRQ resources from PCI
2347  *      configuration space.
2348  */
2349
2350 static int __devinit stl_pciprobe(struct pci_dev *pdev,
2351                 const struct pci_device_id *ent)
2352 {
2353         struct stlbrd *brdp;
2354         unsigned int i, brdtype = ent->driver_data;
2355         int brdnr, retval = -ENODEV;
2356
2357         if ((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE)
2358                 goto err;
2359
2360         dev_info(&pdev->dev, "please, report this to LKML: %x/%x/%x\n",
2361                         pdev->vendor, pdev->device, pdev->class);
2362
2363         retval = pci_enable_device(pdev);
2364         if (retval)
2365                 goto err;
2366         brdp = stl_allocbrd();
2367         if (brdp == NULL) {
2368                 retval = -ENOMEM;
2369                 goto err;
2370         }
2371         mutex_lock(&stl_brdslock);
2372         brdnr = stl_getbrdnr();
2373         if (brdnr < 0) {
2374                 dev_err(&pdev->dev, "too many boards found, "
2375                         "maximum supported %d\n", STL_MAXBRDS);
2376                 mutex_unlock(&stl_brdslock);
2377                 retval = -ENODEV;
2378                 goto err_fr;
2379         }
2380         brdp->brdnr = (unsigned int)brdnr;
2381         stl_brds[brdp->brdnr] = brdp;
2382         mutex_unlock(&stl_brdslock);
2383
2384         brdp->brdtype = brdtype;
2385         brdp->state |= STL_PROBED;
2386
2387 /*
2388  *      We have all resources from the board, so let's setup the actual
2389  *      board structure now.
2390  */
2391         switch (brdtype) {
2392         case BRD_ECHPCI:
2393                 brdp->ioaddr2 = pci_resource_start(pdev, 0);
2394                 brdp->ioaddr1 = pci_resource_start(pdev, 1);
2395                 break;
2396         case BRD_ECH64PCI:
2397                 brdp->ioaddr2 = pci_resource_start(pdev, 2);
2398                 brdp->ioaddr1 = pci_resource_start(pdev, 1);
2399                 break;
2400         case BRD_EASYIOPCI:
2401                 brdp->ioaddr1 = pci_resource_start(pdev, 2);
2402                 brdp->ioaddr2 = pci_resource_start(pdev, 1);
2403                 break;
2404         default:
2405                 dev_err(&pdev->dev, "unknown PCI board type=%u\n", brdtype);
2406                 break;
2407         }
2408
2409         brdp->irq = pdev->irq;
2410         retval = stl_brdinit(brdp);
2411         if (retval)
2412                 goto err_null;
2413
2414         pci_set_drvdata(pdev, brdp);
2415
2416         for (i = 0; i < brdp->nrports; i++)
2417                 tty_register_device(stl_serial,
2418                                 brdp->brdnr * STL_MAXPORTS + i, &pdev->dev);
2419
2420         return 0;
2421 err_null:
2422         stl_brds[brdp->brdnr] = NULL;
2423 err_fr:
2424         kfree(brdp);
2425 err:
2426         return retval;
2427 }
2428
2429 static void __devexit stl_pciremove(struct pci_dev *pdev)
2430 {
2431         struct stlbrd *brdp = pci_get_drvdata(pdev);
2432         unsigned int i;
2433
2434         free_irq(brdp->irq, brdp);
2435
2436         stl_cleanup_panels(brdp);
2437
2438         release_region(brdp->ioaddr1, brdp->iosize1);
2439         if (brdp->iosize2 > 0)
2440                 release_region(brdp->ioaddr2, brdp->iosize2);
2441
2442         for (i = 0; i < brdp->nrports; i++)
2443                 tty_unregister_device(stl_serial,
2444                                 brdp->brdnr * STL_MAXPORTS + i);
2445
2446         stl_brds[brdp->brdnr] = NULL;
2447         kfree(brdp);
2448 }
2449
2450 static struct pci_driver stl_pcidriver = {
2451         .name = "stallion",
2452         .id_table = stl_pcibrds,
2453         .probe = stl_pciprobe,
2454         .remove = __devexit_p(stl_pciremove)
2455 };
2456
2457 /*****************************************************************************/
2458
2459 /*
2460  *      Return the board stats structure to user app.
2461  */
2462
2463 static int stl_getbrdstats(combrd_t __user *bp)
2464 {
2465         combrd_t        stl_brdstats;
2466         struct stlbrd   *brdp;
2467         struct stlpanel *panelp;
2468         unsigned int i;
2469
2470         if (copy_from_user(&stl_brdstats, bp, sizeof(combrd_t)))
2471                 return -EFAULT;
2472         if (stl_brdstats.brd >= STL_MAXBRDS)
2473                 return -ENODEV;
2474         brdp = stl_brds[stl_brdstats.brd];
2475         if (brdp == NULL)
2476                 return -ENODEV;
2477
2478         memset(&stl_brdstats, 0, sizeof(combrd_t));
2479         stl_brdstats.brd = brdp->brdnr;
2480         stl_brdstats.type = brdp->brdtype;
2481         stl_brdstats.hwid = brdp->hwid;
2482         stl_brdstats.state = brdp->state;
2483         stl_brdstats.ioaddr = brdp->ioaddr1;
2484         stl_brdstats.ioaddr2 = brdp->ioaddr2;
2485         stl_brdstats.irq = brdp->irq;
2486         stl_brdstats.nrpanels = brdp->nrpanels;
2487         stl_brdstats.nrports = brdp->nrports;
2488         for (i = 0; i < brdp->nrpanels; i++) {
2489                 panelp = brdp->panels[i];
2490                 stl_brdstats.panels[i].panel = i;
2491                 stl_brdstats.panels[i].hwid = panelp->hwid;
2492                 stl_brdstats.panels[i].nrports = panelp->nrports;
2493         }
2494
2495         return copy_to_user(bp, &stl_brdstats, sizeof(combrd_t)) ? -EFAULT : 0;
2496 }
2497
2498 /*****************************************************************************/
2499
2500 /*
2501  *      Resolve the referenced port number into a port struct pointer.
2502  */
2503
2504 static struct stlport *stl_getport(int brdnr, int panelnr, int portnr)
2505 {
2506         struct stlbrd   *brdp;
2507         struct stlpanel *panelp;
2508
2509         if (brdnr < 0 || brdnr >= STL_MAXBRDS)
2510                 return NULL;
2511         brdp = stl_brds[brdnr];
2512         if (brdp == NULL)
2513                 return NULL;
2514         if (panelnr < 0 || (unsigned int)panelnr >= brdp->nrpanels)
2515                 return NULL;
2516         panelp = brdp->panels[panelnr];
2517         if (panelp == NULL)
2518                 return NULL;
2519         if (portnr < 0 || (unsigned int)portnr >= panelp->nrports)
2520                 return NULL;
2521         return panelp->ports[portnr];
2522 }
2523
2524 /*****************************************************************************/
2525
2526 /*
2527  *      Return the port stats structure to user app. A NULL port struct
2528  *      pointer passed in means that we need to find out from the app
2529  *      what port to get stats for (used through board control device).
2530  */
2531
2532 static int stl_getportstats(struct stlport *portp, comstats_t __user *cp)
2533 {
2534         comstats_t      stl_comstats;
2535         unsigned char   *head, *tail;
2536         unsigned long   flags;
2537
2538         if (!portp) {
2539                 if (copy_from_user(&stl_comstats, cp, sizeof(comstats_t)))
2540                         return -EFAULT;
2541                 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2542                         stl_comstats.port);
2543                 if (portp == NULL)
2544                         return -ENODEV;
2545         }
2546
2547         portp->stats.state = portp->istate;
2548         portp->stats.flags = portp->flags;
2549         portp->stats.hwid = portp->hwid;
2550
2551         portp->stats.ttystate = 0;
2552         portp->stats.cflags = 0;
2553         portp->stats.iflags = 0;
2554         portp->stats.oflags = 0;
2555         portp->stats.lflags = 0;
2556         portp->stats.rxbuffered = 0;
2557
2558         spin_lock_irqsave(&stallion_lock, flags);
2559         if (portp->tty != NULL)
2560                 if (portp->tty->driver_data == portp) {
2561                         portp->stats.ttystate = portp->tty->flags;
2562                         /* No longer available as a statistic */
2563                         portp->stats.rxbuffered = 1; /*portp->tty->flip.count; */
2564                         if (portp->tty->termios != NULL) {
2565                                 portp->stats.cflags = portp->tty->termios->c_cflag;
2566                                 portp->stats.iflags = portp->tty->termios->c_iflag;
2567                                 portp->stats.oflags = portp->tty->termios->c_oflag;
2568                                 portp->stats.lflags = portp->tty->termios->c_lflag;
2569                         }
2570                 }
2571         spin_unlock_irqrestore(&stallion_lock, flags);
2572
2573         head = portp->tx.head;
2574         tail = portp->tx.tail;
2575         portp->stats.txbuffered = (head >= tail) ? (head - tail) :
2576                 (STL_TXBUFSIZE - (tail - head));
2577
2578         portp->stats.signals = (unsigned long) stl_getsignals(portp);
2579
2580         return copy_to_user(cp, &portp->stats,
2581                             sizeof(comstats_t)) ? -EFAULT : 0;
2582 }
2583
2584 /*****************************************************************************/
2585
2586 /*
2587  *      Clear the port stats structure. We also return it zeroed out...
2588  */
2589
2590 static int stl_clrportstats(struct stlport *portp, comstats_t __user *cp)
2591 {
2592         comstats_t      stl_comstats;
2593
2594         if (!portp) {
2595                 if (copy_from_user(&stl_comstats, cp, sizeof(comstats_t)))
2596                         return -EFAULT;
2597                 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2598                         stl_comstats.port);
2599                 if (portp == NULL)
2600                         return -ENODEV;
2601         }
2602
2603         memset(&portp->stats, 0, sizeof(comstats_t));
2604         portp->stats.brd = portp->brdnr;
2605         portp->stats.panel = portp->panelnr;
2606         portp->stats.port = portp->portnr;
2607         return copy_to_user(cp, &portp->stats,
2608                             sizeof(comstats_t)) ? -EFAULT : 0;
2609 }
2610
2611 /*****************************************************************************/
2612
2613 /*
2614  *      Return the entire driver ports structure to a user app.
2615  */
2616
2617 static int stl_getportstruct(struct stlport __user *arg)
2618 {
2619         struct stlport  stl_dummyport;
2620         struct stlport  *portp;
2621
2622         if (copy_from_user(&stl_dummyport, arg, sizeof(struct stlport)))
2623                 return -EFAULT;
2624         portp = stl_getport(stl_dummyport.brdnr, stl_dummyport.panelnr,
2625                  stl_dummyport.portnr);
2626         if (!portp)
2627                 return -ENODEV;
2628         return copy_to_user(arg, portp, sizeof(struct stlport)) ? -EFAULT : 0;
2629 }
2630
2631 /*****************************************************************************/
2632
2633 /*
2634  *      Return the entire driver board structure to a user app.
2635  */
2636
2637 static int stl_getbrdstruct(struct stlbrd __user *arg)
2638 {
2639         struct stlbrd   stl_dummybrd;
2640         struct stlbrd   *brdp;
2641
2642         if (copy_from_user(&stl_dummybrd, arg, sizeof(struct stlbrd)))
2643                 return -EFAULT;
2644         if (stl_dummybrd.brdnr >= STL_MAXBRDS)
2645                 return -ENODEV;
2646         brdp = stl_brds[stl_dummybrd.brdnr];
2647         if (!brdp)
2648                 return -ENODEV;
2649         return copy_to_user(arg, brdp, sizeof(struct stlbrd)) ? -EFAULT : 0;
2650 }
2651
2652 /*****************************************************************************/
2653
2654 /*
2655  *      The "staliomem" device is also required to do some special operations
2656  *      on the board and/or ports. In this driver it is mostly used for stats
2657  *      collection.
2658  */
2659
2660 static int stl_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
2661 {
2662         int     brdnr, rc;
2663         void __user *argp = (void __user *)arg;
2664
2665         pr_debug("stl_memioctl(ip=%p,fp=%p,cmd=%x,arg=%lx)\n", ip, fp, cmd,arg);
2666
2667         brdnr = iminor(ip);
2668         if (brdnr >= STL_MAXBRDS)
2669                 return -ENODEV;
2670         rc = 0;
2671
2672         switch (cmd) {
2673         case COM_GETPORTSTATS:
2674                 rc = stl_getportstats(NULL, argp);
2675                 break;
2676         case COM_CLRPORTSTATS:
2677                 rc = stl_clrportstats(NULL, argp);
2678                 break;
2679         case COM_GETBRDSTATS:
2680                 rc = stl_getbrdstats(argp);
2681                 break;
2682         case COM_READPORT:
2683                 rc = stl_getportstruct(argp);
2684                 break;
2685         case COM_READBOARD:
2686                 rc = stl_getbrdstruct(argp);
2687                 break;
2688         default:
2689                 rc = -ENOIOCTLCMD;
2690                 break;
2691         }
2692
2693         return rc;
2694 }
2695
2696 static const struct tty_operations stl_ops = {
2697         .open = stl_open,
2698         .close = stl_close,
2699         .write = stl_write,
2700         .put_char = stl_putchar,
2701         .flush_chars = stl_flushchars,
2702         .write_room = stl_writeroom,
2703         .chars_in_buffer = stl_charsinbuffer,
2704         .ioctl = stl_ioctl,
2705         .set_termios = stl_settermios,
2706         .throttle = stl_throttle,
2707         .unthrottle = stl_unthrottle,
2708         .stop = stl_stop,
2709         .start = stl_start,
2710         .hangup = stl_hangup,
2711         .flush_buffer = stl_flushbuffer,
2712         .break_ctl = stl_breakctl,
2713         .wait_until_sent = stl_waituntilsent,
2714         .send_xchar = stl_sendxchar,
2715         .read_proc = stl_readproc,
2716         .tiocmget = stl_tiocmget,
2717         .tiocmset = stl_tiocmset,
2718 };
2719
2720 /*****************************************************************************/
2721 /*                       CD1400 HARDWARE FUNCTIONS                           */
2722 /*****************************************************************************/
2723
2724 /*
2725  *      These functions get/set/update the registers of the cd1400 UARTs.
2726  *      Access to the cd1400 registers is via an address/data io port pair.
2727  *      (Maybe should make this inline...)
2728  */
2729
2730 static int stl_cd1400getreg(struct stlport *portp, int regnr)
2731 {
2732         outb((regnr + portp->uartaddr), portp->ioaddr);
2733         return inb(portp->ioaddr + EREG_DATA);
2734 }
2735
2736 static void stl_cd1400setreg(struct stlport *portp, int regnr, int value)
2737 {
2738         outb(regnr + portp->uartaddr, portp->ioaddr);
2739         outb(value, portp->ioaddr + EREG_DATA);
2740 }
2741
2742 static int stl_cd1400updatereg(struct stlport *portp, int regnr, int value)
2743 {
2744         outb(regnr + portp->uartaddr, portp->ioaddr);
2745         if (inb(portp->ioaddr + EREG_DATA) != value) {
2746                 outb(value, portp->ioaddr + EREG_DATA);
2747                 return 1;
2748         }
2749         return 0;
2750 }
2751
2752 /*****************************************************************************/
2753
2754 /*
2755  *      Inbitialize the UARTs in a panel. We don't care what sort of board
2756  *      these ports are on - since the port io registers are almost
2757  *      identical when dealing with ports.
2758  */
2759
2760 static int stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp)
2761 {
2762         unsigned int    gfrcr;
2763         int             chipmask, i, j;
2764         int             nrchips, uartaddr, ioaddr;
2765         unsigned long   flags;
2766
2767         pr_debug("stl_panelinit(brdp=%p,panelp=%p)\n", brdp, panelp);
2768
2769         spin_lock_irqsave(&brd_lock, flags);
2770         BRDENABLE(panelp->brdnr, panelp->pagenr);
2771
2772 /*
2773  *      Check that each chip is present and started up OK.
2774  */
2775         chipmask = 0;
2776         nrchips = panelp->nrports / CD1400_PORTS;
2777         for (i = 0; i < nrchips; i++) {
2778                 if (brdp->brdtype == BRD_ECHPCI) {
2779                         outb((panelp->pagenr + (i >> 1)), brdp->ioctrl);
2780                         ioaddr = panelp->iobase;
2781                 } else
2782                         ioaddr = panelp->iobase + (EREG_BANKSIZE * (i >> 1));
2783                 uartaddr = (i & 0x01) ? 0x080 : 0;
2784                 outb((GFRCR + uartaddr), ioaddr);
2785                 outb(0, (ioaddr + EREG_DATA));
2786                 outb((CCR + uartaddr), ioaddr);
2787                 outb(CCR_RESETFULL, (ioaddr + EREG_DATA));
2788                 outb(CCR_RESETFULL, (ioaddr + EREG_DATA));
2789                 outb((GFRCR + uartaddr), ioaddr);
2790                 for (j = 0; j < CCR_MAXWAIT; j++)
2791                         if ((gfrcr = inb(ioaddr + EREG_DATA)) != 0)
2792                                 break;
2793
2794                 if ((j >= CCR_MAXWAIT) || (gfrcr < 0x40) || (gfrcr > 0x60)) {
2795                         printk("STALLION: cd1400 not responding, "
2796                                 "brd=%d panel=%d chip=%d\n",
2797                                 panelp->brdnr, panelp->panelnr, i);
2798                         continue;
2799                 }
2800                 chipmask |= (0x1 << i);
2801                 outb((PPR + uartaddr), ioaddr);
2802                 outb(PPR_SCALAR, (ioaddr + EREG_DATA));
2803         }
2804
2805         BRDDISABLE(panelp->brdnr);
2806         spin_unlock_irqrestore(&brd_lock, flags);
2807         return chipmask;
2808 }
2809
2810 /*****************************************************************************/
2811
2812 /*
2813  *      Initialize hardware specific port registers.
2814  */
2815
2816 static void stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp)
2817 {
2818         unsigned long flags;
2819         pr_debug("stl_cd1400portinit(brdp=%p,panelp=%p,portp=%p)\n", brdp,
2820                         panelp, portp);
2821
2822         if ((brdp == NULL) || (panelp == NULL) ||
2823             (portp == NULL))
2824                 return;
2825
2826         spin_lock_irqsave(&brd_lock, flags);
2827         portp->ioaddr = panelp->iobase + (((brdp->brdtype == BRD_ECHPCI) ||
2828                 (portp->portnr < 8)) ? 0 : EREG_BANKSIZE);
2829         portp->uartaddr = (portp->portnr & 0x04) << 5;
2830         portp->pagenr = panelp->pagenr + (portp->portnr >> 3);
2831
2832         BRDENABLE(portp->brdnr, portp->pagenr);
2833         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2834         stl_cd1400setreg(portp, LIVR, (portp->portnr << 3));
2835         portp->hwid = stl_cd1400getreg(portp, GFRCR);
2836         BRDDISABLE(portp->brdnr);
2837         spin_unlock_irqrestore(&brd_lock, flags);
2838 }
2839
2840 /*****************************************************************************/
2841
2842 /*
2843  *      Wait for the command register to be ready. We will poll this,
2844  *      since it won't usually take too long to be ready.
2845  */
2846
2847 static void stl_cd1400ccrwait(struct stlport *portp)
2848 {
2849         int     i;
2850
2851         for (i = 0; i < CCR_MAXWAIT; i++)
2852                 if (stl_cd1400getreg(portp, CCR) == 0)
2853                         return;
2854
2855         printk("STALLION: cd1400 not responding, port=%d panel=%d brd=%d\n",
2856                 portp->portnr, portp->panelnr, portp->brdnr);
2857 }
2858
2859 /*****************************************************************************/
2860
2861 /*
2862  *      Set up the cd1400 registers for a port based on the termios port
2863  *      settings.
2864  */
2865
2866 static void stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp)
2867 {
2868         struct stlbrd   *brdp;
2869         unsigned long   flags;
2870         unsigned int    clkdiv, baudrate;
2871         unsigned char   cor1, cor2, cor3;
2872         unsigned char   cor4, cor5, ccr;
2873         unsigned char   srer, sreron, sreroff;
2874         unsigned char   mcor1, mcor2, rtpr;
2875         unsigned char   clk, div;
2876
2877         cor1 = 0;
2878         cor2 = 0;
2879         cor3 = 0;
2880         cor4 = 0;
2881         cor5 = 0;
2882         ccr = 0;
2883         rtpr = 0;
2884         clk = 0;
2885         div = 0;
2886         mcor1 = 0;
2887         mcor2 = 0;
2888         sreron = 0;
2889         sreroff = 0;
2890
2891         brdp = stl_brds[portp->brdnr];
2892         if (brdp == NULL)
2893                 return;
2894
2895 /*
2896  *      Set up the RX char ignore mask with those RX error types we
2897  *      can ignore. We can get the cd1400 to help us out a little here,
2898  *      it will ignore parity errors and breaks for us.
2899  */
2900         portp->rxignoremsk = 0;
2901         if (tiosp->c_iflag & IGNPAR) {
2902                 portp->rxignoremsk |= (ST_PARITY | ST_FRAMING | ST_OVERRUN);
2903                 cor1 |= COR1_PARIGNORE;
2904         }
2905         if (tiosp->c_iflag & IGNBRK) {
2906                 portp->rxignoremsk |= ST_BREAK;
2907                 cor4 |= COR4_IGNBRK;
2908         }
2909
2910         portp->rxmarkmsk = ST_OVERRUN;
2911         if (tiosp->c_iflag & (INPCK | PARMRK))
2912                 portp->rxmarkmsk |= (ST_PARITY | ST_FRAMING);
2913         if (tiosp->c_iflag & BRKINT)
2914                 portp->rxmarkmsk |= ST_BREAK;
2915
2916 /*
2917  *      Go through the char size, parity and stop bits and set all the
2918  *      option register appropriately.
2919  */
2920         switch (tiosp->c_cflag & CSIZE) {
2921         case CS5:
2922                 cor1 |= COR1_CHL5;
2923                 break;
2924         case CS6:
2925                 cor1 |= COR1_CHL6;
2926                 break;
2927         case CS7:
2928                 cor1 |= COR1_CHL7;
2929                 break;
2930         default:
2931                 cor1 |= COR1_CHL8;
2932                 break;
2933         }
2934
2935         if (tiosp->c_cflag & CSTOPB)
2936                 cor1 |= COR1_STOP2;
2937         else
2938                 cor1 |= COR1_STOP1;
2939
2940         if (tiosp->c_cflag & PARENB) {
2941                 if (tiosp->c_cflag & PARODD)
2942                         cor1 |= (COR1_PARENB | COR1_PARODD);
2943                 else
2944                         cor1 |= (COR1_PARENB | COR1_PAREVEN);
2945         } else {
2946                 cor1 |= COR1_PARNONE;
2947         }
2948
2949 /*
2950  *      Set the RX FIFO threshold at 6 chars. This gives a bit of breathing
2951  *      space for hardware flow control and the like. This should be set to
2952  *      VMIN. Also here we will set the RX data timeout to 10ms - this should
2953  *      really be based on VTIME.
2954  */
2955         cor3 |= FIFO_RXTHRESHOLD;
2956         rtpr = 2;
2957
2958 /*
2959  *      Calculate the baud rate timers. For now we will just assume that
2960  *      the input and output baud are the same. Could have used a baud
2961  *      table here, but this way we can generate virtually any baud rate
2962  *      we like!
2963  */
2964         baudrate = tiosp->c_cflag & CBAUD;
2965         if (baudrate & CBAUDEX) {
2966                 baudrate &= ~CBAUDEX;
2967                 if ((baudrate < 1) || (baudrate > 4))
2968                         tiosp->c_cflag &= ~CBAUDEX;
2969                 else
2970                         baudrate += 15;
2971         }
2972         baudrate = stl_baudrates[baudrate];
2973         if ((tiosp->c_cflag & CBAUD) == B38400) {
2974                 if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2975                         baudrate = 57600;
2976                 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2977                         baudrate = 115200;
2978                 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2979                         baudrate = 230400;
2980                 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2981                         baudrate = 460800;
2982                 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
2983                         baudrate = (portp->baud_base / portp->custom_divisor);
2984         }
2985         if (baudrate > STL_CD1400MAXBAUD)
2986                 baudrate = STL_CD1400MAXBAUD;
2987
2988         if (baudrate > 0) {
2989                 for (clk = 0; clk < CD1400_NUMCLKS; clk++) {
2990                         clkdiv = (portp->clk / stl_cd1400clkdivs[clk]) / baudrate;
2991                         if (clkdiv < 0x100)
2992                                 break;
2993                 }
2994                 div = (unsigned char) clkdiv;
2995         }
2996
2997 /*
2998  *      Check what form of modem signaling is required and set it up.
2999  */
3000         if ((tiosp->c_cflag & CLOCAL) == 0) {
3001                 mcor1 |= MCOR1_DCD;
3002                 mcor2 |= MCOR2_DCD;
3003                 sreron |= SRER_MODEM;
3004                 portp->flags |= ASYNC_CHECK_CD;
3005         } else
3006                 portp->flags &= ~ASYNC_CHECK_CD;
3007
3008 /*
3009  *      Setup cd1400 enhanced modes if we can. In particular we want to
3010  *      handle as much of the flow control as possible automatically. As
3011  *      well as saving a few CPU cycles it will also greatly improve flow
3012  *      control reliability.
3013  */
3014         if (tiosp->c_iflag & IXON) {
3015                 cor2 |= COR2_TXIBE;
3016                 cor3 |= COR3_SCD12;
3017                 if (tiosp->c_iflag & IXANY)
3018                         cor2 |= COR2_IXM;
3019         }
3020
3021         if (tiosp->c_cflag & CRTSCTS) {
3022                 cor2 |= COR2_CTSAE;
3023                 mcor1 |= FIFO_RTSTHRESHOLD;
3024         }
3025
3026 /*
3027  *      All cd1400 register values calculated so go through and set
3028  *      them all up.
3029  */
3030
3031         pr_debug("SETPORT: portnr=%d panelnr=%d brdnr=%d\n",
3032                 portp->portnr, portp->panelnr, portp->brdnr);
3033         pr_debug("    cor1=%x cor2=%x cor3=%x cor4=%x cor5=%x\n",
3034                 cor1, cor2, cor3, cor4, cor5);
3035         pr_debug("    mcor1=%x mcor2=%x rtpr=%x sreron=%x sreroff=%x\n",
3036                 mcor1, mcor2, rtpr, sreron, sreroff);
3037         pr_debug("    tcor=%x tbpr=%x rcor=%x rbpr=%x\n", clk, div, clk, div);
3038         pr_debug("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
3039                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP],
3040                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
3041
3042         spin_lock_irqsave(&brd_lock, flags);
3043         BRDENABLE(portp->brdnr, portp->pagenr);
3044         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3045         srer = stl_cd1400getreg(portp, SRER);
3046         stl_cd1400setreg(portp, SRER, 0);
3047         if (stl_cd1400updatereg(portp, COR1, cor1))
3048                 ccr = 1;
3049         if (stl_cd1400updatereg(portp, COR2, cor2))
3050                 ccr = 1;
3051         if (stl_cd1400updatereg(portp, COR3, cor3))
3052                 ccr = 1;
3053         if (ccr) {
3054                 stl_cd1400ccrwait(portp);
3055                 stl_cd1400setreg(portp, CCR, CCR_CORCHANGE);
3056         }
3057         stl_cd1400setreg(portp, COR4, cor4);
3058         stl_cd1400setreg(portp, COR5, cor5);
3059         stl_cd1400setreg(portp, MCOR1, mcor1);
3060         stl_cd1400setreg(portp, MCOR2, mcor2);
3061         if (baudrate > 0) {
3062                 stl_cd1400setreg(portp, TCOR, clk);
3063                 stl_cd1400setreg(portp, TBPR, div);
3064                 stl_cd1400setreg(portp, RCOR, clk);
3065                 stl_cd1400setreg(portp, RBPR, div);
3066         }
3067         stl_cd1400setreg(portp, SCHR1, tiosp->c_cc[VSTART]);
3068         stl_cd1400setreg(portp, SCHR2, tiosp->c_cc[VSTOP]);
3069         stl_cd1400setreg(portp, SCHR3, tiosp->c_cc[VSTART]);
3070         stl_cd1400setreg(portp, SCHR4, tiosp->c_cc[VSTOP]);
3071         stl_cd1400setreg(portp, RTPR, rtpr);
3072         mcor1 = stl_cd1400getreg(portp, MSVR1);
3073         if (mcor1 & MSVR1_DCD)
3074                 portp->sigs |= TIOCM_CD;
3075         else
3076                 portp->sigs &= ~TIOCM_CD;
3077         stl_cd1400setreg(portp, SRER, ((srer & ~sreroff) | sreron));
3078         BRDDISABLE(portp->brdnr);
3079         spin_unlock_irqrestore(&brd_lock, flags);
3080 }
3081
3082 /*****************************************************************************/
3083
3084 /*
3085  *      Set the state of the DTR and RTS signals.
3086  */
3087
3088 static void stl_cd1400setsignals(struct stlport *portp, int dtr, int rts)
3089 {
3090         unsigned char   msvr1, msvr2;
3091         unsigned long   flags;
3092
3093         pr_debug("stl_cd1400setsignals(portp=%p,dtr=%d,rts=%d)\n",
3094                         portp, dtr, rts);
3095
3096         msvr1 = 0;
3097         msvr2 = 0;
3098         if (dtr > 0)
3099                 msvr1 = MSVR1_DTR;
3100         if (rts > 0)
3101                 msvr2 = MSVR2_RTS;
3102
3103         spin_lock_irqsave(&brd_lock, flags);
3104         BRDENABLE(portp->brdnr, portp->pagenr);
3105         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3106         if (rts >= 0)
3107                 stl_cd1400setreg(portp, MSVR2, msvr2);
3108         if (dtr >= 0)
3109                 stl_cd1400setreg(portp, MSVR1, msvr1);
3110         BRDDISABLE(portp->brdnr);
3111         spin_unlock_irqrestore(&brd_lock, flags);
3112 }
3113
3114 /*****************************************************************************/
3115
3116 /*
3117  *      Return the state of the signals.
3118  */
3119
3120 static int stl_cd1400getsignals(struct stlport *portp)
3121 {
3122         unsigned char   msvr1, msvr2;
3123         unsigned long   flags;
3124         int             sigs;
3125
3126         pr_debug("stl_cd1400getsignals(portp=%p)\n", portp);
3127
3128         spin_lock_irqsave(&brd_lock, flags);
3129         BRDENABLE(portp->brdnr, portp->pagenr);
3130         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3131         msvr1 = stl_cd1400getreg(portp, MSVR1);
3132         msvr2 = stl_cd1400getreg(portp, MSVR2);
3133         BRDDISABLE(portp->brdnr);
3134         spin_unlock_irqrestore(&brd_lock, flags);
3135
3136         sigs = 0;
3137         sigs |= (msvr1 & MSVR1_DCD) ? TIOCM_CD : 0;
3138         sigs |= (msvr1 & MSVR1_CTS) ? TIOCM_CTS : 0;
3139         sigs |= (msvr1 & MSVR1_DTR) ? TIOCM_DTR : 0;
3140         sigs |= (msvr2 & MSVR2_RTS) ? TIOCM_RTS : 0;
3141 #if 0
3142         sigs |= (msvr1 & MSVR1_RI) ? TIOCM_RI : 0;
3143         sigs |= (msvr1 & MSVR1_DSR) ? TIOCM_DSR : 0;
3144 #else
3145         sigs |= TIOCM_DSR;
3146 #endif
3147         return sigs;
3148 }
3149
3150 /*****************************************************************************/
3151
3152 /*
3153  *      Enable/Disable the Transmitter and/or Receiver.
3154  */
3155
3156 static void stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx)
3157 {
3158         unsigned char   ccr;
3159         unsigned long   flags;
3160
3161         pr_debug("stl_cd1400enablerxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
3162
3163         ccr = 0;
3164
3165         if (tx == 0)
3166                 ccr |= CCR_TXDISABLE;
3167         else if (tx > 0)
3168                 ccr |= CCR_TXENABLE;
3169         if (rx == 0)
3170                 ccr |= CCR_RXDISABLE;
3171         else if (rx > 0)
3172                 ccr |= CCR_RXENABLE;
3173
3174         spin_lock_irqsave(&brd_lock, flags);
3175         BRDENABLE(portp->brdnr, portp->pagenr);
3176         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3177         stl_cd1400ccrwait(portp);
3178         stl_cd1400setreg(portp, CCR, ccr);
3179         stl_cd1400ccrwait(portp);
3180         BRDDISABLE(portp->brdnr);
3181         spin_unlock_irqrestore(&brd_lock, flags);
3182 }
3183
3184 /*****************************************************************************/
3185
3186 /*
3187  *      Start/stop the Transmitter and/or Receiver.
3188  */
3189
3190 static void stl_cd1400startrxtx(struct stlport *portp, int rx, int tx)
3191 {
3192         unsigned char   sreron, sreroff;
3193         unsigned long   flags;
3194
3195         pr_debug("stl_cd1400startrxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
3196
3197         sreron = 0;
3198         sreroff = 0;
3199         if (tx == 0)
3200                 sreroff |= (SRER_TXDATA | SRER_TXEMPTY);
3201         else if (tx == 1)
3202                 sreron |= SRER_TXDATA;
3203         else if (tx >= 2)
3204                 sreron |= SRER_TXEMPTY;
3205         if (rx == 0)
3206                 sreroff |= SRER_RXDATA;
3207         else if (rx > 0)
3208                 sreron |= SRER_RXDATA;
3209
3210         spin_lock_irqsave(&brd_lock, flags);
3211         BRDENABLE(portp->brdnr, portp->pagenr);
3212         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3213         stl_cd1400setreg(portp, SRER,
3214                 ((stl_cd1400getreg(portp, SRER) & ~sreroff) | sreron));
3215         BRDDISABLE(portp->brdnr);
3216         if (tx > 0)
3217                 set_bit(ASYI_TXBUSY, &portp->istate);
3218         spin_unlock_irqrestore(&brd_lock, flags);
3219 }
3220
3221 /*****************************************************************************/
3222
3223 /*
3224  *      Disable all interrupts from this port.
3225  */
3226
3227 static void stl_cd1400disableintrs(struct stlport *portp)
3228 {
3229         unsigned long   flags;
3230
3231         pr_debug("stl_cd1400disableintrs(portp=%p)\n", portp);
3232
3233         spin_lock_irqsave(&brd_lock, flags);
3234         BRDENABLE(portp->brdnr, portp->pagenr);
3235         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3236         stl_cd1400setreg(portp, SRER, 0);
3237         BRDDISABLE(portp->brdnr);
3238         spin_unlock_irqrestore(&brd_lock, flags);
3239 }
3240
3241 /*****************************************************************************/
3242
3243 static void stl_cd1400sendbreak(struct stlport *portp, int len)
3244 {
3245         unsigned long   flags;
3246
3247         pr_debug("stl_cd1400sendbreak(portp=%p,len=%d)\n", portp, len);
3248
3249         spin_lock_irqsave(&brd_lock, flags);
3250         BRDENABLE(portp->brdnr, portp->pagenr);
3251         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3252         stl_cd1400setreg(portp, SRER,
3253                 ((stl_cd1400getreg(portp, SRER) & ~SRER_TXDATA) |
3254                 SRER_TXEMPTY));
3255         BRDDISABLE(portp->brdnr);
3256         portp->brklen = len;
3257         if (len == 1)
3258                 portp->stats.txbreaks++;
3259         spin_unlock_irqrestore(&brd_lock, flags);
3260 }
3261
3262 /*****************************************************************************/
3263
3264 /*
3265  *      Take flow control actions...
3266  */
3267
3268 static void stl_cd1400flowctrl(struct stlport *portp, int state)
3269 {
3270         struct tty_struct       *tty;
3271         unsigned long           flags;
3272
3273         pr_debug("stl_cd1400flowctrl(portp=%p,state=%x)\n", portp, state);
3274
3275         if (portp == NULL)
3276                 return;
3277         tty = portp->tty;
3278         if (tty == NULL)
3279                 return;
3280
3281         spin_lock_irqsave(&brd_lock, flags);
3282         BRDENABLE(portp->brdnr, portp->pagenr);
3283         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3284
3285         if (state) {
3286                 if (tty->termios->c_iflag & IXOFF) {
3287                         stl_cd1400ccrwait(portp);
3288                         stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1);
3289                         portp->stats.rxxon++;
3290                         stl_cd1400ccrwait(portp);
3291                 }
3292 /*
3293  *              Question: should we return RTS to what it was before? It may
3294  *              have been set by an ioctl... Suppose not, since if you have
3295  *              hardware flow control set then it is pretty silly to go and
3296  *              set the RTS line by hand.
3297  */
3298                 if (tty->termios->c_cflag & CRTSCTS) {
3299                         stl_cd1400setreg(portp, MCOR1,
3300                                 (stl_cd1400getreg(portp, MCOR1) |
3301                                 FIFO_RTSTHRESHOLD));
3302                         stl_cd1400setreg(portp, MSVR2, MSVR2_RTS);
3303                         portp->stats.rxrtson++;
3304                 }
3305         } else {
3306                 if (tty->termios->c_iflag & IXOFF) {
3307                         stl_cd1400ccrwait(portp);
3308                         stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2);
3309                         portp->stats.rxxoff++;
3310                         stl_cd1400ccrwait(portp);