Merge from vendor branch FILE:
[dragonfly.git] / sys / dev / serial / stl / stallion.c
1 /*****************************************************************************/
2
3 /*
4  * stallion.c  -- stallion multiport serial driver.
5  *
6  * Copyright (c) 1995-1996 Greg Ungerer (gerg@stallion.oz.au).
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *      This product includes software developed by Greg Ungerer.
20  * 4. Neither the name of the author nor the names of any co-contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * $FreeBSD: src/sys/i386/isa/stallion.c,v 1.39.2.2 2001/08/30 12:29:57 murray Exp $
37  * $DragonFly: src/sys/dev/serial/stl/stallion.c,v 1.12 2004/09/19 02:00:25 dillon Exp $
38  */
39
40 /*****************************************************************************/
41
42 #define TTYDEFCHARS     1
43
44 #include "use_pci.h"
45 #include "opt_compat.h"
46
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/kernel.h>
50 #include <sys/malloc.h>
51 #include <sys/tty.h>
52 #include <sys/proc.h>
53 #include <sys/conf.h>
54 #include <sys/fcntl.h>
55 #include <bus/isa/i386/isa_device.h>
56 #include <i386/isa/ic/scd1400.h>
57 #include <i386/isa/ic/sc26198.h>
58 #include <machine/comstats.h>
59
60 #if NPCI > 0
61 #include <bus/pci/pcivar.h>
62 #include <bus/pci/pcireg.h>
63 #endif
64
65 #undef STLDEBUG
66
67 /*****************************************************************************/
68
69 /*
70  *      Define the version level of the kernel - so we can compile in the
71  *      appropriate bits of code. By default this will compile for a 2.1
72  *      level kernel.
73  */
74 #define VFREEBSD        220
75
76 #if VFREEBSD >= 220
77 #define STATIC          static
78 #else
79 #define STATIC
80 #endif
81
82 /*****************************************************************************/
83
84 /*
85  *      Define different board types. At the moment I have only declared
86  *      those boards that this driver supports. But I will use the standard
87  *      "assigned" board numbers. In the future this driver will support
88  *      some of the other Stallion boards. Currently supported boards are
89  *      abbreviated as EIO = EasyIO and ECH = EasyConnection 8/32.
90  */
91 #define BRD_EASYIO      20
92 #define BRD_ECH         21
93 #define BRD_ECHMC       22
94 #define BRD_ECHPCI      26
95 #define BRD_ECH64PCI    27
96 #define BRD_EASYIOPCI   28
97
98 /*
99  *      When using the BSD "config" stuff there is no easy way to specifiy
100  *      a secondary IO address region. So it is hard wired here. Also the
101  *      shared interrupt information is hard wired here...
102  */
103 static unsigned int     stl_ioshared = 0x280;
104 static unsigned int     stl_irqshared = 0;
105
106 /*****************************************************************************/
107
108 /*
109  *      Define important driver limitations.
110  */
111 #define STL_MAXBRDS             8
112 #define STL_MAXPANELS           4
113 #define STL_MAXBANKS            8
114 #define STL_PORTSPERPANEL       16
115 #define STL_PORTSPERBRD         64
116
117 /*
118  *      Define the important minor number break down bits. These have been
119  *      chosen to be "compatible" with the standard sio driver minor numbers.
120  *      Extra high bits are used to distinguish between boards.
121  */
122 #define STL_CALLOUTDEV          0x80
123 #define STL_CTRLLOCK            0x40
124 #define STL_CTRLINIT            0x20
125 #define STL_CTRLDEV             (STL_CTRLLOCK | STL_CTRLINIT)
126
127 #define STL_MEMDEV      0x07000000
128
129 #define STL_DEFSPEED    TTYDEF_SPEED
130 #define STL_DEFCFLAG    (CS8 | CREAD | HUPCL)
131
132 /*
133  *      I haven't really decided (or measured) what buffer sizes give
134  *      a good balance between performance and memory usage. These seem
135  *      to work pretty well...
136  */
137 #define STL_RXBUFSIZE           2048
138 #define STL_TXBUFSIZE           2048
139
140 #define STL_TXBUFLOW            (STL_TXBUFSIZE / 4)
141 #define STL_RXBUFHIGH           (3 * STL_RXBUFSIZE / 4)
142
143 /*****************************************************************************/
144
145 /*
146  *      Define our local driver identity first. Set up stuff to deal with
147  *      all the local structures required by a serial tty driver.
148  */
149 static const char       stl_drvname[] = "stl";
150 static const char       stl_longdrvname[] = "Stallion Multiport Serial Driver";
151 static const char       stl_drvversion[] = "2.0.0";
152 static int              stl_brdprobed[STL_MAXBRDS];
153
154 static int              stl_nrbrds = 0;
155 static int              stl_doingtimeout = 0;
156 static struct callout   stl_poll_ch;
157
158 static const char       __file__[] = /*__FILE__*/ "stallion.c";
159
160 /*
161  *      Define global stats structures. Not used often, and can be
162  *      re-used for each stats call.
163  */
164 static combrd_t         stl_brdstats;
165 static comstats_t       stl_comstats;
166
167 /*****************************************************************************/
168
169 /*
170  *      Define a set of structures to hold all the board/panel/port info
171  *      for our ports. These will be dynamically allocated as required.
172  */
173
174 /*
175  *      Define a ring queue structure for each port. This will hold the
176  *      TX data waiting to be output. Characters are fed into this buffer
177  *      from the line discipline (or even direct from user space!) and
178  *      then fed into the UARTs during interrupts. Will use a clasic ring
179  *      queue here for this. The good thing about this type of ring queue
180  *      is that the head and tail pointers can be updated without interrupt
181  *      protection - since "write" code only needs to change the head, and
182  *      interrupt code only needs to change the tail.
183  */
184 typedef struct {
185         char    *buf;
186         char    *endbuf;
187         char    *head;
188         char    *tail;
189 } stlrq_t;
190
191 /*
192  *      Port, panel and board structures to hold status info about each.
193  *      The board structure contains pointers to structures for each panel
194  *      connected to it, and in turn each panel structure contains pointers
195  *      for each port structure for each port on that panel. Note that
196  *      the port structure also contains the board and panel number that it
197  *      is associated with, this makes it (fairly) easy to get back to the
198  *      board/panel info for a port. Also note that the tty struct is at
199  *      the top of the structure, this is important, since the code uses
200  *      this fact to get the port struct pointer from the tty struct
201  *      pointer!
202  */
203 typedef struct stlport {
204         struct tty      tty;
205         int             portnr;
206         int             panelnr;
207         int             brdnr;
208         int             ioaddr;
209         int             uartaddr;
210         int             pagenr;
211         int             callout;
212         int             brklen;
213         int             dtrwait;
214         int             dotimestamp;
215         int             waitopens;
216         int             hotchar;
217         void            *uartp;
218         unsigned int    state;
219         unsigned int    hwid;
220         unsigned int    sigs;
221         unsigned int    rxignoremsk;
222         unsigned int    rxmarkmsk;
223         unsigned int    crenable;
224         unsigned int    imr;
225         unsigned long   clk;
226         struct termios  initintios;
227         struct termios  initouttios;
228         struct termios  lockintios;
229         struct termios  lockouttios;
230         struct timeval  timestamp;
231         comstats_t      stats;
232         stlrq_t         tx;
233         stlrq_t         rx;
234         stlrq_t         rxstatus;
235         struct callout  dtr_ch;
236 } stlport_t;
237
238 typedef struct stlpanel {
239         int             panelnr;
240         int             brdnr;
241         int             pagenr;
242         int             nrports;
243         int             iobase;
244         unsigned int    hwid;
245         unsigned int    ackmask;
246         void            (*isr)(struct stlpanel *panelp, unsigned int iobase);
247         void            *uartp;
248         stlport_t       *ports[STL_PORTSPERPANEL];
249 } stlpanel_t;
250
251 typedef struct stlbrd {
252         int             brdnr;
253         int             brdtype;
254         int             unitid;
255         int             state;
256         int             nrpanels;
257         int             nrports;
258         int             nrbnks;
259         int             irq;
260         int             irqtype;
261         unsigned int    ioaddr1;
262         unsigned int    ioaddr2;
263         unsigned int    iostatus;
264         unsigned int    ioctrl;
265         unsigned int    ioctrlval;
266         unsigned int    hwid;
267         unsigned long   clk;
268         void            (*isr)(struct stlbrd *brdp);
269         unsigned int    bnkpageaddr[STL_MAXBANKS];
270         unsigned int    bnkstataddr[STL_MAXBANKS];
271         stlpanel_t      *bnk2panel[STL_MAXBANKS];
272         stlpanel_t      *panels[STL_MAXPANELS];
273         stlport_t       *ports[STL_PORTSPERBRD];
274 } stlbrd_t;
275
276 static stlbrd_t         *stl_brds[STL_MAXBRDS];
277
278 /*
279  *      Per board state flags. Used with the state field of the board struct.
280  *      Not really much here yet!
281  */
282 #define BRD_FOUND       0x1
283
284 /*
285  *      Define the port structure state flags. These set of flags are
286  *      modified at interrupt time - so setting and reseting them needs
287  *      to be atomic.
288  */
289 #define ASY_TXLOW       0x1
290 #define ASY_RXDATA      0x2
291 #define ASY_DCDCHANGE   0x4
292 #define ASY_DTRWAIT     0x8
293 #define ASY_RTSFLOW     0x10
294 #define ASY_RTSFLOWMODE 0x20
295 #define ASY_CTSFLOWMODE 0x40
296 #define ASY_TXFLOWED    0x80
297 #define ASY_TXBUSY      0x100
298 #define ASY_TXEMPTY     0x200
299
300 #define ASY_ACTIVE      (ASY_TXLOW | ASY_RXDATA | ASY_DCDCHANGE)
301
302 /*
303  *      Define an array of board names as printable strings. Handy for
304  *      referencing boards when printing trace and stuff.
305  */
306 static char     *stl_brdnames[] = {
307         (char *) NULL,
308         (char *) NULL,
309         (char *) NULL,
310         (char *) NULL,
311         (char *) NULL,
312         (char *) NULL,
313         (char *) NULL,
314         (char *) NULL,
315         (char *) NULL,
316         (char *) NULL,
317         (char *) NULL,
318         (char *) NULL,
319         (char *) NULL,
320         (char *) NULL,
321         (char *) NULL,
322         (char *) NULL,
323         (char *) NULL,
324         (char *) NULL,
325         (char *) NULL,
326         (char *) NULL,
327         "EasyIO",
328         "EC8/32-AT",
329         "EC8/32-MC",
330         (char *) NULL,
331         (char *) NULL,
332         (char *) NULL,
333         "EC8/32-PCI",
334         "EC8/64-PCI",
335         "EasyIO-PCI",
336 };
337
338 /*****************************************************************************/
339
340 /*
341  *      Hardware ID bits for the EasyIO and ECH boards. These defines apply
342  *      to the directly accessable io ports of these boards (not the cd1400
343  *      uarts - they are in scd1400.h).
344  */
345 #define EIO_8PORTRS     0x04
346 #define EIO_4PORTRS     0x05
347 #define EIO_8PORTDI     0x00
348 #define EIO_8PORTM      0x06
349 #define EIO_MK3         0x03
350 #define EIO_IDBITMASK   0x07
351
352 #define EIO_BRDMASK     0xf0
353 #define ID_BRD4         0x10
354 #define ID_BRD8         0x20
355 #define ID_BRD16        0x30
356
357 #define EIO_INTRPEND    0x08
358 #define EIO_INTEDGE     0x00
359 #define EIO_INTLEVEL    0x08
360
361 #define ECH_ID          0xa0
362 #define ECH_IDBITMASK   0xe0
363 #define ECH_BRDENABLE   0x08
364 #define ECH_BRDDISABLE  0x00
365 #define ECH_INTENABLE   0x01
366 #define ECH_INTDISABLE  0x00
367 #define ECH_INTLEVEL    0x02
368 #define ECH_INTEDGE     0x00
369 #define ECH_INTRPEND    0x01
370 #define ECH_BRDRESET    0x01
371
372 #define ECHMC_INTENABLE 0x01
373 #define ECHMC_BRDRESET  0x02
374
375 #define ECH_PNLSTATUS   2
376 #define ECH_PNL16PORT   0x20
377 #define ECH_PNLIDMASK   0x07
378 #define ECH_PNLXPID     0x40
379 #define ECH_PNLINTRPEND 0x80
380 #define ECH_ADDR2MASK   0x1e0
381
382 #define EIO_CLK         25000000
383 #define EIO_CLK8M       20000000
384 #define ECH_CLK         EIO_CLK
385
386 /*
387  *      Define the PCI vendor and device ID for Stallion PCI boards.
388  */
389 #define STL_PCINSVENDID 0x100b
390 #define STL_PCINSDEVID  0xd001
391
392 #define STL_PCIVENDID   0x124d
393 #define STL_PCI32DEVID  0x0000
394 #define STL_PCI64DEVID  0x0002
395 #define STL_PCIEIODEVID 0x0003
396
397 #define STL_PCIBADCLASS 0x0101
398
399 typedef struct stlpcibrd {
400         unsigned short          vendid;
401         unsigned short          devid;
402         int                     brdtype;
403 } stlpcibrd_t;
404
405 static  stlpcibrd_t     stl_pcibrds[] = {
406         { STL_PCIVENDID, STL_PCI64DEVID, BRD_ECH64PCI },
407         { STL_PCIVENDID, STL_PCIEIODEVID, BRD_EASYIOPCI },
408         { STL_PCIVENDID, STL_PCI32DEVID, BRD_ECHPCI },
409         { STL_PCINSVENDID, STL_PCINSDEVID, BRD_ECHPCI },
410 };
411
412 static int      stl_nrpcibrds = sizeof(stl_pcibrds) / sizeof(stlpcibrd_t);
413
414 /*****************************************************************************/
415
416 /*
417  *      Define the vector mapping bits for the programmable interrupt board
418  *      hardware. These bits encode the interrupt for the board to use - it
419  *      is software selectable (except the EIO-8M).
420  */
421 static unsigned char    stl_vecmap[] = {
422         0xff, 0xff, 0xff, 0x04, 0x06, 0x05, 0xff, 0x07,
423         0xff, 0xff, 0x00, 0x02, 0x01, 0xff, 0xff, 0x03
424 };
425
426 /*
427  *      Set up enable and disable macros for the ECH boards. They require
428  *      the secondary io address space to be activated and deactivated.
429  *      This way all ECH boards can share their secondary io region.
430  *      If this is an ECH-PCI board then also need to set the page pointer
431  *      to point to the correct page.
432  */
433 #define BRDENABLE(brdnr,pagenr)                                         \
434         if (stl_brds[(brdnr)]->brdtype == BRD_ECH)                      \
435                 outb(stl_brds[(brdnr)]->ioctrl,                         \
436                         (stl_brds[(brdnr)]->ioctrlval | ECH_BRDENABLE));\
437         else if (stl_brds[(brdnr)]->brdtype == BRD_ECHPCI)              \
438                 outb(stl_brds[(brdnr)]->ioctrl, (pagenr));
439
440 #define BRDDISABLE(brdnr)                                               \
441         if (stl_brds[(brdnr)]->brdtype == BRD_ECH)                      \
442                 outb(stl_brds[(brdnr)]->ioctrl,                         \
443                         (stl_brds[(brdnr)]->ioctrlval | ECH_BRDDISABLE));
444
445 /*
446  *      Define some spare buffer space for un-wanted received characters.
447  */
448 static char     stl_unwanted[SC26198_RXFIFOSIZE];
449
450 /*****************************************************************************/
451
452 /*
453  *      Define macros to extract a brd and port number from a minor number.
454  *      This uses the extended minor number range in the upper 2 bytes of
455  *      the device number. This gives us plenty of minor numbers to play
456  *      with...
457  */
458 #define MKDEV2BRD(m)    ((minor(m) & 0x00700000) >> 20)
459 #define MKDEV2PORT(m)   ((minor(m) & 0x1f) | ((minor(m) & 0x00010000) >> 11))
460
461 /*
462  *      Define some handy local macros...
463  */
464 #ifndef MIN
465 #define MIN(a,b)        (((a) <= (b)) ? (a) : (b))
466 #endif
467
468 /*****************************************************************************/
469
470 /*
471  *      Declare all those functions in this driver!  First up is the set of
472  *      externally visible functions.
473  */
474
475 static int      stlprobe(struct isa_device *idp);
476 static int      stlattach(struct isa_device *idp);
477
478 STATIC  d_open_t        stlopen;
479 STATIC  d_close_t       stlclose;
480 STATIC  d_ioctl_t       stlioctl;
481
482 /*
483  *      Internal function prototypes.
484  */
485 static stlport_t *stl_dev2port(dev_t dev);
486 static int      stl_findfreeunit(void);
487 static int      stl_rawopen(stlport_t *portp);
488 static int      stl_rawclose(stlport_t *portp);
489 static void     stl_flush(stlport_t *portp, int flag);
490 static int      stl_param(struct tty *tp, struct termios *tiosp);
491 static void     stl_start(struct tty *tp);
492 static void     stl_stop(struct tty *tp, int);
493 static void     stl_ttyoptim(stlport_t *portp, struct termios *tiosp);
494 static void     stl_dotimeout(void);
495 static void     stl_poll(void *arg);
496 static void     stl_rxprocess(stlport_t *portp);
497 static void     stl_flowcontrol(stlport_t *portp, int hw, int sw);
498 static void     stl_dtrwakeup(void *arg);
499 static int      stl_brdinit(stlbrd_t *brdp);
500 static int      stl_initeio(stlbrd_t *brdp);
501 static int      stl_initech(stlbrd_t *brdp);
502 static int      stl_initports(stlbrd_t *brdp, stlpanel_t *panelp);
503 static void     stl_eiointr(stlbrd_t *brdp);
504 static void     stl_echatintr(stlbrd_t *brdp);
505 static void     stl_echmcaintr(stlbrd_t *brdp);
506 static void     stl_echpciintr(stlbrd_t *brdp);
507 static void     stl_echpci64intr(stlbrd_t *brdp);
508 static int      stl_memioctl(dev_t dev, unsigned long cmd, caddr_t data,
509                         int flag, struct thread *td);
510 static int      stl_getbrdstats(caddr_t data);
511 static int      stl_getportstats(stlport_t *portp, caddr_t data);
512 static int      stl_clrportstats(stlport_t *portp, caddr_t data);
513 static stlport_t *stl_getport(int brdnr, int panelnr, int portnr);
514 static ointhand2_t      stlintr;
515
516 #if NPCI > 0
517 static const char *stlpciprobe(pcici_t tag, pcidi_t type);
518 static void     stlpciattach(pcici_t tag, int unit);
519 static void     stlpciintr(void * arg);
520 #endif
521
522 /*
523  *      CD1400 uart specific handling functions.
524  */
525 static void     stl_cd1400setreg(stlport_t *portp, int regnr, int value);
526 static int      stl_cd1400getreg(stlport_t *portp, int regnr);
527 static int      stl_cd1400updatereg(stlport_t *portp, int regnr, int value);
528 static int      stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp);
529 static void     stl_cd1400portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp);
530 static int      stl_cd1400setport(stlport_t *portp, struct termios *tiosp);
531 static int      stl_cd1400getsignals(stlport_t *portp);
532 static void     stl_cd1400setsignals(stlport_t *portp, int dtr, int rts);
533 static void     stl_cd1400ccrwait(stlport_t *portp);
534 static void     stl_cd1400enablerxtx(stlport_t *portp, int rx, int tx);
535 static void     stl_cd1400startrxtx(stlport_t *portp, int rx, int tx);
536 static void     stl_cd1400disableintrs(stlport_t *portp);
537 static void     stl_cd1400sendbreak(stlport_t *portp, long len);
538 static void     stl_cd1400sendflow(stlport_t *portp, int hw, int sw);
539 static int      stl_cd1400datastate(stlport_t *portp);
540 static void     stl_cd1400flush(stlport_t *portp, int flag);
541 static __inline void    stl_cd1400txisr(stlpanel_t *panelp, int ioaddr);
542 static void     stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr);
543 static void     stl_cd1400mdmisr(stlpanel_t *panelp, int ioaddr);
544 static void     stl_cd1400eiointr(stlpanel_t *panelp, unsigned int iobase);
545 static void     stl_cd1400echintr(stlpanel_t *panelp, unsigned int iobase);
546
547 /*
548  *      SC26198 uart specific handling functions.
549  */
550 static void     stl_sc26198setreg(stlport_t *portp, int regnr, int value);
551 static int      stl_sc26198getreg(stlport_t *portp, int regnr);
552 static int      stl_sc26198updatereg(stlport_t *portp, int regnr, int value);
553 static int      stl_sc26198getglobreg(stlport_t *portp, int regnr);
554 static int      stl_sc26198panelinit(stlbrd_t *brdp, stlpanel_t *panelp);
555 static void     stl_sc26198portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp);
556 static int      stl_sc26198setport(stlport_t *portp, struct termios *tiosp);
557 static int      stl_sc26198getsignals(stlport_t *portp);
558 static void     stl_sc26198setsignals(stlport_t *portp, int dtr, int rts);
559 static void     stl_sc26198enablerxtx(stlport_t *portp, int rx, int tx);
560 static void     stl_sc26198startrxtx(stlport_t *portp, int rx, int tx);
561 static void     stl_sc26198disableintrs(stlport_t *portp);
562 static void     stl_sc26198sendbreak(stlport_t *portp, long len);
563 static void     stl_sc26198sendflow(stlport_t *portp, int hw, int sw);
564 static int      stl_sc26198datastate(stlport_t *portp);
565 static void     stl_sc26198flush(stlport_t *portp, int flag);
566 static void     stl_sc26198txunflow(stlport_t *portp);
567 static void     stl_sc26198wait(stlport_t *portp);
568 static void     stl_sc26198intr(stlpanel_t *panelp, unsigned int iobase);
569 static void     stl_sc26198txisr(stlport_t *port);
570 static void     stl_sc26198rxisr(stlport_t *port, unsigned int iack);
571 static void     stl_sc26198rxgoodchars(stlport_t *portp);
572 static void     stl_sc26198rxbadchars(stlport_t *portp);
573 static void     stl_sc26198otherisr(stlport_t *port, unsigned int iack);
574
575 /*****************************************************************************/
576
577 /*
578  *      Generic UART support structure.
579  */
580 typedef struct uart {
581         int     (*panelinit)(stlbrd_t *brdp, stlpanel_t *panelp);
582         void    (*portinit)(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp);
583         int     (*setport)(stlport_t *portp, struct termios *tiosp);
584         int     (*getsignals)(stlport_t *portp);
585         void    (*setsignals)(stlport_t *portp, int dtr, int rts);
586         void    (*enablerxtx)(stlport_t *portp, int rx, int tx);
587         void    (*startrxtx)(stlport_t *portp, int rx, int tx);
588         void    (*disableintrs)(stlport_t *portp);
589         void    (*sendbreak)(stlport_t *portp, long len);
590         void    (*sendflow)(stlport_t *portp, int hw, int sw);
591         void    (*flush)(stlport_t *portp, int flag);
592         int     (*datastate)(stlport_t *portp);
593         void    (*intr)(stlpanel_t *panelp, unsigned int iobase);
594 } uart_t;
595
596 /*
597  *      Define some macros to make calling these functions nice and clean.
598  */
599 #define stl_panelinit           (* ((uart_t *) panelp->uartp)->panelinit)
600 #define stl_portinit            (* ((uart_t *) portp->uartp)->portinit)
601 #define stl_setport             (* ((uart_t *) portp->uartp)->setport)
602 #define stl_getsignals          (* ((uart_t *) portp->uartp)->getsignals)
603 #define stl_setsignals          (* ((uart_t *) portp->uartp)->setsignals)
604 #define stl_enablerxtx          (* ((uart_t *) portp->uartp)->enablerxtx)
605 #define stl_startrxtx           (* ((uart_t *) portp->uartp)->startrxtx)
606 #define stl_disableintrs        (* ((uart_t *) portp->uartp)->disableintrs)
607 #define stl_sendbreak           (* ((uart_t *) portp->uartp)->sendbreak)
608 #define stl_sendflow            (* ((uart_t *) portp->uartp)->sendflow)
609 #define stl_uartflush           (* ((uart_t *) portp->uartp)->flush)
610 #define stl_datastate           (* ((uart_t *) portp->uartp)->datastate)
611
612 /*****************************************************************************/
613
614 /*
615  *      CD1400 UART specific data initialization.
616  */
617 static uart_t stl_cd1400uart = {
618         stl_cd1400panelinit,
619         stl_cd1400portinit,
620         stl_cd1400setport,
621         stl_cd1400getsignals,
622         stl_cd1400setsignals,
623         stl_cd1400enablerxtx,
624         stl_cd1400startrxtx,
625         stl_cd1400disableintrs,
626         stl_cd1400sendbreak,
627         stl_cd1400sendflow,
628         stl_cd1400flush,
629         stl_cd1400datastate,
630         stl_cd1400eiointr
631 };
632
633 /*
634  *      Define the offsets within the register bank of a cd1400 based panel.
635  *      These io address offsets are common to the EasyIO board as well.
636  */
637 #define EREG_ADDR       0
638 #define EREG_DATA       4
639 #define EREG_RXACK      5
640 #define EREG_TXACK      6
641 #define EREG_MDACK      7
642
643 #define EREG_BANKSIZE   8
644
645 #define CD1400_CLK      25000000
646 #define CD1400_CLK8M    20000000
647
648 /*
649  *      Define the cd1400 baud rate clocks. These are used when calculating
650  *      what clock and divisor to use for the required baud rate. Also
651  *      define the maximum baud rate allowed, and the default base baud.
652  */
653 static int      stl_cd1400clkdivs[] = {
654         CD1400_CLK0, CD1400_CLK1, CD1400_CLK2, CD1400_CLK3, CD1400_CLK4
655 };
656
657 /*
658  *      Define the maximum baud rate of the cd1400 devices.
659  */
660 #define CD1400_MAXBAUD  230400
661
662 /*****************************************************************************/
663
664 /*
665  *      SC26198 UART specific data initization.
666  */
667 static uart_t stl_sc26198uart = {
668         stl_sc26198panelinit,
669         stl_sc26198portinit,
670         stl_sc26198setport,
671         stl_sc26198getsignals,
672         stl_sc26198setsignals,
673         stl_sc26198enablerxtx,
674         stl_sc26198startrxtx,
675         stl_sc26198disableintrs,
676         stl_sc26198sendbreak,
677         stl_sc26198sendflow,
678         stl_sc26198flush,
679         stl_sc26198datastate,
680         stl_sc26198intr
681 };
682
683 /*
684  *      Define the offsets within the register bank of a sc26198 based panel.
685  */
686 #define XP_DATA         0
687 #define XP_ADDR         1
688 #define XP_MODID        2
689 #define XP_STATUS       2
690 #define XP_IACK         3
691
692 #define XP_BANKSIZE     4
693
694 /*
695  *      Define the sc26198 baud rate table. Offsets within the table
696  *      represent the actual baud rate selector of sc26198 registers.
697  */
698 static unsigned int     sc26198_baudtable[] = {
699         50, 75, 150, 200, 300, 450, 600, 900, 1200, 1800, 2400, 3600,
700         4800, 7200, 9600, 14400, 19200, 28800, 38400, 57600, 115200,
701         230400, 460800
702 };
703
704 #define SC26198_NRBAUDS (sizeof(sc26198_baudtable) / sizeof(unsigned int))
705
706 /*
707  *      Define the maximum baud rate of the sc26198 devices.
708  */
709 #define SC26198_MAXBAUD 460800
710
711 /*****************************************************************************/
712
713 /*
714  *      Declare the driver isa structure.
715  */
716 struct isa_driver       stldriver = {
717         stlprobe, stlattach, "stl"
718 };
719
720 /*****************************************************************************/
721
722 #if NPCI > 0
723
724 /*
725  *      Declare the driver pci structure.
726  */
727 static unsigned long    stl_count;
728
729 static struct pci_device        stlpcidriver = {
730         "stl",
731         stlpciprobe,
732         stlpciattach,
733         &stl_count,
734         NULL,
735 };
736
737 COMPAT_PCI_DRIVER (stlpci, stlpcidriver);
738
739 #endif
740
741 /*****************************************************************************/
742
743 #if VFREEBSD >= 220
744
745 /*
746  *      FreeBSD-2.2+ kernel linkage.
747  */
748
749 #define CDEV_MAJOR      72
750 static struct cdevsw stl_cdevsw = {
751         /* name */      "stl",
752         /* maj */       CDEV_MAJOR,
753         /* flags */     D_TTY | D_KQFILTER,
754         /* port */      NULL,
755         /* clone */     NULL,
756
757         /* open */      stlopen,
758         /* close */     stlclose,
759         /* read */      ttyread,
760         /* write */     ttywrite,
761         /* ioctl */     stlioctl,
762         /* poll */      ttypoll,
763         /* mmap */      nommap,
764         /* strategy */  nostrategy,
765         /* dump */      nodump,
766         /* psize */     nopsize,
767         /* kqfilter */  ttykqfilter
768 };
769
770 static void stl_drvinit(void *unused)
771 {
772 }
773
774 SYSINIT(sidev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,stl_drvinit,NULL)
775
776 #endif
777
778 /*****************************************************************************/
779
780 /*
781  *      Probe for some type of EasyIO or EasyConnection 8/32 board at
782  *      the supplied address. All we do is check if we can find the
783  *      board ID for the board... (Note, PCI boards not checked here,
784  *      they are done in the stlpciprobe() routine).
785  */
786
787 static int stlprobe(struct isa_device *idp)
788 {
789         unsigned int    status;
790
791 #if STLDEBUG
792         printf("stlprobe(idp=%x): unit=%d iobase=%x\n", (int) idp,
793                 idp->id_unit, idp->id_iobase);
794 #endif
795
796         if (idp->id_unit > STL_MAXBRDS)
797                 return(0);
798
799         status = inb(idp->id_iobase + 1);
800         if ((status & ECH_IDBITMASK) == ECH_ID) {
801                 stl_brdprobed[idp->id_unit] = BRD_ECH;
802                 return(1);
803         }
804
805         status = inb(idp->id_iobase + 2);
806         switch (status & EIO_IDBITMASK) {
807         case EIO_8PORTRS:
808         case EIO_8PORTM:
809         case EIO_8PORTDI:
810         case EIO_4PORTRS:
811         case EIO_MK3:
812                 stl_brdprobed[idp->id_unit] = BRD_EASYIO;
813                 return(1);
814         default:
815                 break;
816         }
817         
818         return(0);
819 }
820
821 /*****************************************************************************/
822
823 /*
824  *      Find an available internal board number (unit number). The problem
825  *      is that the same unit numbers can be assigned to different boards
826  *      detected during the ISA and PCI initialization phases.
827  */
828
829 static int stl_findfreeunit()
830 {
831         int     i;
832
833         for (i = 0; (i < STL_MAXBRDS); i++)
834                 if (stl_brds[i] == (stlbrd_t *) NULL)
835                         break;
836         return((i >= STL_MAXBRDS) ? -1 : i);
837 }
838
839 /*****************************************************************************/
840
841 /*
842  *      Allocate resources for and initialize the specified board.
843  */
844
845 static int stlattach(struct isa_device *idp)
846 {
847         stlbrd_t        *brdp;
848         int             boardnr, portnr, minor_dev;
849
850 #if STLDEBUG
851         printf("stlattach(idp=%p): unit=%d iobase=%x\n", (void *) idp,
852                 idp->id_unit, idp->id_iobase);
853 #endif
854
855 /*      idp->id_ointr = stlintr; */
856
857         brdp = malloc(sizeof(stlbrd_t), M_TTYS, M_WAITOK | M_ZERO);
858
859         if ((brdp->brdnr = stl_findfreeunit()) < 0) {
860                 printf("STALLION: too many boards found, max=%d\n",
861                         STL_MAXBRDS);
862                 return(0);
863         }
864         if (brdp->brdnr >= stl_nrbrds)
865                 stl_nrbrds = brdp->brdnr + 1;
866
867         brdp->unitid = idp->id_unit;
868         brdp->brdtype = stl_brdprobed[idp->id_unit];
869         brdp->ioaddr1 = idp->id_iobase;
870         brdp->ioaddr2 = stl_ioshared;
871         brdp->irq = ffs(idp->id_irq) - 1;
872         brdp->irqtype = stl_irqshared;
873         stl_brdinit(brdp);
874
875         /* register devices for DEVFS */
876         boardnr = brdp->brdnr;
877         cdevsw_add(&stl_cdevsw, 31, boardnr);
878         make_dev(&stl_cdevsw, boardnr + 0x1000000, UID_ROOT, GID_WHEEL,
879                  0600, "staliomem%d", boardnr);
880
881         for (portnr = 0, minor_dev = boardnr * 0x100000;
882               portnr < 32; portnr++, minor_dev++) {
883                 /* hw ports */
884                 make_dev(&stl_cdevsw, minor_dev,
885                          UID_ROOT, GID_WHEEL, 0600,
886                          "ttyE%d", portnr + (boardnr * 64));
887                 make_dev(&stl_cdevsw, minor_dev + 32,
888                          UID_ROOT, GID_WHEEL, 0600,
889                          "ttyiE%d", portnr + (boardnr * 64));
890                 make_dev(&stl_cdevsw, minor_dev + 64,
891                          UID_ROOT, GID_WHEEL, 0600,
892                          "ttylE%d", portnr + (boardnr * 64));
893                 make_dev(&stl_cdevsw, minor_dev + 128,
894                          UID_ROOT, GID_WHEEL, 0600,
895                          "cue%d", portnr + (boardnr * 64));
896                 make_dev(&stl_cdevsw, minor_dev + 160,
897                          UID_ROOT, GID_WHEEL, 0600,
898                          "cuie%d", portnr + (boardnr * 64));
899                 make_dev(&stl_cdevsw, minor_dev + 192,
900                          UID_ROOT, GID_WHEEL, 0600,
901                          "cule%d", portnr + (boardnr * 64));
902
903                 /* sw ports */
904                 make_dev(&stl_cdevsw, minor_dev + 0x10000,
905                          UID_ROOT, GID_WHEEL, 0600,
906                          "ttyE%d", portnr + (boardnr * 64) + 32);
907                 make_dev(&stl_cdevsw, minor_dev + 32 + 0x10000,
908                          UID_ROOT, GID_WHEEL, 0600,
909                          "ttyiE%d", portnr + (boardnr * 64) + 32);
910                 make_dev(&stl_cdevsw, minor_dev + 64 + 0x10000,
911                          UID_ROOT, GID_WHEEL, 0600,
912                          "ttylE%d", portnr + (boardnr * 64) + 32);
913                 make_dev(&stl_cdevsw, minor_dev + 128 + 0x10000,
914                          UID_ROOT, GID_WHEEL, 0600,
915                          "cue%d", portnr + (boardnr * 64) + 32);
916                 make_dev(&stl_cdevsw, minor_dev + 160 + 0x10000,
917                          UID_ROOT, GID_WHEEL, 0600,
918                          "cuie%d", portnr + (boardnr * 64) + 32);
919                 make_dev(&stl_cdevsw, minor_dev + 192 + 0x10000,
920                          UID_ROOT, GID_WHEEL, 0600,
921                          "cule%d", portnr + (boardnr * 64) + 32);
922         }
923         boardnr = brdp->brdnr;
924         make_dev(&stl_cdevsw, boardnr + 0x1000000, UID_ROOT, GID_WHEEL,
925                  0600, "staliomem%d", boardnr);
926
927         for (portnr = 0, minor_dev = boardnr * 0x100000;
928               portnr < 32; portnr++, minor_dev++) {
929                 /* hw ports */
930                 make_dev(&stl_cdevsw, minor_dev,
931                          UID_ROOT, GID_WHEEL, 0600,
932                          "ttyE%d", portnr + (boardnr * 64));
933                 make_dev(&stl_cdevsw, minor_dev + 32,
934                          UID_ROOT, GID_WHEEL, 0600,
935                          "ttyiE%d", portnr + (boardnr * 64));
936                 make_dev(&stl_cdevsw, minor_dev + 64,
937                          UID_ROOT, GID_WHEEL, 0600,
938                          "ttylE%d", portnr + (boardnr * 64));
939                 make_dev(&stl_cdevsw, minor_dev + 128,
940                          UID_ROOT, GID_WHEEL, 0600,
941                          "cue%d", portnr + (boardnr * 64));
942                 make_dev(&stl_cdevsw, minor_dev + 160,
943                          UID_ROOT, GID_WHEEL, 0600,
944                          "cuie%d", portnr + (boardnr * 64));
945                 make_dev(&stl_cdevsw, minor_dev + 192,
946                          UID_ROOT, GID_WHEEL, 0600,
947                          "cule%d", portnr + (boardnr * 64));
948
949                 /* sw ports */
950                 make_dev(&stl_cdevsw, minor_dev + 0x10000,
951                          UID_ROOT, GID_WHEEL, 0600,
952                          "ttyE%d", portnr + (boardnr * 64) + 32);
953                 make_dev(&stl_cdevsw, minor_dev + 32 + 0x10000,
954                          UID_ROOT, GID_WHEEL, 0600,
955                          "ttyiE%d", portnr + (boardnr * 64) + 32);
956                 make_dev(&stl_cdevsw, minor_dev + 64 + 0x10000,
957                          UID_ROOT, GID_WHEEL, 0600,
958                          "ttylE%d", portnr + (boardnr * 64) + 32);
959                 make_dev(&stl_cdevsw, minor_dev + 128 + 0x10000,
960                          UID_ROOT, GID_WHEEL, 0600,
961                          "cue%d", portnr + (boardnr * 64) + 32);
962                 make_dev(&stl_cdevsw, minor_dev + 160 + 0x10000,
963                          UID_ROOT, GID_WHEEL, 0600,
964                          "cuie%d", portnr + (boardnr * 64) + 32);
965                 make_dev(&stl_cdevsw, minor_dev + 192 + 0x10000,
966                          UID_ROOT, GID_WHEEL, 0600,
967                          "cule%d", portnr + (boardnr * 64) + 32);
968         }
969
970         return(1);
971 }
972
973 /*****************************************************************************/
974
975 #if NPCI > 0
976
977 /*
978  *      Probe specifically for the PCI boards. We need to be a little
979  *      carefull here, since it looks sort like a Nat Semi IDE chip...
980  */
981
982 static const char *stlpciprobe(pcici_t tag, pcidi_t type)
983 {
984         unsigned long   class;
985         int             i, brdtype;
986
987 #if STLDEBUG
988         printf("stlpciprobe(tag=%x,type=%x)\n", (int) &tag, (int) type);
989 #endif
990
991         brdtype = 0;
992         for (i = 0; (i < stl_nrpcibrds); i++) {
993                 if (((type & 0xffff) == stl_pcibrds[i].vendid) &&
994                     (((type >> 16) & 0xffff) == stl_pcibrds[i].devid)) {
995                         brdtype = stl_pcibrds[i].brdtype;
996                         break;
997                 }
998         }
999
1000         if (brdtype == 0)
1001                 return((char *) NULL);
1002
1003         class = pci_conf_read(tag, PCI_CLASS_REG);
1004         if ((class & PCI_CLASS_MASK) == PCI_CLASS_MASS_STORAGE)
1005                 return((char *) NULL);
1006
1007         return(stl_brdnames[brdtype]);
1008 }
1009
1010 /*****************************************************************************/
1011
1012 /*
1013  *      Allocate resources for and initialize the specified PCI board.
1014  */
1015
1016 void stlpciattach(pcici_t tag, int unit)
1017 {
1018         stlbrd_t        *brdp;
1019         unsigned int    bar[4];
1020         unsigned int    id;
1021         int             i;
1022         int             boardnr, portnr, minor_dev;
1023
1024 #if STLDEBUG
1025         printf("stlpciattach(tag=%x,unit=%x)\n", (int) &tag, unit);
1026 #endif
1027
1028         brdp = malloc(sizeof(stlbrd_t), M_TTYS, M_WAITOK | M_ZERO);
1029
1030         if ((unit < 0) || (unit > STL_MAXBRDS)) {
1031                 printf("STALLION: bad PCI board unit number=%d\n", unit);
1032                 return;
1033         }
1034
1035 /*
1036  *      Allocate us a new driver unique unit number.
1037  */
1038         if ((brdp->brdnr = stl_findfreeunit()) < 0) {
1039                 printf("STALLION: too many boards found, max=%d\n",
1040                         STL_MAXBRDS);
1041                 return;
1042         }
1043         if (brdp->brdnr >= stl_nrbrds)
1044                 stl_nrbrds = brdp->brdnr + 1;
1045
1046 /*
1047  *      Determine what type of PCI board this is...
1048  */
1049         id = (unsigned int) pci_conf_read(tag, 0x0);
1050         for (i = 0; (i < stl_nrpcibrds); i++) {
1051                 if (((id & 0xffff) == stl_pcibrds[i].vendid) &&
1052                     (((id >> 16) & 0xffff) == stl_pcibrds[i].devid)) {
1053                         brdp->brdtype = stl_pcibrds[i].brdtype;
1054                         break;
1055                 }
1056         }
1057
1058         if (i >= stl_nrpcibrds) {
1059                 printf("STALLION: probed PCI board unknown type=%x\n", id);
1060                 return;
1061         }
1062
1063         for (i = 0; (i < 4); i++)
1064                 bar[i] = (unsigned int) pci_conf_read(tag, 0x10 + (i * 4)) &
1065                         0xfffc;
1066
1067         switch (brdp->brdtype) {
1068         case BRD_ECH64PCI:
1069                 brdp->ioaddr1 = bar[1];
1070                 brdp->ioaddr2 = bar[2];
1071                 break;
1072         case BRD_EASYIOPCI:
1073                 brdp->ioaddr1 = bar[2];
1074                 brdp->ioaddr2 = bar[1];
1075                 break;
1076         case BRD_ECHPCI:
1077                 brdp->ioaddr1 = bar[1];
1078                 brdp->ioaddr2 = bar[0];
1079                 break;
1080         default:
1081                 printf("STALLION: unknown PCI board type=%d\n", brdp->brdtype);
1082                 return;
1083                 break;
1084         }
1085
1086         brdp->unitid = brdp->brdnr; /* PCI units auto-assigned */
1087         brdp->irq = ((int) pci_conf_read(tag, 0x3c)) & 0xff;
1088         brdp->irqtype = 0;
1089         if (pci_map_int(tag, stlpciintr, (void *) NULL, &tty_imask) == 0) {
1090                 printf("STALLION: failed to map interrupt irq=%d for unit=%d\n",
1091                         brdp->irq, brdp->brdnr);
1092                 return;
1093         }
1094
1095         stl_brdinit(brdp);
1096
1097         /* register devices for DEVFS */
1098         boardnr = brdp->brdnr;
1099         make_dev(&stl_cdevsw, boardnr + 0x1000000, UID_ROOT, GID_WHEEL,
1100                  0600, "staliomem%d", boardnr);
1101
1102         for (portnr = 0, minor_dev = boardnr * 0x100000;
1103               portnr < 32; portnr++, minor_dev++) {
1104                 /* hw ports */
1105                 make_dev(&stl_cdevsw, minor_dev,
1106                          UID_ROOT, GID_WHEEL, 0600,
1107                          "ttyE%d", portnr + (boardnr * 64));
1108                 make_dev(&stl_cdevsw, minor_dev + 32,
1109                          UID_ROOT, GID_WHEEL, 0600,
1110                          "ttyiE%d", portnr + (boardnr * 64));
1111                 make_dev(&stl_cdevsw, minor_dev + 64,
1112                          UID_ROOT, GID_WHEEL, 0600,
1113                          "ttylE%d", portnr + (boardnr * 64));
1114                 make_dev(&stl_cdevsw, minor_dev + 128,
1115                          UID_ROOT, GID_WHEEL, 0600,
1116                          "cue%d", portnr + (boardnr * 64));
1117                 make_dev(&stl_cdevsw, minor_dev + 160,
1118                          UID_ROOT, GID_WHEEL, 0600,
1119                          "cuie%d", portnr + (boardnr * 64));
1120                 make_dev(&stl_cdevsw, minor_dev + 192,
1121                          UID_ROOT, GID_WHEEL, 0600,
1122                          "cule%d", portnr + (boardnr * 64));
1123
1124                 /* sw ports */
1125                 make_dev(&stl_cdevsw, minor_dev + 0x10000,
1126                          UID_ROOT, GID_WHEEL, 0600,
1127                          "ttyE%d", portnr + (boardnr * 64) + 32);
1128                 make_dev(&stl_cdevsw, minor_dev + 32 + 0x10000,
1129                          UID_ROOT, GID_WHEEL, 0600,
1130                          "ttyiE%d", portnr + (boardnr * 64) + 32);
1131                 make_dev(&stl_cdevsw, minor_dev + 64 + 0x10000,
1132                          UID_ROOT, GID_WHEEL, 0600,
1133                          "ttylE%d", portnr + (boardnr * 64) + 32);
1134                 make_dev(&stl_cdevsw, minor_dev + 128 + 0x10000,
1135                          UID_ROOT, GID_WHEEL, 0600,
1136                          "cue%d", portnr + (boardnr * 64) + 32);
1137                 make_dev(&stl_cdevsw, minor_dev + 160 + 0x10000,
1138                          UID_ROOT, GID_WHEEL, 0600,
1139                          "cuie%d", portnr + (boardnr * 64) + 32);
1140                 make_dev(&stl_cdevsw, minor_dev + 192 + 0x10000,
1141                          UID_ROOT, GID_WHEEL, 0600,
1142                          "cule%d", portnr + (boardnr * 64) + 32);
1143         }
1144 }
1145
1146 #endif
1147
1148 /*****************************************************************************/
1149
1150 STATIC int stlopen(dev_t dev, int flag, int mode, struct thread *td)
1151 {
1152         struct tty      *tp;
1153         stlport_t       *portp;
1154         int             error, callout, x;
1155
1156 #if STLDEBUG
1157         printf("stlopen(dev=%x,flag=%x,mode=%x,p=%x)\n", (int) dev, flag,
1158                 mode, (int) p);
1159 #endif
1160
1161 /*
1162  *      Firstly check if the supplied device number is a valid device.
1163  */
1164         if (minor(dev) & STL_MEMDEV)
1165                 return(0);
1166
1167         portp = stl_dev2port(dev);
1168         if (portp == (stlport_t *) NULL)
1169                 return(ENXIO);
1170         if (minor(dev) & STL_CTRLDEV)
1171                 return(0);
1172         tp = &portp->tty;
1173         dev->si_tty = tp;
1174         callout = minor(dev) & STL_CALLOUTDEV;
1175         error = 0;
1176
1177         x = spltty();
1178
1179 stlopen_restart:
1180 /*
1181  *      Wait here for the DTR drop timeout period to expire.
1182  */
1183         while (portp->state & ASY_DTRWAIT) {
1184                 error = tsleep(&portp->dtrwait, PCATCH, "stldtr", 0);
1185                 if (error)
1186                         goto stlopen_end;
1187         }
1188         
1189 /*
1190  *      We have a valid device, so now we check if it is already open.
1191  *      If not then initialize the port hardware and set up the tty
1192  *      struct as required.
1193  */
1194         if ((tp->t_state & TS_ISOPEN) == 0) {
1195                 tp->t_oproc = stl_start;
1196                 tp->t_stop = stl_stop;
1197                 tp->t_param = stl_param;
1198                 tp->t_dev = dev;
1199                 tp->t_termios = callout ? portp->initouttios :
1200                         portp->initintios;
1201                 stl_rawopen(portp);
1202                 ttsetwater(tp);
1203                 if ((portp->sigs & TIOCM_CD) || callout)
1204                         (*linesw[tp->t_line].l_modem)(tp, 1);
1205         } else {
1206                 if (callout) {
1207                         if (portp->callout == 0) {
1208                                 error = EBUSY;
1209                                 goto stlopen_end;
1210                         }
1211                 } else {
1212                         if (portp->callout != 0) {
1213                                 if (flag & O_NONBLOCK) {
1214                                         error = EBUSY;
1215                                         goto stlopen_end;
1216                                 }
1217                                 error = tsleep(&portp->callout,
1218                                             PCATCH, "stlcall", 0);
1219                                 if (error)
1220                                         goto stlopen_end;
1221                                 goto stlopen_restart;
1222                         }
1223                 }
1224                 if ((tp->t_state & TS_XCLUDE) && suser(td)) {
1225                         error = EBUSY;
1226                         goto stlopen_end;
1227                 }
1228         }
1229
1230 /*
1231  *      If this port is not the callout device and we do not have carrier
1232  *      then we need to sleep, waiting for it to be asserted.
1233  */
1234         if (((tp->t_state & TS_CARR_ON) == 0) && !callout &&
1235                         ((tp->t_cflag & CLOCAL) == 0) &&
1236                         ((flag & O_NONBLOCK) == 0)) {
1237                 portp->waitopens++;
1238                 error = tsleep(TSA_CARR_ON(tp), PCATCH, "stldcd", 0);
1239                 portp->waitopens--;
1240                 if (error)
1241                         goto stlopen_end;
1242                 goto stlopen_restart;
1243         }
1244
1245 /*
1246  *      Open the line discipline.
1247  */
1248         error = (*linesw[tp->t_line].l_open)(dev, tp);
1249         stl_ttyoptim(portp, &tp->t_termios);
1250         if ((tp->t_state & TS_ISOPEN) && callout)
1251                 portp->callout = 1;
1252
1253 /*
1254  *      If for any reason we get to here and the port is not actually
1255  *      open then close of the physical hardware - no point leaving it
1256  *      active when the open failed...
1257  */
1258 stlopen_end:
1259         splx(x);
1260         if (((tp->t_state & TS_ISOPEN) == 0) && (portp->waitopens == 0))
1261                 stl_rawclose(portp);
1262
1263         return(error);
1264 }
1265
1266 /*****************************************************************************/
1267
1268 STATIC int stlclose(dev_t dev, int flag, int mode, struct thread *td)
1269 {
1270         struct tty      *tp;
1271         stlport_t       *portp;
1272         int             x;
1273
1274 #if STLDEBUG
1275         printf("stlclose(dev=%s,flag=%x,mode=%x,p=%p)\n", devtoname(dev),
1276                 flag, mode, (void *) p);
1277 #endif
1278
1279         if (minor(dev) & STL_MEMDEV)
1280                 return(0);
1281         if (minor(dev) & STL_CTRLDEV)
1282                 return(0);
1283
1284         portp = stl_dev2port(dev);
1285         if (portp == (stlport_t *) NULL)
1286                 return(ENXIO);
1287         tp = &portp->tty;
1288
1289         x = spltty();
1290         (*linesw[tp->t_line].l_close)(tp, flag);
1291         stl_ttyoptim(portp, &tp->t_termios);
1292         stl_rawclose(portp);
1293         ttyclose(tp);
1294         splx(x);
1295         return(0);
1296 }
1297
1298 /*****************************************************************************/
1299
1300 #if VFREEBSD >= 220
1301
1302 STATIC void stl_stop(struct tty *tp, int rw)
1303 {
1304 #if STLDEBUG
1305         printf("stl_stop(tp=%x,rw=%x)\n", (int) tp, rw);
1306 #endif
1307
1308         stl_flush((stlport_t *) tp, rw);
1309 }
1310
1311 #else
1312
1313 STATIC int stlstop(struct tty *tp, int rw)
1314 {
1315 #if STLDEBUG
1316         printf("stlstop(tp=%x,rw=%x)\n", (int) tp, rw);
1317 #endif
1318
1319         stl_flush((stlport_t *) tp, rw);
1320         return(0);
1321 }
1322
1323 #endif
1324
1325 /*****************************************************************************/
1326
1327 STATIC int stlioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag,
1328                     struct thread *td)
1329 {
1330         struct termios  *newtios, *localtios;
1331         struct tty      *tp;
1332         stlport_t       *portp;
1333         int             error, i, x;
1334
1335 #if STLDEBUG
1336         printf("stlioctl(dev=%s,cmd=%lx,data=%p,flag=%x,p=%p)\n",
1337                 devtoname(dev), cmd, (void *) data, flag, (void *) p);
1338 #endif
1339
1340         if (minor(dev) & STL_MEMDEV)
1341                 return(stl_memioctl(dev, cmd, data, flag, td));
1342
1343         portp = stl_dev2port(dev);
1344         if (portp == (stlport_t *) NULL)
1345                 return(ENODEV);
1346         tp = &portp->tty;
1347         error = 0;
1348         
1349 /*
1350  *      First up handle ioctls on the control devices.
1351  */
1352         if (minor(dev) & STL_CTRLDEV) {
1353                 if ((minor(dev) & STL_CTRLDEV) == STL_CTRLINIT)
1354                         localtios = (minor(dev) & STL_CALLOUTDEV) ?
1355                                 &portp->initouttios : &portp->initintios;
1356                 else if ((minor(dev) & STL_CTRLDEV) == STL_CTRLLOCK)
1357                         localtios = (minor(dev) & STL_CALLOUTDEV) ?
1358                                 &portp->lockouttios : &portp->lockintios;
1359                 else
1360                         return(ENODEV);
1361
1362                 switch (cmd) {
1363                 case TIOCSETA:
1364                         if ((error = suser(td)) == 0)
1365                                 *localtios = *((struct termios *) data);
1366                         break;
1367                 case TIOCGETA:
1368                         *((struct termios *) data) = *localtios;
1369                         break;
1370                 case TIOCGETD:
1371                         *((int *) data) = TTYDISC;
1372                         break;
1373                 case TIOCGWINSZ:
1374                         bzero(data, sizeof(struct winsize));
1375                         break;
1376                 default:
1377                         error = ENOTTY;
1378                         break;
1379                 }
1380                 return(error);
1381         }
1382
1383 /*
1384  *      Deal with 4.3 compatibility issues if we have too...
1385  */
1386 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1387         if (1) {
1388                 struct termios  tios;
1389                 unsigned long   oldcmd;
1390
1391                 tios = tp->t_termios;
1392                 oldcmd = cmd;
1393                 if ((error = ttsetcompat(tp, &cmd, data, &tios)))
1394                         return(error);
1395                 if (cmd != oldcmd)
1396                         data = (caddr_t) &tios;
1397         }
1398 #endif
1399
1400 /*
1401  *      Carry out some pre-cmd processing work first...
1402  *      Hmmm, not so sure we want this, disable for now...
1403  */
1404         if ((cmd == TIOCSETA) || (cmd == TIOCSETAW) || (cmd == TIOCSETAF)) {
1405                 newtios = (struct termios *) data;
1406                 localtios = (minor(dev) & STL_CALLOUTDEV) ? 
1407                         &portp->lockouttios : &portp->lockintios;
1408
1409                 newtios->c_iflag = (tp->t_iflag & localtios->c_iflag) |
1410                         (newtios->c_iflag & ~localtios->c_iflag);
1411                 newtios->c_oflag = (tp->t_oflag & localtios->c_oflag) |
1412                         (newtios->c_oflag & ~localtios->c_oflag);
1413                 newtios->c_cflag = (tp->t_cflag & localtios->c_cflag) |
1414                         (newtios->c_cflag & ~localtios->c_cflag);
1415                 newtios->c_lflag = (tp->t_lflag & localtios->c_lflag) |
1416                         (newtios->c_lflag & ~localtios->c_lflag);
1417                 for (i = 0; (i < NCCS); i++) {
1418                         if (localtios->c_cc[i] != 0)
1419                                 newtios->c_cc[i] = tp->t_cc[i];
1420                 }
1421                 if (localtios->c_ispeed != 0)
1422                         newtios->c_ispeed = tp->t_ispeed;
1423                 if (localtios->c_ospeed != 0)
1424                         newtios->c_ospeed = tp->t_ospeed;
1425         }
1426
1427 /*
1428  *      Call the line discipline and the common command processing to
1429  *      process this command (if they can).
1430  */
1431         error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, td);
1432         if (error != ENOIOCTL)
1433                 return(error);
1434
1435         x = spltty();
1436         error = ttioctl(tp, cmd, data, flag);
1437         stl_ttyoptim(portp, &tp->t_termios);
1438         if (error != ENOIOCTL) {
1439                 splx(x);
1440                 return(error);
1441         }
1442
1443         error = 0;
1444
1445 /*
1446  *      Process local commands here. These are all commands that only we
1447  *      can take care of (they all rely on actually doing something special
1448  *      to the actual hardware).
1449  */
1450         switch (cmd) {
1451         case TIOCSBRK:
1452                 stl_sendbreak(portp, -1);
1453                 break;
1454         case TIOCCBRK:
1455                 stl_sendbreak(portp, -2);
1456                 break;
1457         case TIOCSDTR:
1458                 stl_setsignals(portp, 1, -1);
1459                 break;
1460         case TIOCCDTR:
1461                 stl_setsignals(portp, 0, -1);
1462                 break;
1463         case TIOCMSET:
1464                 i = *((int *) data);
1465                 stl_setsignals(portp, ((i & TIOCM_DTR) ? 1 : 0),
1466                         ((i & TIOCM_RTS) ? 1 : 0));
1467                 break;
1468         case TIOCMBIS:
1469                 i = *((int *) data);
1470                 stl_setsignals(portp, ((i & TIOCM_DTR) ? 1 : -1),
1471                         ((i & TIOCM_RTS) ? 1 : -1));
1472                 break;
1473         case TIOCMBIC:
1474                 i = *((int *) data);
1475                 stl_setsignals(portp, ((i & TIOCM_DTR) ? 0 : -1),
1476                         ((i & TIOCM_RTS) ? 0 : -1));
1477                 break;
1478         case TIOCMGET:
1479                 *((int *) data) = (stl_getsignals(portp) | TIOCM_LE);
1480                 break;
1481         case TIOCMSDTRWAIT:
1482                 if ((error = suser(td)) == 0)
1483                         portp->dtrwait = *((int *) data) * hz / 100;
1484                 break;
1485         case TIOCMGDTRWAIT:
1486                 *((int *) data) = portp->dtrwait * 100 / hz;
1487                 break;
1488         case TIOCTIMESTAMP:
1489                 portp->dotimestamp = 1;
1490                 *((struct timeval *) data) = portp->timestamp;
1491                 break;
1492         default:
1493                 error = ENOTTY;
1494                 break;
1495         }
1496         splx(x);
1497
1498         return(error);
1499 }
1500 /*****************************************************************************/
1501
1502 /*
1503  *      Convert the specified minor device number into a port struct
1504  *      pointer. Return NULL if the device number is not a valid port.
1505  */
1506
1507 STATIC stlport_t *stl_dev2port(dev_t dev)
1508 {
1509         stlbrd_t        *brdp;
1510
1511         brdp = stl_brds[MKDEV2BRD(dev)];
1512         if (brdp == (stlbrd_t *) NULL)
1513                 return((stlport_t *) NULL);
1514         return(brdp->ports[MKDEV2PORT(dev)]);
1515 }
1516
1517 /*****************************************************************************/
1518
1519 /*
1520  *      Initialize the port hardware. This involves enabling the transmitter
1521  *      and receiver, setting the port configuration, and setting the initial
1522  *      signal state.
1523  */
1524
1525 static int stl_rawopen(stlport_t *portp)
1526 {
1527 #if STLDEBUG
1528         printf("stl_rawopen(portp=%p): brdnr=%d panelnr=%d portnr=%d\n",
1529                 (void *) portp, portp->brdnr, portp->panelnr, portp->portnr);
1530 #endif
1531
1532         stl_setport(portp, &portp->tty.t_termios);
1533         portp->sigs = stl_getsignals(portp);
1534         stl_setsignals(portp, 1, 1);
1535         stl_enablerxtx(portp, 1, 1);
1536         stl_startrxtx(portp, 1, 0);
1537         return(0);
1538 }
1539
1540 /*****************************************************************************/
1541
1542 /*
1543  *      Shutdown the hardware of a port. Disable its transmitter and
1544  *      receiver, and maybe drop signals if appropriate.
1545  */
1546
1547 static int stl_rawclose(stlport_t *portp)
1548 {
1549         struct tty      *tp;
1550
1551 #if STLDEBUG
1552         printf("stl_rawclose(portp=%p): brdnr=%d panelnr=%d portnr=%d\n",
1553                 (void *) portp, portp->brdnr, portp->panelnr, portp->portnr);
1554 #endif
1555
1556         tp = &portp->tty;
1557         stl_disableintrs(portp);
1558         stl_enablerxtx(portp, 0, 0);
1559         stl_flush(portp, (FWRITE | FREAD));
1560         if (tp->t_cflag & HUPCL) {
1561                 stl_setsignals(portp, 0, 0);
1562                 if (portp->dtrwait != 0) {
1563                         portp->state |= ASY_DTRWAIT;
1564                         callout_reset(&portp->dtr_ch, portp->dtrwait,
1565                                         stl_dtrwakeup, portp);
1566                 }
1567         }
1568         portp->callout = 0;
1569         portp->brklen = 0;
1570         portp->state &= ~(ASY_ACTIVE | ASY_RTSFLOW);
1571         wakeup(&portp->callout);
1572         wakeup(TSA_CARR_ON(tp));
1573         return(0);
1574 }
1575
1576 /*****************************************************************************/
1577
1578 /*
1579  *      Clear the DTR waiting flag, and wake up any sleepers waiting for
1580  *      DTR wait period to finish.
1581  */
1582
1583 static void stl_dtrwakeup(void *arg)
1584 {
1585         stlport_t       *portp;
1586
1587         portp = (stlport_t *) arg;
1588         portp->state &= ~ASY_DTRWAIT;
1589         wakeup(&portp->dtrwait);
1590 }
1591
1592 /*****************************************************************************/
1593
1594 /*
1595  *      Start (or continue) the transfer of TX data on this port. If the
1596  *      port is not currently busy then load up the interrupt ring queue
1597  *      buffer and kick of the transmitter. If the port is running low on
1598  *      TX data then refill the ring queue. This routine is also used to
1599  *      activate input flow control!
1600  */
1601
1602 static void stl_start(struct tty *tp)
1603 {
1604         stlport_t       *portp;
1605         unsigned int    len, stlen;
1606         char            *head, *tail;
1607         int             count, x;
1608
1609         portp = (stlport_t *) tp;
1610
1611 #if STLDEBUG
1612         printf("stl_start(tp=%x): brdnr=%d portnr=%d\n", (int) tp, 
1613                 portp->brdnr, portp->portnr);
1614 #endif
1615
1616         x = spltty();
1617
1618 /*
1619  *      Check if the ports input has been blocked, and take appropriate action.
1620  *      Not very often do we really need to do anything, so make it quick.
1621  */
1622         if (tp->t_state & TS_TBLOCK) {
1623                 if ((portp->state & ASY_RTSFLOWMODE) &&
1624                     ((portp->state & ASY_RTSFLOW) == 0))
1625                         stl_flowcontrol(portp, 0, -1);
1626         } else {
1627                 if (portp->state & ASY_RTSFLOW)
1628                         stl_flowcontrol(portp, 1, -1);
1629         }
1630
1631 #if VFREEBSD == 205
1632 /*
1633  *      Check if the output cooked clist buffers are near empty, wake up
1634  *      the line discipline to fill it up.
1635  */
1636         if (tp->t_outq.c_cc <= tp->t_lowat) {
1637                 if (tp->t_state & TS_ASLEEP) {
1638                         tp->t_state &= ~TS_ASLEEP;
1639                         wakeup(&tp->t_outq);
1640                 }
1641                 selwakeup(&tp->t_wsel);
1642         }
1643 #endif
1644
1645         if (tp->t_state & (TS_TIMEOUT | TS_TTSTOP)) {
1646                 splx(x);
1647                 return;
1648         }
1649
1650 /*
1651  *      Copy data from the clists into the interrupt ring queue. This will
1652  *      require at most 2 copys... What we do is calculate how many chars
1653  *      can fit into the ring queue, and how many can fit in 1 copy. If after
1654  *      the first copy there is still more room then do the second copy. 
1655  *      The beauty of this type of ring queue is that we do not need to
1656  *      spl protect our-selves, since we only ever update the head pointer,
1657  *      and the interrupt routine only ever updates the tail pointer.
1658  */
1659         if (tp->t_outq.c_cc != 0) {
1660                 head = portp->tx.head;
1661                 tail = portp->tx.tail;
1662                 if (head >= tail) {
1663                         len = STL_TXBUFSIZE - (head - tail) - 1;
1664                         stlen = portp->tx.endbuf - head;
1665                 } else {
1666                         len = tail - head - 1;
1667                         stlen = len;
1668                 }
1669
1670                 if (len > 0) {
1671                         stlen = MIN(len, stlen);
1672                         count = q_to_b(&tp->t_outq, head, stlen);
1673                         len -= count;
1674                         head += count;
1675                         if (head >= portp->tx.endbuf) {
1676                                 head = portp->tx.buf;
1677                                 if (len > 0) {
1678                                         stlen = q_to_b(&tp->t_outq, head, len);
1679                                         head += stlen;
1680                                         count += stlen;
1681                                 }
1682                         }
1683                         portp->tx.head = head;
1684                         if (count > 0)
1685                                 stl_startrxtx(portp, -1, 1);
1686                 }
1687
1688 /*
1689  *              If we sent something, make sure we are called again.
1690  */
1691                 tp->t_state |= TS_BUSY;
1692         }
1693
1694 #if VFREEBSD != 205
1695 /*
1696  *      Do any writer wakeups.
1697  */
1698         ttwwakeup(tp);
1699 #endif
1700
1701         splx(x);
1702 }
1703
1704 /*****************************************************************************/
1705
1706 static void stl_flush(stlport_t *portp, int flag)
1707 {
1708         char    *head, *tail;
1709         int     len, x;
1710
1711 #if STLDEBUG
1712         printf("stl_flush(portp=%x,flag=%x)\n", (int) portp, flag);
1713 #endif
1714
1715         if (portp == (stlport_t *) NULL)
1716                 return;
1717
1718         x = spltty();
1719
1720         if (flag & FWRITE) {
1721                 stl_uartflush(portp, FWRITE);
1722                 portp->tx.tail = portp->tx.head;
1723         }
1724
1725 /*
1726  *      The only thing to watch out for when flushing the read side is
1727  *      the RX status buffer. The interrupt code relys on the status
1728  *      bytes as being zeroed all the time (it does not bother setting
1729  *      a good char status to 0, it expects that it already will be).
1730  *      We also need to un-flow the RX channel if flow control was
1731  *      active.
1732  */
1733         if (flag & FREAD) {
1734                 head = portp->rx.head;
1735                 tail = portp->rx.tail;
1736                 if (head != tail) {
1737                         if (head >= tail) {
1738                                 len = head - tail;
1739                         } else {
1740                                 len = portp->rx.endbuf - tail;
1741                                 bzero(portp->rxstatus.buf,
1742                                         (head - portp->rx.buf));
1743                         }
1744                         bzero((tail + STL_RXBUFSIZE), len);
1745                         portp->rx.tail = head;
1746                 }
1747
1748                 if ((portp->state & ASY_RTSFLOW) &&
1749                                 ((portp->tty.t_state & TS_TBLOCK) == 0))
1750                         stl_flowcontrol(portp, 1, -1);
1751         }
1752
1753         splx(x);
1754 }
1755
1756 /*****************************************************************************/
1757
1758 /*
1759  *      Interrupt handler for host based boards. Interrupts for all boards
1760  *      are vectored through here.
1761  */
1762
1763 void stlintr(int unit)
1764 {
1765         stlbrd_t        *brdp;
1766         int             i;
1767
1768 #if STLDEBUG
1769         printf("stlintr(unit=%d)\n", unit);
1770 #endif
1771
1772         for (i = 0; (i < stl_nrbrds); i++) {
1773                 if ((brdp = stl_brds[i]) == (stlbrd_t *) NULL)
1774                         continue;
1775                 if (brdp->state == 0)
1776                         continue;
1777                 (* brdp->isr)(brdp);
1778         }
1779 }
1780
1781 /*****************************************************************************/
1782
1783 #if NPCI > 0
1784
1785 static void stlpciintr(void *arg)
1786 {
1787         stlintr(0);
1788 }
1789
1790 #endif
1791
1792 /*****************************************************************************/
1793
1794 /*
1795  *      Interrupt service routine for EasyIO boards.
1796  */
1797
1798 static void stl_eiointr(stlbrd_t *brdp)
1799 {
1800         stlpanel_t      *panelp;
1801         int             iobase;
1802
1803 #if STLDEBUG
1804         printf("stl_eiointr(brdp=%p)\n", brdp);
1805 #endif
1806
1807         panelp = (stlpanel_t *) brdp->panels[0];
1808         iobase = panelp->iobase;
1809         while (inb(brdp->iostatus) & EIO_INTRPEND)
1810                 (* panelp->isr)(panelp, iobase);
1811 }
1812
1813 /*
1814  *      Interrupt service routine for ECH-AT board types.
1815  */
1816
1817 static void stl_echatintr(stlbrd_t *brdp)
1818 {
1819         stlpanel_t      *panelp;
1820         unsigned int    ioaddr;
1821         int             bnknr;
1822
1823         outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDENABLE));
1824
1825         while (inb(brdp->iostatus) & ECH_INTRPEND) {
1826                 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1827                         ioaddr = brdp->bnkstataddr[bnknr];
1828                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1829                                 panelp = brdp->bnk2panel[bnknr];
1830                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1831                         }
1832                 }
1833         }
1834
1835         outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDDISABLE));
1836 }
1837
1838 /*****************************************************************************/
1839
1840 /*
1841  *      Interrupt service routine for ECH-MCA board types.
1842  */
1843
1844 static void stl_echmcaintr(stlbrd_t *brdp)
1845 {
1846         stlpanel_t      *panelp;
1847         unsigned int    ioaddr;
1848         int             bnknr;
1849
1850         while (inb(brdp->iostatus) & ECH_INTRPEND) {
1851                 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1852                         ioaddr = brdp->bnkstataddr[bnknr];
1853                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1854                                 panelp = brdp->bnk2panel[bnknr];
1855                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1856                         }
1857                 }
1858         }
1859 }
1860
1861 /*****************************************************************************/
1862
1863 /*
1864  *      Interrupt service routine for ECH-PCI board types.
1865  */
1866
1867 static void stl_echpciintr(stlbrd_t *brdp)
1868 {
1869         stlpanel_t      *panelp;
1870         unsigned int    ioaddr;
1871         int             bnknr, recheck;
1872
1873 #if STLDEBUG
1874         printf("stl_echpciintr(brdp=%x)\n", (int) brdp);
1875 #endif
1876
1877         for (;;) {
1878                 recheck = 0;
1879                 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1880                         outb(brdp->ioctrl, brdp->bnkpageaddr[bnknr]);
1881                         ioaddr = brdp->bnkstataddr[bnknr];
1882                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1883                                 panelp = brdp->bnk2panel[bnknr];
1884                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1885                                 recheck++;
1886                         }
1887                 }
1888                 if (! recheck)
1889                         break;
1890         }
1891 }
1892
1893 /*****************************************************************************/
1894
1895 /*
1896  *      Interrupt service routine for EC8/64-PCI board types.
1897  */
1898
1899 static void stl_echpci64intr(stlbrd_t *brdp)
1900 {
1901         stlpanel_t      *panelp;
1902         unsigned int    ioaddr;
1903         int             bnknr;
1904
1905 #if STLDEBUG
1906         printf("stl_echpci64intr(brdp=%p)\n", brdp);
1907 #endif
1908
1909         while (inb(brdp->ioctrl) & 0x1) {
1910                 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1911                         ioaddr = brdp->bnkstataddr[bnknr];
1912 #if STLDEBUG
1913         printf("    --> ioaddr=%x status=%x(%x)\n", ioaddr, inb(ioaddr) & ECH_PNLINTRPEND, inb(ioaddr));
1914 #endif
1915                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1916                                 panelp = brdp->bnk2panel[bnknr];
1917                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1918                         }
1919                 }
1920         }
1921 }
1922
1923 /*****************************************************************************/
1924
1925 /*
1926  *      If we haven't scheduled a timeout then do it, some port needs high
1927  *      level processing.
1928  */
1929
1930 static void stl_dotimeout()
1931 {
1932 #if STLDEBUG
1933         printf("stl_dotimeout()\n");
1934 #endif
1935         if (stl_doingtimeout == 0) {
1936                 if ((stl_poll_ch.c_flags & CALLOUT_DID_INIT) == 0)
1937                         callout_init(&stl_poll_ch);
1938                 callout_reset(&stl_poll_ch, 1, stl_poll, NULL);
1939                 stl_doingtimeout++;
1940         }
1941 }
1942
1943 /*****************************************************************************/
1944
1945 /*
1946  *      Service "software" level processing. Too slow or painfull to be done
1947  *      at real hardware interrupt time. This way we might also be able to
1948  *      do some service on other waiting ports as well...
1949  */
1950
1951 static void stl_poll(void *arg)
1952 {
1953         stlbrd_t        *brdp;
1954         stlport_t       *portp;
1955         struct tty      *tp;
1956         int             brdnr, portnr, rearm, x;
1957
1958 #if STLDEBUG
1959         printf("stl_poll()\n");
1960 #endif
1961
1962         stl_doingtimeout = 0;
1963         rearm = 0;
1964
1965         x = spltty();
1966         for (brdnr = 0; (brdnr < stl_nrbrds); brdnr++) {
1967                 if ((brdp = stl_brds[brdnr]) == (stlbrd_t *) NULL)
1968                         continue;
1969                 for (portnr = 0; (portnr < brdp->nrports); portnr++) {
1970                         if ((portp = brdp->ports[portnr]) == (stlport_t *) NULL)
1971                                 continue;
1972                         if ((portp->state & ASY_ACTIVE) == 0)
1973                                 continue;
1974                         tp = &portp->tty;
1975
1976                         if (portp->state & ASY_RXDATA)
1977                                 stl_rxprocess(portp);
1978                         if (portp->state & ASY_DCDCHANGE) {
1979                                 portp->state &= ~ASY_DCDCHANGE;
1980                                 portp->sigs = stl_getsignals(portp);
1981                                 (*linesw[tp->t_line].l_modem)(tp,
1982                                         (portp->sigs & TIOCM_CD));
1983                         }
1984                         if (portp->state & ASY_TXEMPTY) {
1985                                 if (stl_datastate(portp) == 0) {
1986                                         portp->state &= ~ASY_TXEMPTY;
1987                                         tp->t_state &= ~TS_BUSY;
1988                                         (*linesw[tp->t_line].l_start)(tp);
1989                                 }
1990                         }
1991                         if (portp->state & ASY_TXLOW) {
1992                                 portp->state &= ~ASY_TXLOW;
1993                                 (*linesw[tp->t_line].l_start)(tp);
1994                         }
1995
1996                         if (portp->state & ASY_ACTIVE)
1997                                 rearm++;
1998                 }
1999         }
2000         splx(x);
2001
2002         if (rearm)
2003                 stl_dotimeout();
2004 }
2005
2006 /*****************************************************************************/
2007
2008 /*
2009  *      Process the RX data that has been buffered up in the RX ring queue.
2010  */
2011
2012 static void stl_rxprocess(stlport_t *portp)
2013 {
2014         struct tty      *tp;
2015         unsigned int    len, stlen, lostlen;
2016         char            *head, *tail;
2017         char            status;
2018         int             ch;
2019
2020 #if STLDEBUG
2021         printf("stl_rxprocess(portp=%x): brdnr=%d portnr=%d\n", (int) portp, 
2022                 portp->brdnr, portp->portnr);
2023 #endif
2024
2025         tp = &portp->tty;
2026         portp->state &= ~ASY_RXDATA;
2027
2028         if ((tp->t_state & TS_ISOPEN) == 0) {
2029                 stl_flush(portp, FREAD);
2030                 return;
2031         }
2032
2033 /*
2034  *      Calculate the amount of data in the RX ring queue. Also calculate
2035  *      the largest single copy size...
2036  */
2037         head = portp->rx.head;
2038         tail = portp->rx.tail;
2039         if (head >= tail) {
2040                 len = head - tail;
2041                 stlen = len;
2042         } else {
2043                 len = STL_RXBUFSIZE - (tail - head);
2044                 stlen = portp->rx.endbuf - tail;
2045         }
2046
2047         if (tp->t_state & TS_CAN_BYPASS_L_RINT) {
2048                 if (len > 0) {
2049                         if (((tp->t_rawq.c_cc + len) >= TTYHOG) &&
2050                                         ((portp->state & ASY_RTSFLOWMODE) ||
2051                                         (tp->t_iflag & IXOFF)) &&
2052                                         ((tp->t_state & TS_TBLOCK) == 0)) {
2053                                 ch = TTYHOG - tp->t_rawq.c_cc - 1;
2054                                 len = (ch > 0) ? ch : 0;
2055                                 stlen = MIN(stlen, len);
2056                                 ttyblock(tp);
2057                         }
2058                         lostlen = b_to_q(tail, stlen, &tp->t_rawq);
2059                         tail += stlen;
2060                         len -= stlen;
2061                         if (tail >= portp->rx.endbuf) {
2062                                 tail = portp->rx.buf;
2063                                 lostlen += b_to_q(tail, len, &tp->t_rawq);
2064                                 tail += len;
2065                         }
2066                         portp->stats.rxlost += lostlen;
2067                         ttwakeup(tp);
2068                         portp->rx.tail = tail;
2069                 }
2070         } else {
2071                 while (portp->rx.tail != head) {
2072                         ch = (unsigned char) *(portp->rx.tail);
2073                         status = *(portp->rx.tail + STL_RXBUFSIZE);
2074                         if (status) {
2075                                 *(portp->rx.tail + STL_RXBUFSIZE) = 0;
2076                                 if (status & ST_BREAK)
2077                                         ch |= TTY_BI;
2078                                 if (status & ST_FRAMING)
2079                                         ch |= TTY_FE;
2080                                 if (status & ST_PARITY)
2081                                         ch |= TTY_PE;
2082                                 if (status & ST_OVERRUN)
2083                                         ch |= TTY_OE;
2084                         }
2085                         (*linesw[tp->t_line].l_rint)(ch, tp);
2086                         if (portp->rx.tail == head)
2087                                 break;
2088
2089                         if (++(portp->rx.tail) >= portp->rx.endbuf)
2090                                 portp->rx.tail = portp->rx.buf;
2091                 }
2092         }
2093
2094         if (head != portp->rx.tail)
2095                 portp->state |= ASY_RXDATA;
2096
2097 /*
2098  *      If we were flow controled then maybe the buffer is low enough that
2099  *      we can re-activate it.
2100  */
2101         if ((portp->state & ASY_RTSFLOW) && ((tp->t_state & TS_TBLOCK) == 0))
2102                 stl_flowcontrol(portp, 1, -1);
2103 }
2104
2105 /*****************************************************************************/
2106
2107 static int stl_param(struct tty *tp, struct termios *tiosp)
2108 {
2109         stlport_t       *portp;
2110
2111         portp = (stlport_t *) tp;
2112         if (portp == (stlport_t *) NULL)
2113                 return(ENODEV);
2114
2115         return(stl_setport(portp, tiosp));
2116 }
2117
2118 /*****************************************************************************/
2119
2120 /*
2121  *      Action the flow control as required. The hw and sw args inform the
2122  *      routine what flow control methods it should try.
2123  */
2124
2125 static void stl_flowcontrol(stlport_t *portp, int hw, int sw)
2126 {
2127         unsigned char   *head, *tail;
2128         int             len, hwflow;
2129
2130 #if STLDEBUG
2131         printf("stl_flowcontrol(portp=%x,hw=%d,sw=%d)\n", (int) portp, hw, sw);
2132 #endif
2133
2134         hwflow = -1;
2135
2136         if (portp->state & ASY_RTSFLOWMODE) {
2137                 if (hw == 0) {
2138                         if ((portp->state & ASY_RTSFLOW) == 0)
2139                                 hwflow = 0;
2140                 } else if (hw > 0) {
2141                         if (portp->state & ASY_RTSFLOW) {
2142                                 head = portp->rx.head;
2143                                 tail = portp->rx.tail;
2144                                 len = (head >= tail) ? (head - tail) :
2145                                         (STL_RXBUFSIZE - (tail - head));
2146                                 if (len < STL_RXBUFHIGH)
2147                                         hwflow = 1;
2148                         }
2149                 }
2150         }
2151
2152 /*
2153  *      We have worked out what to do, if anything. So now apply it to the
2154  *      UART port.
2155  */
2156         stl_sendflow(portp, hwflow, sw);
2157 }
2158
2159 /*****************************************************************************/
2160
2161 /*
2162  *      Enable l_rint processing bypass mode if tty modes allow it.
2163  */
2164
2165 static void stl_ttyoptim(stlport_t *portp, struct termios *tiosp)
2166 {
2167         struct tty      *tp;
2168
2169         tp = &portp->tty;
2170         if (((tiosp->c_iflag &
2171               (ICRNL | IGNCR | IMAXBEL | INLCR | ISTRIP)) == 0) &&
2172             (((tiosp->c_iflag & BRKINT) == 0) || (tiosp->c_iflag & IGNBRK)) &&
2173             (((tiosp->c_iflag & PARMRK) == 0) ||
2174                 ((tiosp->c_iflag & (IGNPAR | IGNBRK)) == (IGNPAR | IGNBRK))) &&
2175             ((tiosp->c_lflag & (ECHO | ICANON | IEXTEN | ISIG | PENDIN)) ==0) &&
2176             (linesw[tp->t_line].l_rint == ttyinput))
2177                 tp->t_state |= TS_CAN_BYPASS_L_RINT;
2178         else
2179                 tp->t_state &= ~TS_CAN_BYPASS_L_RINT;
2180         portp->hotchar = linesw[tp->t_line].l_hotchar;
2181 }
2182
2183 /*****************************************************************************/
2184
2185 /*
2186  *      Try and find and initialize all the ports on a panel. We don't care
2187  *      what sort of board these ports are on - since the port io registers
2188  *      are almost identical when dealing with ports.
2189  */
2190
2191 static int stl_initports(stlbrd_t *brdp, stlpanel_t *panelp)
2192 {
2193         stlport_t       *portp;
2194         unsigned int    chipmask;
2195         int             i, j;
2196
2197 #if STLDEBUG
2198         printf("stl_initports(panelp=%x)\n", (int) panelp);
2199 #endif
2200
2201         chipmask = stl_panelinit(brdp, panelp);
2202
2203 /*
2204  *      All UART's are initialized if found. Now go through and setup
2205  *      each ports data structures. Also initialize each individual
2206  *      UART port.
2207  */
2208         for (i = 0; (i < panelp->nrports); i++) {
2209                 portp = malloc(sizeof(stlport_t), M_TTYS, M_WAITOK | M_ZERO);
2210
2211                 portp->portnr = i;
2212                 portp->brdnr = panelp->brdnr;
2213                 portp->panelnr = panelp->panelnr;
2214                 portp->uartp = panelp->uartp;
2215                 portp->clk = brdp->clk;
2216                 panelp->ports[i] = portp;
2217
2218                 j = STL_TXBUFSIZE + (2 * STL_RXBUFSIZE);
2219                 portp->tx.buf = malloc(j, M_TTYS, M_WAITOK);
2220                 portp->tx.endbuf = portp->tx.buf + STL_TXBUFSIZE;
2221                 portp->tx.head = portp->tx.buf;
2222                 portp->tx.tail = portp->tx.buf;
2223                 portp->rx.buf = portp->tx.buf + STL_TXBUFSIZE;
2224                 portp->rx.endbuf = portp->rx.buf + STL_RXBUFSIZE;
2225                 portp->rx.head = portp->rx.buf;
2226                 portp->rx.tail = portp->rx.buf;
2227                 portp->rxstatus.buf = portp->rx.buf + STL_RXBUFSIZE;
2228                 portp->rxstatus.endbuf = portp->rxstatus.buf + STL_RXBUFSIZE;
2229                 portp->rxstatus.head = portp->rxstatus.buf;
2230                 portp->rxstatus.tail = portp->rxstatus.buf;
2231                 bzero(portp->rxstatus.head, STL_RXBUFSIZE);
2232
2233                 portp->initintios.c_ispeed = STL_DEFSPEED;
2234                 portp->initintios.c_ospeed = STL_DEFSPEED;
2235                 portp->initintios.c_cflag = STL_DEFCFLAG;
2236                 portp->initintios.c_iflag = 0;
2237                 portp->initintios.c_oflag = 0;
2238                 portp->initintios.c_lflag = 0;
2239                 bcopy(&ttydefchars[0], &portp->initintios.c_cc[0],
2240                         sizeof(portp->initintios.c_cc));
2241                 portp->initouttios = portp->initintios;
2242                 portp->dtrwait = 3 * hz;
2243                 callout_init(&portp->dtr_ch);
2244
2245                 stl_portinit(brdp, panelp, portp);
2246         }
2247
2248         return(0);
2249 }
2250
2251 /*****************************************************************************/
2252
2253 /*
2254  *      Try to find and initialize an EasyIO board.
2255  */
2256
2257 static int stl_initeio(stlbrd_t *brdp)
2258 {
2259         stlpanel_t      *panelp;
2260         unsigned int    status;
2261
2262 #if STLDEBUG
2263         printf("stl_initeio(brdp=%x)\n", (int) brdp);
2264 #endif
2265
2266         brdp->ioctrl = brdp->ioaddr1 + 1;
2267         brdp->iostatus = brdp->ioaddr1 + 2;
2268         brdp->clk = EIO_CLK;
2269         brdp->isr = stl_eiointr;
2270
2271         status = inb(brdp->iostatus);
2272         switch (status & EIO_IDBITMASK) {
2273         case EIO_8PORTM:
2274                 brdp->clk = EIO_CLK8M;
2275                 /* fall thru */
2276         case EIO_8PORTRS:
2277         case EIO_8PORTDI:
2278                 brdp->nrports = 8;
2279                 break;
2280         case EIO_4PORTRS:
2281                 brdp->nrports = 4;
2282                 break;
2283         case EIO_MK3:
2284                 switch (status & EIO_BRDMASK) {
2285                 case ID_BRD4:
2286                         brdp->nrports = 4;
2287                         break;
2288                 case ID_BRD8:
2289                         brdp->nrports = 8;
2290                         break;
2291                 case ID_BRD16:
2292                         brdp->nrports = 16;
2293                         break;
2294                 default:
2295                         return(ENODEV);
2296                 }
2297                 brdp->ioctrl++;
2298                 break;
2299         default:
2300                 return(ENODEV);
2301         }
2302
2303         if (brdp->brdtype == BRD_EASYIOPCI) {
2304                 outb((brdp->ioaddr2 + 0x4c), 0x41);
2305         } else {
2306 /*
2307  *      Check that the supplied IRQ is good and then use it to setup the
2308  *      programmable interrupt bits on EIO board. Also set the edge/level
2309  *      triggered interrupt bit.
2310  */
2311                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
2312                         (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
2313                         printf("STALLION: invalid irq=%d for brd=%d\n",
2314                                brdp->irq, brdp->brdnr);
2315                         return(EINVAL);
2316                 }
2317                 outb(brdp->ioctrl, (stl_vecmap[brdp->irq] |
2318                         ((brdp->irqtype) ? EIO_INTLEVEL : EIO_INTEDGE)));
2319         }
2320
2321         panelp = malloc(sizeof(stlpanel_t), M_TTYS, M_WAITOK | M_ZERO);
2322         panelp->brdnr = brdp->brdnr;
2323         panelp->panelnr = 0;
2324         panelp->nrports = brdp->nrports;
2325         panelp->iobase = brdp->ioaddr1;
2326         panelp->hwid = status;
2327         if ((status & EIO_IDBITMASK) == EIO_MK3) {
2328                 panelp->uartp = (void *) &stl_sc26198uart;
2329                 panelp->isr = stl_sc26198intr;
2330         } else {
2331                 panelp->uartp = (void *) &stl_cd1400uart;
2332                 panelp->isr = stl_cd1400eiointr;
2333         }
2334         brdp->panels[0] = panelp;
2335         brdp->nrpanels = 1;
2336         brdp->hwid = status;
2337         brdp->state |= BRD_FOUND;
2338         return(0);
2339 }
2340
2341 /*****************************************************************************/
2342
2343 /*
2344  *      Try to find an ECH board and initialize it. This code is capable of
2345  *      dealing with all types of ECH board.
2346  */
2347
2348 static int stl_initech(stlbrd_t *brdp)
2349 {
2350         stlpanel_t      *panelp;
2351         unsigned int    status, nxtid;
2352         int             panelnr, ioaddr, banknr, i;
2353
2354 #if STLDEBUG
2355         printf("stl_initech(brdp=%x)\n", (int) brdp);
2356 #endif
2357
2358 /*
2359  *      Set up the initial board register contents for boards. This varys a
2360  *      bit between the different board types. So we need to handle each
2361  *      separately. Also do a check that the supplied IRQ is good.
2362  */
2363         switch (brdp->brdtype) {
2364
2365         case BRD_ECH:
2366                 brdp->isr = stl_echatintr;
2367                 brdp->ioctrl = brdp->ioaddr1 + 1;
2368                 brdp->iostatus = brdp->ioaddr1 + 1;
2369                 status = inb(brdp->iostatus);
2370                 if ((status & ECH_IDBITMASK) != ECH_ID)
2371                         return(ENODEV);
2372                 brdp->hwid = status;
2373
2374                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
2375                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
2376                         printf("STALLION: invalid irq=%d for brd=%d\n",
2377                                 brdp->irq, brdp->brdnr);
2378                         return(EINVAL);
2379                 }
2380                 status = ((brdp->ioaddr2 & ECH_ADDR2MASK) >> 1);
2381                 status |= (stl_vecmap[brdp->irq] << 1);
2382                 outb(brdp->ioaddr1, (status | ECH_BRDRESET));
2383                 brdp->ioctrlval = ECH_INTENABLE |
2384                         ((brdp->irqtype) ? ECH_INTLEVEL : ECH_INTEDGE);
2385                 outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDENABLE));
2386                 outb(brdp->ioaddr1, status);
2387                 break;
2388
2389         case BRD_ECHMC:
2390                 brdp->isr = stl_echmcaintr;
2391                 brdp->ioctrl = brdp->ioaddr1 + 0x20;
2392                 brdp->iostatus = brdp->ioctrl;
2393                 status = inb(brdp->iostatus);
2394                 if ((status & ECH_IDBITMASK) != ECH_ID)
2395                         return(ENODEV);
2396                 brdp->hwid = status;
2397
2398                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
2399                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
2400                         printf("STALLION: invalid irq=%d for brd=%d\n",
2401                                 brdp->irq, brdp->brdnr);
2402                         return(EINVAL);
2403                 }
2404                 outb(brdp->ioctrl, ECHMC_BRDRESET);
2405                 outb(brdp->ioctrl, ECHMC_INTENABLE);
2406                 break;
2407
2408         case BRD_ECHPCI:
2409                 brdp->isr = stl_echpciintr;
2410                 brdp->ioctrl = brdp->ioaddr1 + 2;
2411                 break;
2412
2413         case BRD_ECH64PCI:
2414                 brdp->isr = stl_echpci64intr;
2415                 brdp->ioctrl = brdp->ioaddr2 + 0x40;
2416                 outb((brdp->ioaddr1 + 0x4c), 0x43);
2417                 break;
2418
2419         default:
2420                 printf("STALLION: unknown board type=%d\n", brdp->brdtype);
2421                 break;
2422         }
2423
2424         brdp->clk = ECH_CLK;
2425
2426 /*
2427  *      Scan through the secondary io address space looking for panels.
2428  *      As we find'em allocate and initialize panel structures for each.
2429  */
2430         ioaddr = brdp->ioaddr2;
2431         panelnr = 0;
2432         nxtid = 0;
2433         banknr = 0;
2434
2435         for (i = 0; (i < STL_MAXPANELS); i++) {
2436                 if (brdp->brdtype == BRD_ECHPCI) {
2437                         outb(brdp->ioctrl, nxtid);
2438                         ioaddr = brdp->ioaddr2;
2439                 }
2440                 status = inb(ioaddr + ECH_PNLSTATUS);
2441                 if ((status & ECH_PNLIDMASK) != nxtid)
2442                         break;
2443                 panelp = malloc(sizeof(stlpanel_t), M_TTYS, M_WAITOK | M_ZERO);
2444                 panelp->brdnr = brdp->brdnr;
2445                 panelp->panelnr = panelnr;
2446                 panelp->iobase = ioaddr;
2447                 panelp->pagenr = nxtid;
2448                 panelp->hwid = status;
2449                 brdp->bnk2panel[banknr] = panelp;
2450                 brdp->bnkpageaddr[banknr] = nxtid;
2451                 brdp->bnkstataddr[banknr++] = ioaddr + ECH_PNLSTATUS;
2452
2453                 if (status & ECH_PNLXPID) {
2454                         panelp->uartp = (void *) &stl_sc26198uart;
2455                         panelp->isr = stl_sc26198intr;
2456                         if (status & ECH_PNL16PORT) {
2457                                 panelp->nrports = 16;
2458                                 brdp->bnk2panel[banknr] = panelp;
2459                                 brdp->bnkpageaddr[banknr] = nxtid;
2460                                 brdp->bnkstataddr[banknr++] = ioaddr + 4 +
2461                                         ECH_PNLSTATUS;
2462                         } else {
2463                                 panelp->nrports = 8;
2464                         }
2465                 } else {
2466                         panelp->uartp = (void *) &stl_cd1400uart;
2467                         panelp->isr = stl_cd1400echintr;
2468                         if (status & ECH_PNL16PORT) {
2469                                 panelp->nrports = 16;
2470                                 panelp->ackmask = 0x80;
2471                                 if (brdp->brdtype != BRD_ECHPCI)
2472                                         ioaddr += EREG_BANKSIZE;
2473                                 brdp->bnk2panel[banknr] = panelp;
2474                                 brdp->bnkpageaddr[banknr] = ++nxtid;
2475                                 brdp->bnkstataddr[banknr++] = ioaddr +
2476                                         ECH_PNLSTATUS;
2477                         } else {
2478                                 panelp->nrports = 8;
2479                                 panelp->ackmask = 0xc0;
2480                         }
2481                 }
2482
2483                 nxtid++;
2484                 ioaddr += EREG_BANKSIZE;
2485                 brdp->nrports += panelp->nrports;
2486                 brdp->panels[panelnr++] = panelp;
2487                 if ((brdp->brdtype == BRD_ECH) || (brdp->brdtype == BRD_ECHMC)){
2488                         if (ioaddr >= (brdp->ioaddr2 + 0x20)) {
2489                                 printf("STALLION: too many ports attached "
2490                                         "to board %d, remove last module\n",
2491                                         brdp->brdnr);
2492                                 break;
2493                         }
2494                 }
2495         }
2496
2497         brdp->nrpanels = panelnr;
2498         brdp->nrbnks = banknr;
2499         if (brdp->brdtype == BRD_ECH)
2500                 outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDDISABLE));
2501
2502         brdp->state |= BRD_FOUND;
2503         return(0);
2504 }
2505
2506 /*****************************************************************************/
2507
2508 /*
2509  *      Initialize and configure the specified board. This firstly probes
2510  *      for the board, if it is found then the board is initialized and
2511  *      then all its ports are initialized as well.
2512  */
2513
2514 static int stl_brdinit(stlbrd_t *brdp)
2515 {
2516         stlpanel_t      *panelp;
2517         int             i, j, k;
2518
2519 #if STLDEBUG
2520         printf("stl_brdinit(brdp=%x): unit=%d type=%d io1=%x io2=%x irq=%d\n",
2521                 (int) brdp, brdp->brdnr, brdp->brdtype, brdp->ioaddr1,
2522                 brdp->ioaddr2, brdp->irq);
2523 #endif
2524
2525         switch (brdp->brdtype) {
2526         case BRD_EASYIO:
2527         case BRD_EASYIOPCI:
2528                 stl_initeio(brdp);
2529                 break;
2530         case BRD_ECH:
2531         case BRD_ECHMC:
2532         case BRD_ECHPCI:
2533         case BRD_ECH64PCI:
2534                 stl_initech(brdp);
2535                 break;
2536         default:
2537                 printf("STALLION: unit=%d is unknown board type=%d\n",
2538                         brdp->brdnr, brdp->brdtype);
2539                 return(ENODEV);
2540         }
2541
2542         stl_brds[brdp->brdnr] = brdp;
2543         if ((brdp->state & BRD_FOUND) == 0) {
2544 #if 0
2545                 printf("STALLION: %s board not found, unit=%d io=%x irq=%d\n",
2546                         stl_brdnames[brdp->brdtype], brdp->brdnr,
2547                         brdp->ioaddr1, brdp->irq);
2548 #endif
2549                 return(ENODEV);
2550         }
2551
2552         for (i = 0, k = 0; (i < STL_MAXPANELS); i++) {
2553                 panelp = brdp->panels[i];
2554                 if (panelp != (stlpanel_t *) NULL) {
2555                         stl_initports(brdp, panelp);
2556                         for (j = 0; (j < panelp->nrports); j++)
2557                                 brdp->ports[k++] = panelp->ports[j];
2558                 }
2559         }
2560
2561         printf("stl%d: %s (driver version %s) unit=%d nrpanels=%d nrports=%d\n",
2562                 brdp->unitid, stl_brdnames[brdp->brdtype], stl_drvversion,
2563                 brdp->brdnr, brdp->nrpanels, brdp->nrports);
2564         return(0);
2565 }
2566
2567 /*****************************************************************************/
2568
2569 /*
2570  *      Return the board stats structure to user app.
2571  */
2572
2573 static int stl_getbrdstats(caddr_t data)
2574 {
2575         stlbrd_t        *brdp;
2576         stlpanel_t      *panelp;
2577         int             i;
2578
2579         stl_brdstats = *((combrd_t *) data);
2580         if (stl_brdstats.brd >= STL_MAXBRDS)
2581                 return(-ENODEV);
2582         brdp = stl_brds[stl_brdstats.brd];
2583         if (brdp == (stlbrd_t *) NULL)
2584                 return(-ENODEV);
2585
2586         bzero(&stl_brdstats, sizeof(combrd_t));
2587         stl_brdstats.brd = brdp->brdnr;
2588         stl_brdstats.type = brdp->brdtype;
2589         stl_brdstats.hwid = brdp->hwid;
2590         stl_brdstats.state = brdp->state;
2591         stl_brdstats.ioaddr = brdp->ioaddr1;
2592         stl_brdstats.ioaddr2 = brdp->ioaddr2;
2593         stl_brdstats.irq = brdp->irq;
2594         stl_brdstats.nrpanels = brdp->nrpanels;
2595         stl_brdstats.nrports = brdp->nrports;
2596         for (i = 0; (i < brdp->nrpanels); i++) {
2597                 panelp = brdp->panels[i];
2598                 stl_brdstats.panels[i].panel = i;
2599                 stl_brdstats.panels[i].hwid = panelp->hwid;
2600                 stl_brdstats.panels[i].nrports = panelp->nrports;
2601         }
2602
2603         *((combrd_t *) data) = stl_brdstats;;
2604         return(0);
2605 }
2606
2607 /*****************************************************************************/
2608
2609 /*
2610  *      Resolve the referenced port number into a port struct pointer.
2611  */
2612
2613 static stlport_t *stl_getport(int brdnr, int panelnr, int portnr)
2614 {
2615         stlbrd_t        *brdp;
2616         stlpanel_t      *panelp;
2617
2618         if ((brdnr < 0) || (brdnr >= STL_MAXBRDS))
2619                 return((stlport_t *) NULL);
2620         brdp = stl_brds[brdnr];
2621         if (brdp == (stlbrd_t *) NULL)
2622                 return((stlport_t *) NULL);
2623         if ((panelnr < 0) || (panelnr >= brdp->nrpanels))
2624                 return((stlport_t *) NULL);
2625         panelp = brdp->panels[panelnr];
2626         if (panelp == (stlpanel_t *) NULL)
2627                 return((stlport_t *) NULL);
2628         if ((portnr < 0) || (portnr >= panelp->nrports))
2629                 return((stlport_t *) NULL);
2630         return(panelp->ports[portnr]);
2631 }
2632
2633 /*****************************************************************************/
2634
2635 /*
2636  *      Return the port stats structure to user app. A NULL port struct
2637  *      pointer passed in means that we need to find out from the app
2638  *      what port to get stats for (used through board control device).
2639  */
2640
2641 static int stl_getportstats(stlport_t *portp, caddr_t data)
2642 {
2643         unsigned char   *head, *tail;
2644
2645         if (portp == (stlport_t *) NULL) {
2646                 stl_comstats = *((comstats_t *) data);
2647                 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2648                         stl_comstats.port);
2649                 if (portp == (stlport_t *) NULL)
2650                         return(-ENODEV);
2651         }
2652
2653         portp->stats.state = portp->state;
2654         /*portp->stats.flags = portp->flags;*/
2655         portp->stats.hwid = portp->hwid;
2656         portp->stats.ttystate = portp->tty.t_state;
2657         portp->stats.cflags = portp->tty.t_cflag;
2658         portp->stats.iflags = portp->tty.t_iflag;
2659         portp->stats.oflags = portp->tty.t_oflag;
2660         portp->stats.lflags = portp->tty.t_lflag;
2661
2662         head = portp->tx.head;
2663         tail = portp->tx.tail;
2664         portp->stats.txbuffered = ((head >= tail) ? (head - tail) :
2665                 (STL_TXBUFSIZE - (tail - head)));
2666
2667         head = portp->rx.head;
2668         tail = portp->rx.tail;
2669         portp->stats.rxbuffered = (head >= tail) ? (head - tail) :
2670                 (STL_RXBUFSIZE - (tail - head));
2671
2672         portp->stats.signals = (unsigned long) stl_getsignals(portp);
2673
2674         *((comstats_t *) data) = portp->stats;
2675         return(0);
2676 }
2677
2678 /*****************************************************************************/
2679
2680 /*
2681  *      Clear the port stats structure. We also return it zeroed out...
2682  */
2683
2684 static int stl_clrportstats(stlport_t *portp, caddr_t data)
2685 {
2686         if (portp == (stlport_t *) NULL) {
2687                 stl_comstats = *((comstats_t *) data);
2688                 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2689                         stl_comstats.port);
2690                 if (portp == (stlport_t *) NULL)
2691                         return(ENODEV);
2692         }
2693
2694         bzero(&portp->stats, sizeof(comstats_t));
2695         portp->stats.brd = portp->brdnr;
2696         portp->stats.panel = portp->panelnr;
2697         portp->stats.port = portp->portnr;
2698         *((comstats_t *) data) = stl_comstats;
2699         return(0);
2700 }
2701
2702 /*****************************************************************************/
2703
2704 /*
2705  *      The "staliomem" device is used for stats collection in this driver.
2706  */
2707
2708 static int stl_memioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag,
2709                         struct thread *td)
2710 {
2711         int             rc;
2712
2713 #if STLDEBUG
2714         printf("stl_memioctl(dev=%s,cmd=%lx,data=%p,flag=%x)\n",
2715                 devtoname(dev), cmd, (void *) data, flag);
2716 #endif
2717
2718         rc = 0;
2719
2720         switch (cmd) {
2721         case COM_GETPORTSTATS:
2722                 rc = stl_getportstats((stlport_t *) NULL, data);
2723                 break;
2724         case COM_CLRPORTSTATS:
2725                 rc = stl_clrportstats((stlport_t *) NULL, data);
2726                 break;
2727         case COM_GETBRDSTATS:
2728                 rc = stl_getbrdstats(data);
2729                 break;
2730         default:
2731                 rc = ENOTTY;
2732                 break;
2733         }
2734
2735         return(rc);
2736 }
2737
2738 /*****************************************************************************/
2739
2740 /*****************************************************************************/
2741 /*                         CD1400 UART CODE                                  */
2742 /*****************************************************************************/
2743
2744 /*
2745  *      These functions get/set/update the registers of the cd1400 UARTs.
2746  *      Access to the cd1400 registers is via an address/data io port pair.
2747  */
2748
2749 static int stl_cd1400getreg(stlport_t *portp, int regnr)
2750 {
2751         outb(portp->ioaddr, (regnr + portp->uartaddr));
2752         return(inb(portp->ioaddr + EREG_DATA));
2753 }
2754
2755 /*****************************************************************************/
2756
2757 static void stl_cd1400setreg(stlport_t *portp, int regnr, int value)
2758 {
2759         outb(portp->ioaddr, (regnr + portp->uartaddr));
2760         outb((portp->ioaddr + EREG_DATA), value);
2761 }
2762
2763 /*****************************************************************************/
2764
2765 static int stl_cd1400updatereg(stlport_t *portp, int regnr, int value)
2766 {
2767         outb(portp->ioaddr, (regnr + portp->uartaddr));
2768         if (inb(portp->ioaddr + EREG_DATA) != value) {
2769                 outb((portp->ioaddr + EREG_DATA), value);
2770                 return(1);
2771         }
2772         return(0);
2773 }
2774
2775 /*****************************************************************************/
2776
2777 static void stl_cd1400flush(stlport_t *portp, int flag)
2778 {
2779         int     x;
2780
2781 #if STLDEBUG
2782         printf("stl_cd1400flush(portp=%x,flag=%x)\n", (int) portp, flag);
2783 #endif
2784
2785         if (portp == (stlport_t *) NULL)
2786                 return;
2787
2788         x = spltty();
2789
2790         if (flag & FWRITE) {
2791                 BRDENABLE(portp->brdnr, portp->pagenr);
2792                 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2793                 stl_cd1400ccrwait(portp);
2794                 stl_cd1400setreg(portp, CCR, CCR_TXFLUSHFIFO);
2795                 stl_cd1400ccrwait(portp);
2796                 BRDDISABLE(portp->brdnr);
2797         }
2798
2799         if (flag & FREAD) {
2800                 /* Hmmm */
2801         }
2802
2803         splx(x);
2804 }
2805
2806 /*****************************************************************************/
2807
2808 static void stl_cd1400ccrwait(stlport_t *portp)
2809 {
2810         int     i;
2811
2812         for (i = 0; (i < CCR_MAXWAIT); i++) {
2813                 if (stl_cd1400getreg(portp, CCR) == 0)
2814                         return;
2815         }
2816
2817         printf("stl%d: cd1400 device not responding, panel=%d port=%d\n",
2818             portp->brdnr, portp->panelnr, portp->portnr);
2819 }
2820
2821 /*****************************************************************************/
2822
2823 /*
2824  *      Transmit interrupt handler. This has gotta be fast!  Handling TX
2825  *      chars is pretty simple, stuff as many as possible from the TX buffer
2826  *      into the cd1400 FIFO. Must also handle TX breaks here, since they
2827  *      are embedded as commands in the data stream. Oh no, had to use a goto!
2828  */
2829
2830 static __inline void stl_cd1400txisr(stlpanel_t *panelp, int ioaddr)
2831 {
2832         struct tty      *tp;
2833         stlport_t       *portp;
2834         unsigned char   ioack, srer;
2835         char            *head, *tail;
2836         int             len, stlen;
2837
2838 #if STLDEBUG
2839         printf("stl_cd1400txisr(panelp=%x,ioaddr=%x)\n", (int) panelp, ioaddr);
2840 #endif
2841
2842         ioack = inb(ioaddr + EREG_TXACK);
2843         if (((ioack & panelp->ackmask) != 0) ||
2844             ((ioack & ACK_TYPMASK) != ACK_TYPTX)) {
2845                 printf("STALLION: bad TX interrupt ack value=%x\n",
2846                         ioack);
2847                 return;
2848         }
2849         portp = panelp->ports[(ioack >> 3)];
2850         tp = &portp->tty;
2851
2852 /*
2853  *      Unfortunately we need to handle breaks in the data stream, since
2854  *      this is the only way to generate them on the cd1400. Do it now if
2855  *      a break is to be sent. Some special cases here: brklen is -1 then
2856  *      start sending an un-timed break, if brklen is -2 then stop sending
2857  *      an un-timed break, if brklen is -3 then we have just sent an
2858  *      un-timed break and do not want any data to go out, if brklen is -4
2859  *      then a break has just completed so clean up the port settings.
2860  */
2861         if (portp->brklen != 0) {
2862                 if (portp->brklen >= -1) {
2863                         outb(ioaddr, (TDR + portp->uartaddr));
2864                         outb((ioaddr + EREG_DATA), ETC_CMD);
2865                         outb((ioaddr + EREG_DATA), ETC_STARTBREAK);
2866                         if (portp->brklen > 0) {
2867                                 outb((ioaddr + EREG_DATA), ETC_CMD);
2868                                 outb((ioaddr + EREG_DATA), ETC_DELAY);
2869                                 outb((ioaddr + EREG_DATA), portp->brklen);
2870                                 outb((ioaddr + EREG_DATA), ETC_CMD);
2871                                 outb((ioaddr + EREG_DATA), ETC_STOPBREAK);
2872                                 portp->brklen = -4;
2873                         } else {
2874                                 portp->brklen = -3;
2875                         }
2876                 } else if (portp->brklen == -2) {
2877                         outb(ioaddr, (TDR + portp->uartaddr));
2878                         outb((ioaddr + EREG_DATA), ETC_CMD);
2879                         outb((ioaddr + EREG_DATA), ETC_STOPBREAK);
2880                         portp->brklen = -4;
2881                 } else if (portp->brklen == -3) {
2882                         outb(ioaddr, (SRER + portp->uartaddr));
2883                         srer = inb(ioaddr + EREG_DATA);
2884                         srer &= ~(SRER_TXDATA | SRER_TXEMPTY);
2885                         outb((ioaddr + EREG_DATA), srer);
2886                 } else {
2887                         outb(ioaddr, (COR2 + portp->uartaddr));
2888                         outb((ioaddr + EREG_DATA),
2889                                 (inb(ioaddr + EREG_DATA) & ~COR2_ETC));
2890                         portp->brklen = 0;
2891                 }
2892                 goto stl_txalldone;
2893         }
2894
2895         head = portp->tx.head;
2896         tail = portp->tx.tail;
2897         len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
2898         if ((len == 0) || ((len < STL_TXBUFLOW) &&
2899             ((portp->state & ASY_TXLOW) == 0))) {
2900                 portp->state |= ASY_TXLOW;
2901                 stl_dotimeout();
2902         }
2903
2904         if (len == 0) {
2905                 outb(ioaddr, (SRER + portp->uartaddr));
2906                 srer = inb(ioaddr + EREG_DATA);
2907                 if (srer & SRER_TXDATA) {
2908                         srer = (srer & ~SRER_TXDATA) | SRER_TXEMPTY;
2909                 } else {
2910                         srer &= ~(SRER_TXDATA | SRER_TXEMPTY);
2911                         portp->state |= ASY_TXEMPTY;
2912                         portp->state &= ~ASY_TXBUSY;
2913                 }
2914                 outb((ioaddr + EREG_DATA), srer);
2915         } else {
2916                 len = MIN(len, CD1400_TXFIFOSIZE);
2917                 portp->stats.txtotal += len;
2918                 stlen = MIN(len, (portp->tx.endbuf - tail));
2919                 outb(ioaddr, (TDR + portp->uartaddr));
2920                 outsb((ioaddr + EREG_DATA), tail, stlen);
2921                 len -= stlen;
2922                 tail += stlen;
2923                 if (tail >= portp->tx.endbuf)
2924                         tail = portp->tx.buf;
2925                 if (len > 0) {
2926                         outsb((ioaddr + EREG_DATA), tail, len);
2927                         tail += len;
2928                 }
2929                 portp->tx.tail = tail;
2930         }
2931
2932 stl_txalldone:
2933         outb(ioaddr, (EOSRR + portp->uartaddr));
2934         outb((ioaddr + EREG_DATA), 0);
2935 }
2936
2937 /*****************************************************************************/
2938
2939 /*
2940  *      Receive character interrupt handler. Determine if we have good chars
2941  *      or bad chars and then process appropriately.
2942  */
2943
2944 static __inline void stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr)
2945 {
2946         stlport_t       *portp;
2947         struct tty      *tp;
2948         unsigned int    ioack, len, buflen, stlen;
2949         unsigned char   status;
2950         char            ch;
2951         char            *head, *tail;
2952
2953 #if STLDEBUG
2954         printf("stl_cd1400rxisr(panelp=%x,ioaddr=%x)\n", (int) panelp, ioaddr);
2955 #endif
2956
2957         ioack = inb(ioaddr + EREG_RXACK);
2958         if ((ioack & panelp->ackmask) != 0) {
2959                 printf("STALLION: bad RX interrupt ack value=%x\n", ioack);
2960                 return;
2961         }
2962         portp = panelp->ports[(ioack >> 3)];
2963         tp = &portp->tty;
2964
2965 /*
2966  *      First up, calculate how much room there is in the RX ring queue.
2967  *      We also want to keep track of the longest possible copy length,
2968  *      this has to allow for the wrapping of the ring queue.
2969  */
2970         head = portp->rx.head;
2971         tail = portp->rx.tail;
2972         if (head >= tail) {
2973                 buflen = STL_RXBUFSIZE - (head - tail) - 1;
2974                 stlen = portp->rx.endbuf - head;
2975         } else {
2976                 buflen = tail - head - 1;
2977                 stlen = buflen;
2978         }
2979
2980 /*
2981  *      Check if the input buffer is near full. If so then we should take
2982  *      some flow control action... It is very easy to do hardware and
2983  *      software flow control from here since we have the port selected on
2984  *      the UART.
2985  */
2986         if (buflen <= (STL_RXBUFSIZE - STL_RXBUFHIGH)) {
2987                 if (((portp->state & ASY_RTSFLOW) == 0) &&
2988                     (portp->state & ASY_RTSFLOWMODE)) {
2989                         portp->state |= ASY_RTSFLOW;
2990                         stl_cd1400setreg(portp, MCOR1,
2991                                 (stl_cd1400getreg(portp, MCOR1) & 0xf0));
2992                         stl_cd1400setreg(portp, MSVR2, 0);
2993                         portp->stats.rxrtsoff++;
2994                 }
2995         }
2996
2997 /*
2998  *      OK we are set, process good data... If the RX ring queue is full
2999  *      just chuck the chars - don't leave them in the UART.
3000  */
3001         if ((ioack & ACK_TYPMASK) == ACK_TYPRXGOOD) {
3002                 outb(ioaddr, (RDCR + portp->uartaddr));
3003                 len = inb(ioaddr + EREG_DATA);
3004                 if (buflen == 0) {
3005                         outb(ioaddr, (RDSR + portp->uartaddr));
3006                         insb((ioaddr + EREG_DATA), &stl_unwanted[0], len);
3007                         portp->stats.rxlost += len;
3008                         portp->stats.rxtotal += len;
3009                 } else {
3010                         len = MIN(len, buflen);
3011                         portp->stats.rxtotal += len;
3012                         stlen = MIN(len, stlen);
3013                         if (len > 0) {
3014                                 outb(ioaddr, (RDSR + portp->uartaddr));
3015                                 insb((ioaddr + EREG_DATA), head, stlen);
3016                                 head += stlen;
3017                                 if (head >= portp->rx.endbuf) {
3018                                         head = portp->rx.buf;
3019                                         len -= stlen;
3020                                         insb((ioaddr + EREG_DATA), head, len);
3021                                         head += len;
3022                                 }
3023                         }
3024                 }
3025         } else if ((ioack & ACK_TYPMASK) == ACK_TYPRXBAD) {
3026                 outb(ioaddr, (RDSR + portp->uartaddr));
3027                 status = inb(ioaddr + EREG_DATA);
3028                 ch = inb(ioaddr + EREG_DATA);
3029                 if (status & ST_BREAK)
3030                         portp->stats.rxbreaks++;
3031                 if (status & ST_FRAMING)
3032                         portp->stats.rxframing++;
3033                 if (status & ST_PARITY)
3034                         portp->stats.rxparity++;
3035                 if (status & ST_OVERRUN)
3036                         portp->stats.rxoverrun++;
3037                 if (status & ST_SCHARMASK) {
3038                         if ((status & ST_SCHARMASK) == ST_SCHAR1)
3039                                 portp->stats.txxon++;
3040                         if ((status & ST_SCHARMASK) == ST_SCHAR2)
3041                                 portp->stats.txxoff++;
3042                         goto stl_rxalldone;
3043                 }
3044                 if ((portp->rxignoremsk & status) == 0) {
3045                         if ((tp->t_state & TS_CAN_BYPASS_L_RINT) &&
3046                             ((status & ST_FRAMING) ||
3047                             ((status & ST_PARITY) && (tp->t_iflag & INPCK))))
3048                                 ch = 0;
3049                         if ((portp->rxmarkmsk & status) == 0)
3050                                 status = 0;
3051                         *(head + STL_RXBUFSIZE) = status;
3052                         *head++ = ch;
3053                         if (head >= portp->rx.endbuf)
3054                                 head = portp->rx.buf;
3055                 }
3056         } else {
3057                 printf("STALLION: bad RX interrupt ack value=%x\n", ioack);
3058                 return;
3059         }
3060
3061         portp->rx.head = head;
3062         portp->state |= ASY_RXDATA;
3063         stl_dotimeout();
3064
3065 stl_rxalldone:
3066         outb(ioaddr, (EOSRR + portp->uartaddr));
3067         outb((ioaddr + EREG_DATA), 0);
3068 }
3069
3070 /*****************************************************************************/
3071
3072 /*
3073  *      Modem interrupt handler. The is called when the modem signal line
3074  *      (DCD) has changed state.
3075  */
3076
3077 static __inline void stl_cd1400mdmisr(stlpanel_t *panelp, int ioaddr)
3078 {
3079         stlport_t       *portp;
3080         unsigned int    ioack;
3081         unsigned char   misr;
3082
3083 #if STLDEBUG
3084         printf("stl_cd1400mdmisr(panelp=%x,ioaddr=%x)\n", (int) panelp, ioaddr);
3085 #endif
3086
3087         ioack = inb(ioaddr + EREG_MDACK);
3088         if (((ioack & panelp->ackmask) != 0) ||
3089             ((ioack & ACK_TYPMASK) != ACK_TYPMDM)) {
3090                 printf("STALLION: bad MODEM interrupt ack value=%x\n", ioack);
3091                 return;
3092         }
3093         portp = panelp->ports[(ioack >> 3)];
3094
3095         outb(ioaddr, (MISR + portp->uartaddr));
3096         misr = inb(ioaddr + EREG_DATA);
3097         if (misr & MISR_DCD) {
3098                 portp->state |= ASY_DCDCHANGE;
3099                 portp->stats.modem++;
3100                 stl_dotimeout();
3101         }
3102
3103         outb(ioaddr, (EOSRR + portp->uartaddr));
3104         outb((ioaddr + EREG_DATA), 0);
3105 }
3106
3107 /*****************************************************************************/
3108
3109 /*
3110  *      Interrupt service routine for cd1400 EasyIO boards.
3111  */
3112
3113 static void stl_cd1400eiointr(stlpanel_t *panelp, unsigned int iobase)
3114 {
3115         unsigned char   svrtype;
3116
3117 #if STLDEBUG
3118         printf("stl_cd1400eiointr(panelp=%x,iobase=%x)\n", (int) panelp,
3119                 iobase);
3120 #endif
3121
3122         outb(iobase, SVRR);
3123         svrtype = inb(iobase + EREG_DATA);
3124         if (panelp->nrports > 4) {
3125                 outb(iobase, (SVRR + 0x80));
3126                 svrtype |= inb(iobase + EREG_DATA);
3127         }
3128 #if STLDEBUG
3129 printf("stl_cd1400eiointr(panelp=%x,iobase=%x): svrr=%x\n", (int) panelp, iobase, svrtype);
3130 #endif
3131
3132         if (svrtype & SVRR_RX)
3133                 stl_cd1400rxisr(panelp, iobase);
3134         else if (svrtype & SVRR_TX)
3135                 stl_cd1400txisr(panelp, iobase);
3136         else if (svrtype & SVRR_MDM)
3137                 stl_cd1400mdmisr(panelp, iobase);
3138 }
3139
3140 /*****************************************************************************/
3141
3142 /*
3143  *      Interrupt service routine for cd1400 panels.
3144  */
3145
3146 static void stl_cd1400echintr(stlpanel_t *panelp, unsigned int iobase)
3147 {
3148         unsigned char   svrtype;
3149
3150 #if STLDEBUG
3151         printf("stl_cd1400echintr(panelp=%x,iobase=%x)\n", (int) panelp,
3152                 iobase);
3153 #endif
3154
3155         outb(iobase, SVRR);
3156         svrtype = inb(iobase + EREG_DATA);
3157         outb(iobase, (SVRR + 0x80));
3158         svrtype |= inb(iobase + EREG_DATA);
3159         if (svrtype & SVRR_RX)
3160                 stl_cd1400rxisr(panelp, iobase);
3161         else if (svrtype & SVRR_TX)
3162                 stl_cd1400txisr(panelp, iobase);
3163         else if (svrtype & SVRR_MDM)
3164                 stl_cd1400mdmisr(panelp, iobase);
3165 }
3166
3167 /*****************************************************************************/
3168
3169 /*
3170  *      Set up the cd1400 registers for a port based on the termios port
3171  *      settings.
3172  */
3173
3174 static int stl_cd1400setport(stlport_t *portp, struct termios *tiosp)
3175 {
3176         unsigned int    clkdiv;
3177         unsigned char   cor1, cor2, cor3;
3178         unsigned char   cor4, cor5, ccr;
3179         unsigned char   srer, sreron, sreroff;
3180         unsigned char   mcor1, mcor2, rtpr;
3181         unsigned char   clk, div;
3182         int             x;
3183
3184 #if STLDEBUG
3185         printf("stl_cd1400setport(portp=%x,tiosp=%x): brdnr=%d portnr=%d\n",
3186                 (int) portp, (int) tiosp, portp->brdnr, portp->portnr);
3187 #endif
3188
3189         cor1 = 0;
3190         cor2 = 0;
3191         cor3 = 0;
3192         cor4 = 0;
3193         cor5 = 0;
3194         ccr = 0;
3195         rtpr = 0;
3196         clk = 0;
3197         div = 0;
3198         mcor1 = 0;
3199         mcor2 = 0;
3200         sreron = 0;
3201         sreroff = 0;
3202
3203 /*
3204  *      Set up the RX char ignore mask with those RX error types we
3205  *      can ignore. We could have used some special modes of the cd1400
3206  *      UART to help, but it is better this way because we can keep stats
3207  *      on the number of each type of RX exception event.
3208  */
3209         portp->rxignoremsk = 0;
3210         if (tiosp->c_iflag & IGNPAR)
3211                 portp->rxignoremsk |= (ST_PARITY | ST_FRAMING | ST_OVERRUN);
3212         if (tiosp->c_iflag & IGNBRK)
3213                 portp->rxignoremsk |= ST_BREAK;
3214
3215         portp->rxmarkmsk = ST_OVERRUN;
3216         if (tiosp->c_iflag & (INPCK | PARMRK))
3217                 portp->rxmarkmsk |= (ST_PARITY | ST_FRAMING);
3218         if (tiosp->c_iflag & BRKINT)
3219                 portp->rxmarkmsk |= ST_BREAK;
3220
3221 /*
3222  *      Go through the char size, parity and stop bits and set all the
3223  *      option registers appropriately.
3224  */
3225         switch (tiosp->c_cflag & CSIZE) {
3226         case CS5:
3227                 cor1 |= COR1_CHL5;
3228                 break;
3229         case CS6:
3230                 cor1 |= COR1_CHL6;
3231                 break;
3232         case CS7:
3233                 cor1 |= COR1_CHL7;
3234                 break;
3235         default:
3236                 cor1 |= COR1_CHL8;
3237                 break;
3238         }
3239
3240         if (tiosp->c_cflag & CSTOPB)
3241                 cor1 |= COR1_STOP2;
3242         else
3243                 cor1 |= COR1_STOP1;
3244
3245         if (tiosp->c_cflag & PARENB) {
3246                 if (tiosp->c_cflag & PARODD)
3247                         cor1 |= (COR1_PARENB | COR1_PARODD);
3248                 else
3249                         cor1 |= (COR1_PARENB | COR1_PAREVEN);
3250         } else {
3251                 cor1 |= COR1_PARNONE;
3252         }
3253
3254 /*
3255  *      Set the RX FIFO threshold at 6 chars. This gives a bit of breathing
3256  *      space for hardware flow control and the like. This should be set to
3257  *      VMIN. Also here we will set the RX data timeout to 10ms - this should
3258  *      really be based on VTIME...
3259  */
3260         cor3 |= FIFO_RXTHRESHOLD;
3261         rtpr = 2;
3262
3263 /*
3264  *      Calculate the baud rate timers. For now we will just assume that
3265  *      the input and output baud are the same. Could have used a baud
3266  *      table here, but this way we can generate virtually any baud rate
3267  *      we like!
3268  */
3269         if (tiosp->c_ispeed == 0)
3270                 tiosp->c_ispeed = tiosp->c_ospeed;
3271         if ((tiosp->c_ospeed < 0) || (tiosp->c_ospeed > CD1400_MAXBAUD))
3272                 return(EINVAL);
3273
3274         if (tiosp->c_ospeed > 0) {
3275                 for (clk = 0; (clk < CD1400_NUMCLKS); clk++) {
3276                         clkdiv = ((portp->clk / stl_cd1400clkdivs[clk]) /
3277                                 tiosp->c_ospeed);
3278                         if (clkdiv < 0x100)
3279                                 break;
3280                 }
3281                 div = (unsigned char) clkdiv;
3282         }
3283
3284 /*
3285  *      Check what form of modem signaling is required and set it up.
3286  */
3287         if ((tiosp->c_cflag & CLOCAL) == 0) {
3288                 mcor1 |= MCOR1_DCD;
3289                 mcor2 |= MCOR2_DCD;
3290                 sreron |= SRER_MODEM;
3291         }
3292
3293 /*
3294  *      Setup cd1400 enhanced modes if we can. In particular we want to
3295  *      handle as much of the flow control as possbile automatically. As
3296  *      well as saving a few CPU cycles it will also greatly improve flow
3297  *      control reliablilty.
3298  */
3299         if (tiosp->c_iflag & IXON) {
3300                 cor2 |= COR2_TXIBE;
3301                 cor3 |= COR3_SCD12;
3302                 if (tiosp->c_iflag & IXANY)
3303                         cor2 |= COR2_IXM;
3304         }
3305
3306         if (tiosp->c_cflag & CCTS_OFLOW)
3307                 cor2 |= COR2_CTSAE;
3308         if (tiosp->c_cflag & CRTS_IFLOW)
3309                 mcor1 |= FIFO_RTSTHRESHOLD;
3310
3311 /*
3312  *      All cd1400 register values calculated so go through and set them
3313  *      all up.
3314  */
3315 #if STLDEBUG
3316         printf("SETPORT: portnr=%d panelnr=%d brdnr=%d\n", portp->portnr,
3317                 portp->panelnr, portp->brdnr);
3318         printf("    cor1=%x cor2=%x cor3=%x cor4=%x cor5=%x\n", cor1, cor2,
3319                 cor3, cor4, cor5);
3320         printf("    mcor1=%x mcor2=%x rtpr=%x sreron=%x sreroff=%x\n",
3321                 mcor1, mcor2, rtpr, sreron, sreroff);
3322         printf("    tcor=%x tbpr=%x rcor=%x rbpr=%x\n", clk, div, clk, div);
3323         printf("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
3324                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP], tiosp->c_cc[VSTART],
3325                 tiosp->c_cc[VSTOP]);
3326 #endif
3327
3328         x = spltty();
3329         BRDENABLE(portp->brdnr, portp->pagenr);
3330         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3331         srer = stl_cd1400getreg(portp, SRER);
3332         stl_cd1400setreg(portp, SRER, 0);
3333         ccr += stl_cd1400updatereg(portp, COR1, cor1);
3334         ccr += stl_cd1400updatereg(portp, COR2, cor2);
3335         ccr += stl_cd1400updatereg(portp, COR3, cor3);
3336         if (ccr) {
3337                 stl_cd1400ccrwait(portp);
3338                 stl_cd1400setreg(portp, CCR, CCR_CORCHANGE);
3339         }
3340         stl_cd1400setreg(portp, COR4, cor4);
3341         stl_cd1400setreg(portp, COR5, cor5);
3342         stl_cd1400setreg(portp, MCOR1, mcor1);
3343         stl_cd1400setreg(portp, MCOR2, mcor2);
3344         if (tiosp->c_ospeed == 0) {
3345                 stl_cd1400setreg(portp, MSVR1, 0);
3346         } else {
3347                 stl_cd1400setreg(portp, MSVR1, MSVR1_DTR);
3348                 stl_cd1400setreg(portp, TCOR, clk);
3349                 stl_cd1400setreg(portp, TBPR, div);
3350                 stl_cd1400setreg(portp, RCOR, clk);
3351                 stl_cd1400setreg(portp, RBPR, div);
3352         }
3353         stl_cd1400setreg(portp, SCHR1, tiosp->c_cc[VSTART]);
3354         stl_cd1400setreg(portp, SCHR2, tiosp->c_cc[VSTOP]);
3355         stl_cd1400setreg(portp, SCHR3, tiosp->c_cc[VSTART]);
3356         stl_cd1400setreg(portp, SCHR4, tiosp->c_cc[VSTOP]);
3357         stl_cd1400setreg(portp, RTPR, rtpr);
3358         mcor1 = stl_cd1400getreg(portp, MSVR1);
3359         if (mcor1 & MSVR1_DCD)
3360                 portp->sigs |= TIOCM_CD;
3361         else
3362                 portp->sigs &= ~TIOCM_CD;
3363         stl_cd1400setreg(portp, SRER, ((srer & ~sreroff) | sreron));
3364         BRDDISABLE(portp->brdnr);
3365         portp->state &= ~(ASY_RTSFLOWMODE | ASY_CTSFLOWMODE);
3366         portp->state |= ((tiosp->c_cflag & CRTS_IFLOW) ? ASY_RTSFLOWMODE : 0);
3367         portp->state |= ((tiosp->c_cflag & CCTS_OFLOW) ? ASY_CTSFLOWMODE : 0);
3368         stl_ttyoptim(portp, tiosp);
3369         splx(x);
3370
3371         return(0);
3372 }
3373
3374 /*****************************************************************************/
3375
3376 /*
3377  *      Action the flow control as required. The hw and sw args inform the
3378  *      routine what flow control methods it should try.
3379  */
3380
3381 static void stl_cd1400sendflow(stlport_t *portp, int hw, int sw)
3382 {
3383         int     x;
3384
3385 #if STLDEBUG
3386         printf("stl_cd1400sendflow(portp=%x,hw=%d,sw=%d)\n",
3387                 (int) portp, hw, sw);
3388 #endif
3389
3390         x = spltty();
3391         BRDENABLE(portp->brdnr, portp->pagenr);
3392         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3393
3394         if (sw >= 0) {
3395                 stl_cd1400ccrwait(portp);
3396                 if (sw) {
3397                         stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2);
3398                         portp->stats.rxxoff++;
3399                 } else {
3400                         stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1);
3401                         portp->stats.rxxon++;
3402                 }
3403                 stl_cd1400ccrwait(portp);
3404         }
3405
3406         if (hw == 0) {
3407                 portp->state |= ASY_RTSFLOW;
3408                 stl_cd1400setreg(portp, MCOR1,
3409                         (stl_cd1400getreg(portp, MCOR1) & 0xf0));
3410                 stl_cd1400setreg(portp, MSVR2, 0);
3411                 portp->stats.rxrtsoff++;
3412         } else if (hw > 0) {
3413                 portp->state &= ~ASY_RTSFLOW;
3414                 stl_cd1400setreg(portp, MSVR2, MSVR2_RTS);
3415                 stl_cd1400setreg(portp, MCOR1,
3416                         (stl_cd1400getreg(portp, MCOR1) | FIFO_RTSTHRESHOLD));
3417                 portp->stats.rxrtson++;
3418         }
3419
3420         BRDDISABLE(portp->brdnr);
3421         splx(x);
3422 }
3423
3424 /*****************************************************************************/
3425
3426 /*
3427  *      Return the current state of data flow on this port. This is only
3428  *      really interresting when determining if data has fully completed
3429  *      transmission or not... This is easy for the cd1400, it accurately
3430  *      maintains the busy port flag.
3431  */
3432
3433 static int stl_cd1400datastate(stlport_t *portp)
3434 {
3435 #if STLDEBUG
3436         printf("stl_cd1400datastate(portp=%x)\n", (int) portp);
3437 #endif
3438
3439         if (portp == (stlport_t *) NULL)
3440                 return(0);
3441
3442         return((portp->state & ASY_TXBUSY) ? 1 : 0);
3443 }
3444
3445 /*****************************************************************************/
3446
3447 /*
3448  *      Set the state of the DTR and RTS signals. Got to do some extra
3449  *      work here to deal hardware flow control.
3450  */
3451
3452 static void stl_cd1400setsignals(stlport_t *portp, int dtr, int rts)
3453 {
3454         unsigned char   msvr1, msvr2;
3455         int             x;
3456
3457 #if STLDEBUG
3458         printf("stl_cd1400setsignals(portp=%x,dtr=%d,rts=%d)\n", (int) portp,
3459                 dtr, rts);
3460 #endif
3461
3462         msvr1 = 0;
3463         msvr2 = 0;
3464         if (dtr > 0)
3465                 msvr1 = MSVR1_DTR;
3466         if (rts > 0)
3467                 msvr2 = MSVR2_RTS;
3468
3469         x = spltty();
3470         BRDENABLE(portp->brdnr, portp->pagenr);
3471         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3472         if (rts >= 0) {
3473                 if (portp->tty.t_cflag & CRTS_IFLOW) {
3474                         if (rts == 0) {
3475                                 stl_cd1400setreg(portp, MCOR1,
3476                                       (stl_cd1400getreg(portp, MCOR1) & 0xf0));
3477                                 portp->stats.rxrtsoff++;
3478                         } else {
3479                                 stl_cd1400setreg(portp, MCOR1,
3480                                         (stl_cd1400getreg(portp, MCOR1) |
3481                                         FIFO_RTSTHRESHOLD));
3482                                 portp->stats.rxrtson++;
3483                         }
3484                 }
3485                 stl_cd1400setreg(portp, MSVR2, msvr2);
3486         }
3487         if (dtr >= 0)
3488                 stl_cd1400setreg(portp, MSVR1, msvr1);
3489         BRDDISABLE(portp->brdnr);
3490         splx(x);
3491 }
3492
3493 /*****************************************************************************/
3494
3495 /*
3496  *      Get the state of the signals.
3497  */
3498
3499 static int stl_cd1400getsignals(stlport_t *portp)
3500 {
3501         unsigned char   msvr1, msvr2;
3502         int             sigs, x;
3503
3504 #if STLDEBUG
3505         printf("stl_cd1400getsignals(portp=%x)\n", (int) portp);
3506 #endif
3507
3508         x = spltty();
3509         BRDENABLE(portp->brdnr, portp->pagenr);
3510         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3511         msvr1 = stl_cd1400getreg(portp, MSVR1);
3512         msvr2 = stl_cd1400getreg(portp, MSVR2);
3513         BRDDISABLE(portp->brdnr);
3514         splx(x);
3515
3516         sigs = 0;
3517         sigs |= (msvr1 & MSVR1_DCD) ? TIOCM_CD : 0;
3518         sigs |= (msvr1 & MSVR1_CTS) ? TIOCM_CTS : 0;
3519         sigs |= (msvr1 & MSVR1_DTR) ? TIOCM_DTR : 0;
3520         sigs |= (msvr2 & MSVR2_RTS) ? TIOCM_RTS : 0;
3521 #if 0
3522         sigs |= (msvr1 & MSVR1_RI) ? TIOCM_RI : 0;
3523         sigs |= (msvr1 & MSVR1_DSR) ? TIOCM_DSR : 0;
3524 #else
3525         sigs |= TIOCM_DSR;
3526 #endif
3527         return(sigs);
3528 }
3529
3530 /*****************************************************************************/
3531
3532 /*
3533  *      Enable or disable the Transmitter and/or Receiver.
3534  */
3535
3536 static void stl_cd1400enablerxtx(stlport_t *portp, int rx, int tx)
3537 {
3538         unsigned char   ccr;
3539         int             x;
3540
3541 #if STLDEBUG
3542         printf("stl_cd1400enablerxtx(portp=%x,rx=%d,tx=%d)\n",
3543                 (int) portp, rx, tx);
3544 #endif
3545
3546         ccr = 0;
3547         if (tx == 0)
3548                 ccr |= CCR_TXDISABLE;
3549         else if (tx > 0)
3550                 ccr |= CCR_TXENABLE;
3551         if (rx == 0)
3552                 ccr |= CCR_RXDISABLE;
3553         else if (rx > 0)
3554                 ccr |= CCR_RXENABLE;
3555
3556         x = spltty();
3557         BRDENABLE(portp->brdnr, portp->pagenr);
3558         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3559         stl_cd1400ccrwait(portp);
3560         stl_cd1400setreg(portp, CCR, ccr);
3561         stl_cd1400ccrwait(portp);
3562         BRDDISABLE(portp->brdnr);
3563         splx(x);
3564 }
3565
3566 /*****************************************************************************/
3567
3568 /*
3569  *      Start or stop the Transmitter and/or Receiver.
3570  */
3571
3572 static void stl_cd1400startrxtx(stlport_t *portp, int rx, int tx)
3573 {
3574         unsigned char   sreron, sreroff;
3575         int             x;
3576
3577 #if STLDEBUG
3578         printf("stl_cd1400startrxtx(portp=%x,rx=%d,tx=%d)\n",
3579                 (int) portp, rx, tx);
3580 #endif
3581
3582         sreron = 0;
3583         sreroff = 0;
3584         if (tx == 0)
3585                 sreroff |= (SRER_TXDATA | SRER_TXEMPTY);
3586         else if (tx == 1)
3587                 sreron |= SRER_TXDATA;
3588         else if (tx >= 2)
3589                 sreron |= SRER_TXEMPTY;
3590         if (rx == 0)
3591                 sreroff |= SRER_RXDATA;
3592         else if (rx > 0)
3593                 sreron |= SRER_RXDATA;
3594
3595         x = spltty();
3596         BRDENABLE(portp->brdnr, portp->pagenr);
3597         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3598         stl_cd1400setreg(portp, SRER,
3599                 ((stl_cd1400getreg(portp, SRER) & ~sreroff) | sreron));
3600         BRDDISABLE(portp->brdnr);
3601         if (tx > 0) {
3602                 portp->state |= ASY_TXBUSY;
3603                 portp->tty.t_state |= TS_BUSY;
3604         }
3605         splx(x);
3606 }
3607
3608 /*****************************************************************************/
3609
3610 /*
3611  *      Disable all interrupts from this port.
3612  */
3613
3614 static void stl_cd1400disableintrs(stlport_t *portp)
3615 {
3616         int     x;
3617
3618 #if STLDEBUG
3619         printf("stl_cd1400disableintrs(portp=%x)\n", (int) portp);
3620 #endif
3621
3622         x = spltty();
3623         BRDENABLE(portp->brdnr, portp->pagenr);
3624         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3625         stl_cd1400setreg(portp, SRER, 0);
3626         BRDDISABLE(portp->brdnr);
3627         splx(x);
3628 }
3629
3630 /*****************************************************************************/
3631
3632 static void stl_cd1400sendbreak(stlport_t *portp, long len)
3633 {
3634         int     x;
3635
3636 #if STLDEBUG
3637         printf("stl_cd1400sendbreak(portp=%x,len=%d)\n", (int) portp,
3638                 (int) len);
3639 #endif
3640
3641         x = spltty();
3642         BRDENABLE(portp->brdnr, portp->pagenr);
3643         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3644         stl_cd1400setreg(portp, COR2,
3645                 (stl_cd1400getreg(portp, COR2) | COR2_ETC));
3646         stl_cd1400setreg(portp, SRER,
3647                 ((stl_cd1400getreg(portp, SRER) & ~SRER_TXDATA) |
3648                 SRER_TXEMPTY));
3649         BRDDISABLE(portp->brdnr);
3650         if (len > 0) {
3651                 len = len / 5;
3652                 portp->brklen = (len > 255) ? 255 : len;
3653         } else {
3654                 portp->brklen = len;
3655         }
3656         splx(x);
3657         portp->stats.txbreaks++;
3658 }
3659
3660 /*****************************************************************************/
3661
3662 /*
3663  *      Try and find and initialize all the ports on a panel. We don't care
3664  *      what sort of board these ports are on - since the port io registers
3665  *      are almost identical when dealing with ports.
3666  */
3667
3668 static void stl_cd1400portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp)
3669 {
3670 #if STLDEBUG
3671         printf("stl_cd1400portinit(brdp=%x,panelp=%x,portp=%x)\n",
3672                 (int) brdp, (int) panelp, (int) portp);
3673 #endif
3674
3675         if ((brdp == (stlbrd_t *) NULL) || (panelp == (stlpanel_t *) NULL) ||
3676             (portp == (stlport_t *) NULL))
3677                 return;
3678
3679         portp->ioaddr = panelp->iobase + (((brdp->brdtype == BRD_ECHPCI) ||
3680                 (portp->portnr < 8)) ? 0 : EREG_BANKSIZE);
3681         portp->uartaddr = (portp->portnr & 0x04) << 5;
3682         portp->pagenr = panelp->pagenr + (portp->portnr >> 3);
3683
3684         BRDENABLE(portp->brdnr, portp->pagenr);
3685         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3686         stl_cd1400setreg(portp, LIVR, (portp->portnr << 3));
3687         portp->hwid = stl_cd1400getreg(portp, GFRCR);
3688         BRDDISABLE(portp->brdnr);
3689 }
3690
3691 /*****************************************************************************/
3692
3693 /*
3694  *      Inbitialize the UARTs in a panel. We don't care what sort of board
3695  *      these ports are on - since the port io registers are almost
3696  *      identical when dealing with ports.
3697  */
3698
3699 static int stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
3700 {
3701         unsigned int    gfrcr;
3702         int             chipmask, i, j;
3703         int             nrchips, uartaddr, ioaddr;
3704
3705 #if STLDEBUG
3706         printf("stl_cd1400panelinit(brdp=%x,panelp=%x)\n", (int) brdp,
3707                 (int) panelp);
3708 #endif
3709
3710         BRDENABLE(panelp->brdnr, panelp->pagenr);
3711
3712 /*
3713  *      Check that each chip is present and started up OK.
3714  */
3715         chipmask = 0;
3716         nrchips = panelp->nrports / CD1400_PORTS;
3717         for (i = 0; (i < nrchips); i++) {
3718                 if (brdp->brdtype == BRD_ECHPCI) {
3719                         outb((panelp->pagenr + (i >> 1)), brdp->ioctrl);
3720                         ioaddr = panelp->iobase;
3721                 } else {
3722                         ioaddr = panelp->iobase + (EREG_BANKSIZE * (i >> 1));
3723                 }
3724                 uartaddr = (i & 0x01) ? 0x080 : 0;
3725                 outb(ioaddr, (GFRCR + uartaddr));
3726                 outb((ioaddr + EREG_DATA), 0);
3727                 outb(ioaddr, (CCR + uartaddr));
3728                 outb((ioaddr + EREG_DATA), CCR_RESETFULL);
3729                 outb((ioaddr + EREG_DATA), CCR_RESETFULL);
3730                 outb(ioaddr, (GFRCR + uartaddr));
3731                 for (j = 0; (j < CCR_MAXWAIT); j++) {
3732                         if ((gfrcr = inb(ioaddr + EREG_DATA)) != 0)
3733                                 break;
3734                 }
3735                 if ((j >= CCR_MAXWAIT) || (gfrcr < 0x40) || (gfrcr > 0x60)) {
3736                         printf("STALLION: cd1400 not responding, "
3737                                 "board=%d panel=%d chip=%d\n", panelp->brdnr,
3738                                 panelp->panelnr, i);
3739                         continue;
3740                 }
3741                 chipmask |= (0x1 << i);
3742                 outb(ioaddr, (PPR + uartaddr));
3743                 outb((ioaddr + EREG_DATA), PPR_SCALAR);
3744         }
3745
3746
3747         BRDDISABLE(panelp->brdnr);
3748         return(chipmask);
3749 }
3750
3751 /*****************************************************************************/
3752 /*                      SC26198 HARDWARE FUNCTIONS                           */
3753 /*****************************************************************************/
3754
3755 /*
3756  *      These functions get/set/update the registers of the sc26198 UARTs.
3757  *      Access to the sc26198 registers is via an address/data io port pair.
3758  *      (Maybe should make this inline...)
3759  */
3760
3761 static int stl_sc26198getreg(stlport_t *portp, int regnr)
3762 {
3763         outb((portp->ioaddr + XP_ADDR), (regnr | portp->uartaddr));
3764         return(inb(portp->ioaddr + XP_DATA));
3765 }
3766
3767 static void stl_sc26198setreg(stlport_t *portp, int regnr, int value)
3768 {
3769         outb((portp->ioaddr + XP_ADDR), (regnr | portp->uartaddr));
3770         outb((portp->ioaddr + XP_DATA), value);
3771 }
3772
3773 static int stl_sc26198updatereg(stlport_t *portp, int regnr, int value)
3774 {
3775         outb((portp->ioaddr + XP_ADDR), (regnr | portp->uartaddr));
3776         if (inb(portp->ioaddr + XP_DATA) != value) {
3777                 outb((portp->ioaddr + XP_DATA), value);
3778                 return(1);
3779         }
3780         return(0);
3781 }
3782
3783 /*****************************************************************************/
3784
3785 /*
3786  *      Functions to get and set the sc26198 global registers.
3787  */
3788
3789 static int stl_sc26198getglobreg(stlport_t *portp, int regnr)
3790 {
3791         outb((portp->ioaddr + XP_ADDR), regnr);
3792         return(inb(portp->ioaddr + XP_DATA));
3793 }
3794
3795 #if 0
3796 static void stl_sc26198setglobreg(stlport_t *portp, int regnr, int value)
3797 {
3798         outb((portp->ioaddr + XP_ADDR), regnr);
3799         outb((portp->ioaddr + XP_DATA), value);
3800 }
3801 #endif
3802
3803 /*****************************************************************************/
3804
3805 /*
3806  *      Inbitialize the UARTs in a panel. We don't care what sort of board
3807  *      these ports are on - since the port io registers are almost
3808  *      identical when dealing with ports.
3809  */
3810
3811 static int stl_sc26198panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
3812 {
3813         int     chipmask, i;
3814         int     nrchips, ioaddr;
3815
3816 #if STLDEBUG
3817         printf("stl_sc26198panelinit(brdp=%x,panelp=%x)\n", (int) brdp,
3818                 (int) panelp);
3819 #endif
3820
3821         BRDENABLE(panelp->brdnr, panelp->pagenr);
3822
3823 /*
3824  *      Check that each chip is present and started up OK.
3825  */
3826         chipmask = 0;
3827         nrchips = (panelp->nrports + 4) / SC26198_PORTS;
3828         if (brdp->brdtype == BRD_ECHPCI)
3829                 outb(brdp->ioctrl, panelp->pagenr);
3830
3831         for (i = 0; (i < nrchips); i++) {
3832                 ioaddr = panelp->iobase + (i * 4); 
3833                 outb((ioaddr + XP_ADDR), SCCR);
3834                 outb((ioaddr + XP_DATA), CR_RESETALL);
3835                 outb((ioaddr + XP_ADDR), TSTR);
3836                 if (inb(ioaddr + XP_DATA) != 0) {
3837                         printf("STALLION: sc26198 not responding, "
3838                                 "board=%d panel=%d chip=%d\n", panelp->brdnr,
3839                                 panelp->panelnr, i);
3840                         continue;
3841                 }
3842                 chipmask |= (0x1 << i);
3843                 outb((ioaddr + XP_ADDR), GCCR);
3844                 outb((ioaddr + XP_DATA), GCCR_IVRTYPCHANACK);
3845                 outb((ioaddr + XP_ADDR), WDTRCR);
3846                 outb((ioaddr + XP_DATA), 0xff);
3847         }
3848
3849         BRDDISABLE(panelp->brdnr);
3850         return(chipmask);
3851 }
3852
3853 /*****************************************************************************/
3854
3855 /*
3856  *      Initialize hardware specific port registers.
3857  */
3858
3859 static void stl_sc26198portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp)
3860 {
3861 #if STLDEBUG
3862         printf("stl_sc26198portinit(brdp=%x,panelp=%x,portp=%x)\n",
3863                 (int) brdp, (int) panelp, (int) portp);
3864 #endif
3865
3866         if ((brdp == (stlbrd_t *) NULL) || (panelp == (stlpanel_t *) NULL) ||
3867             (portp == (stlport_t *) NULL))
3868                 return;
3869
3870         portp->ioaddr = panelp->iobase + ((portp->portnr < 8) ? 0 : 4);
3871         portp->uartaddr = (portp->portnr & 0x07) << 4;
3872         portp->pagenr = panelp->pagenr;
3873         portp->hwid = 0x1;
3874
3875         BRDENABLE(portp->brdnr, portp->pagenr);
3876         stl_sc26198setreg(portp, IOPCR, IOPCR_SETSIGS);
3877         BRDDISABLE(portp->brdnr);
3878 }
3879
3880 /*****************************************************************************/
3881
3882 /*
3883  *      Set up the sc26198 registers for a port based on the termios port
3884  *      settings.
3885  */
3886
3887 static int stl_sc26198setport(stlport_t *portp, struct termios *tiosp)
3888 {
3889         unsigned char   mr0, mr1, mr2, clk;
3890         unsigned char   imron, imroff, iopr, ipr;
3891         int             x;
3892
3893 #if STLDEBUG
3894         printf("stl_sc26198setport(portp=%x,tiosp=%x): brdnr=%d portnr=%d\n",
3895                 (int) portp, (int) tiosp, portp->brdnr, portp->portnr);
3896 #endif
3897
3898         mr0 = 0;
3899         mr1 = 0;
3900         mr2 = 0;
3901         clk = 0;
3902         iopr = 0;
3903         imron = 0;
3904         imroff = 0;
3905
3906 /*
3907  *      Set up the RX char ignore mask with those RX error types we
3908  *      can ignore.
3909  */
3910         portp->rxignoremsk = 0;
3911         if (tiosp->c_iflag & IGNPAR)
3912                 portp->rxignoremsk |= (SR_RXPARITY | SR_RXFRAMING |
3913                         SR_RXOVERRUN);
3914         if (tiosp->c_iflag & IGNBRK)
3915                 portp->rxignoremsk |= SR_RXBREAK;
3916
3917         portp->rxmarkmsk = SR_RXOVERRUN;
3918         if (tiosp->c_iflag & (INPCK | PARMRK))
3919                 portp->rxmarkmsk |= (SR_RXPARITY | SR_RXFRAMING);
3920         if (tiosp->c_iflag & BRKINT)
3921                 portp->rxmarkmsk |= SR_RXBREAK;
3922
3923 /*
3924  *      Go through the char size, parity and stop bits and set all the
3925  *      option registers appropriately.
3926  */
3927         switch (tiosp->c_cflag & CSIZE) {
3928         case CS5:
3929                 mr1 |= MR1_CS5;
3930                 break;
3931         case CS6:
3932                 mr1 |= MR1_CS6;
3933                 break;
3934         case CS7:
3935                 mr1 |= MR1_CS7;
3936                 break;
3937         default:
3938                 mr1 |= MR1_CS8;
3939                 break;
3940         }
3941
3942         if (tiosp->c_cflag & CSTOPB)
3943                 mr2 |= MR2_STOP2;
3944         else
3945                 mr2 |= MR2_STOP1;
3946
3947         if (tiosp->c_cflag & PARENB) {
3948                 if (tiosp->c_cflag & PARODD)
3949                         mr1 |= (MR1_PARENB | MR1_PARODD);
3950                 else
3951                         mr1 |= (MR1_PARENB | MR1_PAREVEN);
3952         } else {
3953                 mr1 |= MR1_PARNONE;
3954         }
3955
3956         mr1 |= MR1_ERRBLOCK;
3957
3958 /*
3959  *      Set the RX FIFO threshold at 8 chars. This gives a bit of breathing
3960  *      space for hardware flow control and the like. This should be set to
3961  *      VMIN.
3962  */
3963         mr2 |= MR2_RXFIFOHALF;
3964
3965 /*
3966  *      Calculate the baud rate timers. For now we will just assume that
3967  *      the input and output baud are the same. The sc26198 has a fixed
3968  *      baud rate table, so only discrete baud rates possible.
3969  */
3970         if (tiosp->c_ispeed == 0)
3971                 tiosp->c_ispeed = tiosp->c_ospeed;
3972         if ((tiosp->c_ospeed < 0) || (tiosp->c_ospeed > SC26198_MAXBAUD))
3973                 return(EINVAL);
3974
3975         if (tiosp->c_ospeed > 0) {
3976                 for (clk = 0; (clk < SC26198_NRBAUDS); clk++) {
3977                         if (tiosp->c_ospeed <= sc26198_baudtable[clk])
3978                                 break;
3979                 }
3980         }
3981
3982 /*
3983  *      Check what form of modem signaling is required and set it up.
3984  */
3985         if ((tiosp->c_cflag & CLOCAL) == 0) {
3986                 iopr |= IOPR_DCDCOS;
3987                 imron |= IR_IOPORT;
3988         }
3989
3990 /*
3991  *      Setup sc26198 enhanced modes if we can. In particular we want to
3992  *      handle as much of the flow control as possible automatically. As
3993  *      well as saving a few CPU cycles it will also greatly improve flow
3994  *      control reliability.
3995  */
3996         if (tiosp->c_iflag & IXON) {
3997                 mr0 |= MR0_SWFTX | MR0_SWFT;
3998                 imron |= IR_XONXOFF;
3999         } else {
4000                 imroff |= IR_XONXOFF;
4001         }
4002 #if 0
4003         if (tiosp->c_iflag & IXOFF)
4004                 mr0 |= MR0_SWFRX;
4005 #endif
4006
4007         if (tiosp->c_cflag & CCTS_OFLOW)
4008                 mr2 |= MR2_AUTOCTS;
4009         if (tiosp->c_cflag & CRTS_IFLOW)
4010                 mr1 |= MR1_AUTORTS;
4011
4012 /*
4013  *      All sc26198 register values calculated so go through and set
4014  *      them all up.
4015  */
4016
4017 #if STLDEBUG
4018         printf("SETPORT: portnr=%d panelnr=%d brdnr=%d\n", portp->portnr,
4019                 portp->panelnr, portp->brdnr);
4020         printf("    mr0=%x mr1=%x mr2=%x clk=%x\n", mr0, mr1, mr2, clk);
4021         printf("    iopr=%x imron=%x imroff=%x\n", iopr, imron, imroff);
4022         printf("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
4023                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP],
4024                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
4025 #endif
4026
4027         x = spltty();
4028         BRDENABLE(portp->brdnr, portp->pagenr);
4029         stl_sc26198setreg(portp, IMR, 0);
4030         stl_sc26198updatereg(portp, MR0, mr0);
4031         stl_sc26198updatereg(portp, MR1, mr1);
4032         stl_sc26198setreg(portp, SCCR, CR_RXERRBLOCK);
4033         stl_sc26198updatereg(portp, MR2, mr2);
4034         iopr = (stl_sc26198getreg(portp, IOPIOR) & ~IPR_CHANGEMASK) | iopr;
4035         if (tiosp->c_ospeed == 0) {
4036                 iopr &= ~IPR_DTR;
4037         } else {
4038                 iopr |= IPR_DTR;
4039                 stl_sc26198setreg(portp, TXCSR, clk);