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