projects / dragonfly.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | history | HEAD
DEVFS - remove dev_ops_add(), dev_ops_get(), and get_dev()
[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
MD		 752static struct dev_ops stl_ops = {
753 { "stl", CDEV_MAJOR, D_TTY | D_KQFILTER },
754 .d_open = stlopen,
755 .d_close = stlclose,
756 .d_read = ttyread,
757 .d_write = ttywrite,
758 .d_ioctl = stlioctl,
759 .d_poll = ttypoll,
a32446b7
MD		 760 .d_kqfilter = ttykqfilter,
761 .d_revoke = ttyrevoke
984263bc
MD		 762};
763
764static void stl_drvinit(void *unused)
765{
984263bc
MD		 766}
767
768SYSINIT(sidev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,stl_drvinit,NULL)
769
770#endif
771
772/*****************************************************************************/
773
774/*
775 * Probe for some type of EasyIO or EasyConnection 8/32 board at
776 * the supplied address. All we do is check if we can find the
777 * board ID for the board... (Note, PCI boards not checked here,
778 * they are done in the stlpciprobe() routine).
779 */
780
781static int stlprobe(struct isa_device *idp)
782{
783 unsigned int status;
784
785#if STLDEBUG
e3869ec7 786 kprintf("stlprobe(idp=%x): unit=%d iobase=%x\n", (int) idp,
984263bc
MD		 787 idp->id_unit, idp->id_iobase);
788#endif
789
790 if (idp->id_unit > STL_MAXBRDS)
791 return(0);
792
793 status = inb(idp->id_iobase + 1);
794 if ((status & ECH_IDBITMASK) == ECH_ID) {
795 stl_brdprobed[idp->id_unit] = BRD_ECH;
796 return(1);
797 }
798
799 status = inb(idp->id_iobase + 2);
800 switch (status & EIO_IDBITMASK) {
801 case EIO_8PORTRS:
802 case EIO_8PORTM:
803 case EIO_8PORTDI:
804 case EIO_4PORTRS:
805 case EIO_MK3:
806 stl_brdprobed[idp->id_unit] = BRD_EASYIO;
807 return(1);
808 default:
809 break;
810 }
811
812 return(0);
813}
814
815/*****************************************************************************/
816
817/*
818 * Find an available internal board number (unit number). The problem
819 * is that the same unit numbers can be assigned to different boards
820 * detected during the ISA and PCI initialization phases.
821 */
822
ce63e0fa 823static int stl_findfreeunit(void)
984263bc
MD		 824{
825 int i;
826
827 for (i = 0; (i < STL_MAXBRDS); i++)
2038fb68 828 if (stl_brds[i] == NULL)
984263bc
MD		 829 break;
830 return((i >= STL_MAXBRDS) ? -1 : i);
831}
832
833/*****************************************************************************/
834
835/*
836 * Allocate resources for and initialize the specified board.
837 */
838
839static int stlattach(struct isa_device *idp)
840{
841 stlbrd_t *brdp;
842 int boardnr, portnr, minor_dev;
843
844#if STLDEBUG
e3869ec7 845 kprintf("stlattach(idp=%p): unit=%d iobase=%x\n", (void *) idp,
984263bc
MD		 846 idp->id_unit, idp->id_iobase);
847#endif
848
1b51b0fa 849/* idp->id_intr = (inthand2_t *)stlintr; */
984263bc 850
efda3bd0 851 brdp = kmalloc(sizeof(stlbrd_t), M_TTYS, M_WAITOK | M_ZERO);
984263bc
MD		 852
853 if ((brdp->brdnr = stl_findfreeunit()) < 0) {
e3869ec7 854 kprintf("STALLION: too many boards found, max=%d\n",
984263bc
MD		 855 STL_MAXBRDS);
856 return(0);
857 }
858 if (brdp->brdnr >= stl_nrbrds)
859 stl_nrbrds = brdp->brdnr + 1;
860
861 brdp->unitid = idp->id_unit;
862 brdp->brdtype = stl_brdprobed[idp->id_unit];
863 brdp->ioaddr1 = idp->id_iobase;
864 brdp->ioaddr2 = stl_ioshared;
865 brdp->irq = ffs(idp->id_irq) - 1;
866 brdp->irqtype = stl_irqshared;
867 stl_brdinit(brdp);
868
869 /* register devices for DEVFS */
870 boardnr = brdp->brdnr;
fef8985e 871 make_dev(&stl_ops, boardnr + 0x1000000, UID_ROOT, GID_WHEEL,
984263bc
MD		 872 0600, "staliomem%d", boardnr);
873
874 for (portnr = 0, minor_dev = boardnr * 0x100000;
875 portnr < 32; portnr++, minor_dev++) {
876 /* hw ports */
fef8985e 877 make_dev(&stl_ops, minor_dev,
984263bc
MD		 878 UID_ROOT, GID_WHEEL, 0600,
879 "ttyE%d", portnr + (boardnr * 64));
fef8985e 880 make_dev(&stl_ops, minor_dev + 32,
984263bc
MD		 881 UID_ROOT, GID_WHEEL, 0600,
882 "ttyiE%d", portnr + (boardnr * 64));
fef8985e 883 make_dev(&stl_ops, minor_dev + 64,
984263bc
MD		 884 UID_ROOT, GID_WHEEL, 0600,
885 "ttylE%d", portnr + (boardnr * 64));
fef8985e 886 make_dev(&stl_ops, minor_dev + 128,
984263bc
MD		 887 UID_ROOT, GID_WHEEL, 0600,
888 "cue%d", portnr + (boardnr * 64));
fef8985e 889 make_dev(&stl_ops, minor_dev + 160,
984263bc
MD		 890 UID_ROOT, GID_WHEEL, 0600,
891 "cuie%d", portnr + (boardnr * 64));
fef8985e 892 make_dev(&stl_ops, minor_dev + 192,
984263bc
MD		 893 UID_ROOT, GID_WHEEL, 0600,
894 "cule%d", portnr + (boardnr * 64));
895
896 /* sw ports */
fef8985e 897 make_dev(&stl_ops, minor_dev + 0x10000,
984263bc
MD		 898 UID_ROOT, GID_WHEEL, 0600,
899 "ttyE%d", portnr + (boardnr * 64) + 32);
fef8985e 900 make_dev(&stl_ops, minor_dev + 32 + 0x10000,
984263bc
MD		 901 UID_ROOT, GID_WHEEL, 0600,
902 "ttyiE%d", portnr + (boardnr * 64) + 32);
fef8985e 903 make_dev(&stl_ops, minor_dev + 64 + 0x10000,
984263bc
MD		 904 UID_ROOT, GID_WHEEL, 0600,
905 "ttylE%d", portnr + (boardnr * 64) + 32);
fef8985e 906 make_dev(&stl_ops, minor_dev + 128 + 0x10000,
984263bc
MD		 907 UID_ROOT, GID_WHEEL, 0600,
908 "cue%d", portnr + (boardnr * 64) + 32);
fef8985e 909 make_dev(&stl_ops, minor_dev + 160 + 0x10000,
984263bc
MD		 910 UID_ROOT, GID_WHEEL, 0600,
911 "cuie%d", portnr + (boardnr * 64) + 32);
fef8985e 912 make_dev(&stl_ops, minor_dev + 192 + 0x10000,
984263bc
MD		 913 UID_ROOT, GID_WHEEL, 0600,
914 "cule%d", portnr + (boardnr * 64) + 32);
915 }
916 boardnr = brdp->brdnr;
fef8985e 917 make_dev(&stl_ops, boardnr + 0x1000000, UID_ROOT, GID_WHEEL,
984263bc
MD		 918 0600, "staliomem%d", boardnr);
919
920 for (portnr = 0, minor_dev = boardnr * 0x100000;
921 portnr < 32; portnr++, minor_dev++) {
922 /* hw ports */
fef8985e 923 make_dev(&stl_ops, minor_dev,
984263bc
MD		 924 UID_ROOT, GID_WHEEL, 0600,
925 "ttyE%d", portnr + (boardnr * 64));
fef8985e 926 make_dev(&stl_ops, minor_dev + 32,
984263bc
MD		 927 UID_ROOT, GID_WHEEL, 0600,
928 "ttyiE%d", portnr + (boardnr * 64));
fef8985e 929 make_dev(&stl_ops, minor_dev + 64,
984263bc
MD		 930 UID_ROOT, GID_WHEEL, 0600,
931 "ttylE%d", portnr + (boardnr * 64));
fef8985e 932 make_dev(&stl_ops, minor_dev + 128,
984263bc
MD		 933 UID_ROOT, GID_WHEEL, 0600,
934 "cue%d", portnr + (boardnr * 64));
fef8985e 935 make_dev(&stl_ops, minor_dev + 160,
984263bc
MD		 936 UID_ROOT, GID_WHEEL, 0600,
937 "cuie%d", portnr + (boardnr * 64));
fef8985e 938 make_dev(&stl_ops, minor_dev + 192,
984263bc
MD		 939 UID_ROOT, GID_WHEEL, 0600,
940 "cule%d", portnr + (boardnr * 64));
941
942 /* sw ports */
fef8985e 943 make_dev(&stl_ops, minor_dev + 0x10000,
984263bc
MD		 944 UID_ROOT, GID_WHEEL, 0600,
945 "ttyE%d", portnr + (boardnr * 64) + 32);
fef8985e 946 make_dev(&stl_ops, minor_dev + 32 + 0x10000,
984263bc
MD		 947 UID_ROOT, GID_WHEEL, 0600,
948 "ttyiE%d", portnr + (boardnr * 64) + 32);
fef8985e 949 make_dev(&stl_ops, minor_dev + 64 + 0x10000,
984263bc
MD		 950 UID_ROOT, GID_WHEEL, 0600,
951 "ttylE%d", portnr + (boardnr * 64) + 32);
fef8985e 952 make_dev(&stl_ops, minor_dev + 128 + 0x10000,
984263bc
MD		 953 UID_ROOT, GID_WHEEL, 0600,
954 "cue%d", portnr + (boardnr * 64) + 32);
fef8985e 955 make_dev(&stl_ops, minor_dev + 160 + 0x10000,
984263bc
MD		 956 UID_ROOT, GID_WHEEL, 0600,
957 "cuie%d", portnr + (boardnr * 64) + 32);
fef8985e 958 make_dev(&stl_ops, minor_dev + 192 + 0x10000,
984263bc
MD		 959 UID_ROOT, GID_WHEEL, 0600,
960 "cule%d", portnr + (boardnr * 64) + 32);
961 }
962
963 return(1);
964}
965
966/*****************************************************************************/
967
968#if NPCI > 0
969
970/*
971 * Probe specifically for the PCI boards. We need to be a little
972 * carefull here, since it looks sort like a Nat Semi IDE chip...
973 */
974
975static const char *stlpciprobe(pcici_t tag, pcidi_t type)
976{
977 unsigned long class;
978 int i, brdtype;
979
980#if STLDEBUG
e3869ec7 981 kprintf("stlpciprobe(tag=%x,type=%x)\n", (int) &tag, (int) type);
984263bc
MD		 982#endif
983
984 brdtype = 0;
985 for (i = 0; (i < stl_nrpcibrds); i++) {
986 if (((type & 0xffff) == stl_pcibrds[i].vendid) &&
987 (((type >> 16) & 0xffff) == stl_pcibrds[i].devid)) {
988 brdtype = stl_pcibrds[i].brdtype;
989 break;
990 }
991 }
992
993 if (brdtype == 0)
2038fb68 994 return(NULL);
984263bc
MD		 995
996 class = pci_conf_read(tag, PCI_CLASS_REG);
997 if ((class & PCI_CLASS_MASK) == PCI_CLASS_MASS_STORAGE)
2038fb68 998 return(NULL);
984263bc
MD		 999
1000 return(stl_brdnames[brdtype]);
1001}
1002
1003/*****************************************************************************/
1004
1005/*
1006 * Allocate resources for and initialize the specified PCI board.
1007 */
1008
1009void stlpciattach(pcici_t tag, int unit)
1010{
1011 stlbrd_t *brdp;
1012 unsigned int bar[4];
1013 unsigned int id;
1014 int i;
1015 int boardnr, portnr, minor_dev;
1016
1017#if STLDEBUG
e3869ec7 1018 kprintf("stlpciattach(tag=%x,unit=%x)\n", (int) &tag, unit);
984263bc
MD		 1019#endif
1020
efda3bd0 1021 brdp = kmalloc(sizeof(stlbrd_t), M_TTYS, M_WAITOK | M_ZERO);
984263bc
MD		 1022
1023 if ((unit < 0) || (unit > STL_MAXBRDS)) {
e3869ec7 1024 kprintf("STALLION: bad PCI board unit number=%d\n", unit);
984263bc
MD		 1025 return;
1026 }
1027
1028/*
1029 * Allocate us a new driver unique unit number.
1030 */
1031 if ((brdp->brdnr = stl_findfreeunit()) < 0) {
e3869ec7 1032 kprintf("STALLION: too many boards found, max=%d\n",
984263bc
MD		 1033 STL_MAXBRDS);
1034 return;
1035 }
1036 if (brdp->brdnr >= stl_nrbrds)
1037 stl_nrbrds = brdp->brdnr + 1;
1038
1039/*
1040 * Determine what type of PCI board this is...
1041 */
1042 id = (unsigned int) pci_conf_read(tag, 0x0);
1043 for (i = 0; (i < stl_nrpcibrds); i++) {
1044 if (((id & 0xffff) == stl_pcibrds[i].vendid) &&
1045 (((id >> 16) & 0xffff) == stl_pcibrds[i].devid)) {
1046 brdp->brdtype = stl_pcibrds[i].brdtype;
1047 break;
1048 }
1049 }
1050
1051 if (i >= stl_nrpcibrds) {
e3869ec7 1052 kprintf("STALLION: probed PCI board unknown type=%x\n", id);
984263bc
MD		 1053 return;
1054 }
1055
1056 for (i = 0; (i < 4); i++)
1057 bar[i] = (unsigned int) pci_conf_read(tag, 0x10 + (i * 4)) &
1058 0xfffc;
1059
1060 switch (brdp->brdtype) {
1061 case BRD_ECH64PCI:
1062 brdp->ioaddr1 = bar[1];
1063 brdp->ioaddr2 = bar[2];
1064 break;
1065 case BRD_EASYIOPCI:
1066 brdp->ioaddr1 = bar[2];
1067 brdp->ioaddr2 = bar[1];
1068 break;
1069 case BRD_ECHPCI:
1070 brdp->ioaddr1 = bar[1];
1071 brdp->ioaddr2 = bar[0];
1072 break;
1073 default:
e3869ec7 1074 kprintf("STALLION: unknown PCI board type=%d\n", brdp->brdtype);
984263bc
MD		 1075 return;
1076 break;
1077 }
1078
1079 brdp->unitid = brdp->brdnr; /* PCI units auto-assigned */
1080 brdp->irq = ((int) pci_conf_read(tag, 0x3c)) & 0xff;
1081 brdp->irqtype = 0;
3641b7ca 1082 if (pci_map_int(tag, stlpciintr, NULL) == 0) {
e3869ec7 1083 kprintf("STALLION: failed to map interrupt irq=%d for unit=%d\n",
984263bc
MD		 1084 brdp->irq, brdp->brdnr);
1085 return;
1086 }
1087
1088 stl_brdinit(brdp);
1089
1090 /* register devices for DEVFS */
1091 boardnr = brdp->brdnr;
fef8985e 1092 make_dev(&stl_ops, boardnr + 0x1000000, UID_ROOT, GID_WHEEL,
984263bc
MD		 1093 0600, "staliomem%d", boardnr);
1094
1095 for (portnr = 0, minor_dev = boardnr * 0x100000;
1096 portnr < 32; portnr++, minor_dev++) {
1097 /* hw ports */
fef8985e 1098 make_dev(&stl_ops, minor_dev,
984263bc
MD		 1099 UID_ROOT, GID_WHEEL, 0600,
1100 "ttyE%d", portnr + (boardnr * 64));
fef8985e 1101 make_dev(&stl_ops, minor_dev + 32,
984263bc
MD		 1102 UID_ROOT, GID_WHEEL, 0600,
1103 "ttyiE%d", portnr + (boardnr * 64));
fef8985e 1104 make_dev(&stl_ops, minor_dev + 64,
984263bc
MD		 1105 UID_ROOT, GID_WHEEL, 0600,
1106 "ttylE%d", portnr + (boardnr * 64));
fef8985e 1107 make_dev(&stl_ops, minor_dev + 128,
984263bc
MD		 1108 UID_ROOT, GID_WHEEL, 0600,
1109 "cue%d", portnr + (boardnr * 64));
fef8985e 1110 make_dev(&stl_ops, minor_dev + 160,
984263bc
MD		 1111 UID_ROOT, GID_WHEEL, 0600,
1112 "cuie%d", portnr + (boardnr * 64));
fef8985e 1113 make_dev(&stl_ops, minor_dev + 192,
984263bc
MD		 1114 UID_ROOT, GID_WHEEL, 0600,
1115 "cule%d", portnr + (boardnr * 64));
1116
1117 /* sw ports */
fef8985e 1118 make_dev(&stl_ops, minor_dev + 0x10000,
984263bc
MD		 1119 UID_ROOT, GID_WHEEL, 0600,
1120 "ttyE%d", portnr + (boardnr * 64) + 32);
fef8985e 1121 make_dev(&stl_ops, minor_dev + 32 + 0x10000,
984263bc
MD		 1122 UID_ROOT, GID_WHEEL, 0600,
1123 "ttyiE%d", portnr + (boardnr * 64) + 32);
fef8985e 1124 make_dev(&stl_ops, minor_dev + 64 + 0x10000,
984263bc
MD		 1125 UID_ROOT, GID_WHEEL, 0600,
1126 "ttylE%d", portnr + (boardnr * 64) + 32);
fef8985e 1127 make_dev(&stl_ops, minor_dev + 128 + 0x10000,
984263bc
MD		 1128 UID_ROOT, GID_WHEEL, 0600,
1129 "cue%d", portnr + (boardnr * 64) + 32);
fef8985e 1130 make_dev(&stl_ops, minor_dev + 160 + 0x10000,
984263bc
MD		 1131 UID_ROOT, GID_WHEEL, 0600,
1132 "cuie%d", portnr + (boardnr * 64) + 32);
fef8985e 1133 make_dev(&stl_ops, minor_dev + 192 + 0x10000,
984263bc
MD		 1134 UID_ROOT, GID_WHEEL, 0600,
1135 "cule%d", portnr + (boardnr * 64) + 32);
1136 }
1137}
1138
1139#endif
1140
1141/*****************************************************************************/
1142
fef8985e 1143STATIC int stlopen(struct dev_open_args *ap)
984263bc 1144{
b13267a5 1145 cdev_t dev = ap->a_head.a_dev;
984263bc
MD		 1146 struct tty *tp;
1147 stlport_t *portp;
8d77660e 1148 int error, callout;
984263bc
MD		 1149
1150#if STLDEBUG
e3869ec7 1151 kprintf("stlopen(dev=%x,flag=%x,mode=%x,p=%x)\n", (int) dev, flag,
984263bc
MD		 1152 mode, (int) p);
1153#endif
1154
1155/*
1156 * Firstly check if the supplied device number is a valid device.
1157 */
1158 if (minor(dev) & STL_MEMDEV)
1159 return(0);
1160
1161 portp = stl_dev2port(dev);
2038fb68 1162 if (portp == NULL)
984263bc
MD		 1163 return(ENXIO);
1164 if (minor(dev) & STL_CTRLDEV)
1165 return(0);
1166 tp = &portp->tty;
1167 dev->si_tty = tp;
1168 callout = minor(dev) & STL_CALLOUTDEV;
1169 error = 0;
1170
8d77660e 1171 crit_enter();
984263bc
MD		 1172
1173stlopen_restart:
1174/*
1175 * Wait here for the DTR drop timeout period to expire.
1176 */
1177 while (portp->state & ASY_DTRWAIT) {
377d4740 1178 error = tsleep(&portp->dtrwait, PCATCH, "stldtr", 0);
984263bc
MD		 1179 if (error)
1180 goto stlopen_end;
1181 }
1182
1183/*
1184 * We have a valid device, so now we check if it is already open.
1185 * If not then initialize the port hardware and set up the tty
1186 * struct as required.
1187 */
1188 if ((tp->t_state & TS_ISOPEN) == 0) {
1189 tp->t_oproc = stl_start;
1190 tp->t_stop = stl_stop;
1191 tp->t_param = stl_param;
1192 tp->t_dev = dev;
1193 tp->t_termios = callout ? portp->initouttios :
1194 portp->initintios;
1195 stl_rawopen(portp);
1196 ttsetwater(tp);
1197 if ((portp->sigs & TIOCM_CD) || callout)
1198 (*linesw[tp->t_line].l_modem)(tp, 1);
1199 } else {
1200 if (callout) {
1201 if (portp->callout == 0) {
1202 error = EBUSY;
1203 goto stlopen_end;
1204 }
1205 } else {
1206 if (portp->callout != 0) {
fef8985e 1207 if (ap->a_oflags & O_NONBLOCK) {
984263bc
MD		 1208 error = EBUSY;
1209 goto stlopen_end;
1210 }
1211 error = tsleep(&portp->callout,
377d4740 1212 PCATCH, "stlcall", 0);
984263bc
MD		 1213 if (error)
1214 goto stlopen_end;
1215 goto stlopen_restart;
1216 }
1217 }
895c1f85 1218 if ((tp->t_state & TS_XCLUDE) && priv_check_cred(ap->a_cred, PRIV_ROOT, 0)) {
984263bc
MD		 1219 error = EBUSY;
1220 goto stlopen_end;
1221 }
1222 }
1223
1224/*
1225 * If this port is not the callout device and we do not have carrier
1226 * then we need to sleep, waiting for it to be asserted.
1227 */
1228 if (((tp->t_state & TS_CARR_ON) == 0) && !callout &&
1229 ((tp->t_cflag & CLOCAL) == 0) &&
fef8985e 1230 ((ap->a_oflags & O_NONBLOCK) == 0)) {
984263bc 1231 portp->waitopens++;
377d4740 1232 error = tsleep(TSA_CARR_ON(tp), PCATCH, "stldcd", 0);
984263bc
MD		 1233 portp->waitopens--;
1234 if (error)
1235 goto stlopen_end;
1236 goto stlopen_restart;
1237 }
1238
1239/*
1240 * Open the line discipline.
1241 */
1242 error = (*linesw[tp->t_line].l_open)(dev, tp);
1243 stl_ttyoptim(portp, &tp->t_termios);
1244 if ((tp->t_state & TS_ISOPEN) && callout)
1245 portp->callout = 1;
1246
1247/*
1248 * If for any reason we get to here and the port is not actually
1249 * open then close of the physical hardware - no point leaving it
1250 * active when the open failed...
1251 */
1252stlopen_end:
8d77660e 1253 crit_exit();
984263bc
MD		 1254 if (((tp->t_state & TS_ISOPEN) == 0) && (portp->waitopens == 0))
1255 stl_rawclose(portp);
1256
1257 return(error);
1258}
1259
1260/*****************************************************************************/
1261
fef8985e 1262STATIC int stlclose(struct dev_close_args *ap)
984263bc 1263{
b13267a5 1264 cdev_t dev = ap->a_head.a_dev;
984263bc
MD		 1265 struct tty *tp;
1266 stlport_t *portp;
984263bc
MD		 1267
1268#if STLDEBUG
e3869ec7 1269 kprintf("stlclose(dev=%s,flag=%x,mode=%x,p=%p)\n", devtoname(dev),
984263bc
MD		 1270 flag, mode, (void *) p);
1271#endif
1272
1273 if (minor(dev) & STL_MEMDEV)
1274 return(0);
1275 if (minor(dev) & STL_CTRLDEV)
1276 return(0);
1277
1278 portp = stl_dev2port(dev);
2038fb68 1279 if (portp == NULL)
984263bc
MD		 1280 return(ENXIO);
1281 tp = &portp->tty;
1282
8d77660e 1283 crit_enter();
fef8985e 1284 (*linesw[tp->t_line].l_close)(tp, ap->a_fflag);
984263bc
MD		 1285 stl_ttyoptim(portp, &tp->t_termios);
1286 stl_rawclose(portp);
1287 ttyclose(tp);
8d77660e 1288 crit_exit();
984263bc
MD		 1289 return(0);
1290}
1291
1292/*****************************************************************************/
1293
1294#if VFREEBSD >= 220
1295
1296STATIC void stl_stop(struct tty *tp, int rw)
1297{
1298#if STLDEBUG
e3869ec7 1299 kprintf("stl_stop(tp=%x,rw=%x)\n", (int) tp, rw);
984263bc
MD		 1300#endif
1301
1302 stl_flush((stlport_t *) tp, rw);
1303}
1304
1305#else
1306
1307STATIC int stlstop(struct tty *tp, int rw)
1308{
1309#if STLDEBUG
e3869ec7 1310 kprintf("stlstop(tp=%x,rw=%x)\n", (int) tp, rw);
984263bc
MD		 1311#endif
1312
1313 stl_flush((stlport_t *) tp, rw);
1314 return(0);
1315}
1316
1317#endif
1318
1319/*****************************************************************************/
1320
fef8985e 1321STATIC int stlioctl(struct dev_ioctl_args *ap)
984263bc 1322{
b13267a5 1323 cdev_t dev = ap->a_head.a_dev;
fef8985e
MD		 1324 u_long cmd = ap->a_cmd;
1325 caddr_t data = ap->a_data;
984263bc
MD		 1326 struct termios *newtios, *localtios;
1327 struct tty *tp;
1328 stlport_t *portp;
8d77660e 1329 int error, i;
984263bc
MD		 1330
1331#if STLDEBUG
e3869ec7 1332 kprintf("stlioctl(dev=%s,cmd=%lx,data=%p,flag=%x)\n",
fef8985e 1333 devtoname(dev), cmd, (void *) data, ap->a_fflag);
984263bc
MD		 1334#endif
1335
1336 if (minor(dev) & STL_MEMDEV)
fef8985e 1337 return(stl_memioctl(dev, cmd, data, ap->a_fflag));
984263bc
MD		 1338
1339 portp = stl_dev2port(dev);
2038fb68 1340 if (portp == NULL)
984263bc
MD		 1341 return(ENODEV);
1342 tp = &portp->tty;
1343 error = 0;
1344
1345/*
1346 * First up handle ioctls on the control devices.
1347 */
1348 if (minor(dev) & STL_CTRLDEV) {
1349 if ((minor(dev) & STL_CTRLDEV) == STL_CTRLINIT)
1350 localtios = (minor(dev) & STL_CALLOUTDEV) ?
1351 &portp->initouttios : &portp->initintios;
1352 else if ((minor(dev) & STL_CTRLDEV) == STL_CTRLLOCK)
1353 localtios = (minor(dev) & STL_CALLOUTDEV) ?
1354 &portp->lockouttios : &portp->lockintios;
1355 else
1356 return(ENODEV);
1357
1358 switch (cmd) {
1359 case TIOCSETA:
895c1f85 1360 if ((error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0)) == 0)
984263bc
MD		 1361 *localtios = *((struct termios *) data);
1362 break;
1363 case TIOCGETA:
1364 *((struct termios *) data) = *localtios;
1365 break;
1366 case TIOCGETD:
1367 *((int *) data) = TTYDISC;
1368 break;
1369 case TIOCGWINSZ:
1370 bzero(data, sizeof(struct winsize));
1371 break;
1372 default:
1373 error = ENOTTY;
1374 break;
1375 }
1376 return(error);
1377 }
1378
1379/*
9a7c6212 1380 * Deal with 4.3 compatibility issues if we have too...
984263bc
MD		 1381 */
1382#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1383 if (1) {
1384 struct termios tios;
1385 unsigned long oldcmd;
1386
1387 tios = tp->t_termios;
1388 oldcmd = cmd;
1389 if ((error = ttsetcompat(tp, &cmd, data, &tios)))
1390 return(error);
1391 if (cmd != oldcmd)
1392 data = (caddr_t) &tios;
1393 }
1394#endif
1395
1396/*
1397 * Carry out some pre-cmd processing work first...
1398 * Hmmm, not so sure we want this, disable for now...
1399 */
1400 if ((cmd == TIOCSETA) || (cmd == TIOCSETAW) || (cmd == TIOCSETAF)) {
1401 newtios = (struct termios *) data;
1402 localtios = (minor(dev) & STL_CALLOUTDEV) ?
1403 &portp->lockouttios : &portp->lockintios;
1404
1405 newtios->c_iflag = (tp->t_iflag & localtios->c_iflag) |
1406 (newtios->c_iflag & ~localtios->c_iflag);
1407 newtios->c_oflag = (tp->t_oflag & localtios->c_oflag) |
1408 (newtios->c_oflag & ~localtios->c_oflag);
1409 newtios->c_cflag = (tp->t_cflag & localtios->c_cflag) |
1410 (newtios->c_cflag & ~localtios->c_cflag);
1411 newtios->c_lflag = (tp->t_lflag & localtios->c_lflag) |
1412 (newtios->c_lflag & ~localtios->c_lflag);
1413 for (i = 0; (i < NCCS); i++) {
1414 if (localtios->c_cc[i] != 0)
1415 newtios->c_cc[i] = tp->t_cc[i];
1416 }
1417 if (localtios->c_ispeed != 0)
1418 newtios->c_ispeed = tp->t_ispeed;
1419 if (localtios->c_ospeed != 0)
1420 newtios->c_ospeed = tp->t_ospeed;
1421 }
1422
1423/*
1424 * Call the line discipline and the common command processing to
1425 * process this command (if they can).
1426 */
fef8985e
MD		 1427 error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data,
1428 ap->a_fflag, ap->a_cred);
984263bc
MD		 1429 if (error != ENOIOCTL)
1430 return(error);
1431
8d77660e 1432 crit_enter();
fef8985e 1433 error = ttioctl(tp, cmd, data, ap->a_fflag);
984263bc
MD		 1434 stl_ttyoptim(portp, &tp->t_termios);
1435 if (error != ENOIOCTL) {
8d77660e 1436 crit_exit();
984263bc
MD		 1437 return(error);
1438 }
1439
1440 error = 0;
1441
1442/*
1443 * Process local commands here. These are all commands that only we
1444 * can take care of (they all rely on actually doing something special
1445 * to the actual hardware).
1446 */
1447 switch (cmd) {
1448 case TIOCSBRK:
1449 stl_sendbreak(portp, -1);
1450 break;
1451 case TIOCCBRK:
1452 stl_sendbreak(portp, -2);
1453 break;
1454 case TIOCSDTR:
1455 stl_setsignals(portp, 1, -1);
1456 break;
1457 case TIOCCDTR:
1458 stl_setsignals(portp, 0, -1);
1459 break;
1460 case TIOCMSET:
1461 i = *((int *) data);
1462 stl_setsignals(portp, ((i & TIOCM_DTR) ? 1 : 0),
1463 ((i & TIOCM_RTS) ? 1 : 0));
1464 break;
1465 case TIOCMBIS:
1466 i = *((int *) data);
1467 stl_setsignals(portp, ((i & TIOCM_DTR) ? 1 : -1),
1468 ((i & TIOCM_RTS) ? 1 : -1));
1469 break;
1470 case TIOCMBIC:
1471 i = *((int *) data);
1472 stl_setsignals(portp, ((i & TIOCM_DTR) ? 0 : -1),
1473 ((i & TIOCM_RTS) ? 0 : -1));
1474 break;
1475 case TIOCMGET:
1476 *((int *) data) = (stl_getsignals(portp) | TIOCM_LE);
1477 break;
1478 case TIOCMSDTRWAIT:
895c1f85 1479 if ((error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0)) == 0)
984263bc
MD		 1480 portp->dtrwait = *((int *) data) * hz / 100;
1481 break;
1482 case TIOCMGDTRWAIT:
1483 *((int *) data) = portp->dtrwait * 100 / hz;
1484 break;
1485 case TIOCTIMESTAMP:
1486 portp->dotimestamp = 1;
1487 *((struct timeval *) data) = portp->timestamp;
1488 break;
1489 default:
1490 error = ENOTTY;
1491 break;
1492 }
8d77660e 1493 crit_exit();
984263bc
MD		 1494
1495 return(error);
1496}
1497/*****************************************************************************/
1498
1499/*
1500 * Convert the specified minor device number into a port struct
1501 * pointer. Return NULL if the device number is not a valid port.
1502 */
1503
b13267a5 1504STATIC stlport_t *stl_dev2port(cdev_t dev)
984263bc
MD		 1505{
1506 stlbrd_t *brdp;
1507
1508 brdp = stl_brds[MKDEV2BRD(dev)];
2038fb68
SW		 1509 if (brdp == NULL)
1510 return(NULL);
984263bc
MD		 1511 return(brdp->ports[MKDEV2PORT(dev)]);
1512}
1513
1514/*****************************************************************************/
1515
1516/*
1517 * Initialize the port hardware. This involves enabling the transmitter
1518 * and receiver, setting the port configuration, and setting the initial
1519 * signal state.
1520 */
1521
1522static int stl_rawopen(stlport_t *portp)
1523{
1524#if STLDEBUG
e3869ec7 1525 kprintf("stl_rawopen(portp=%p): brdnr=%d panelnr=%d portnr=%d\n",
984263bc
MD		 1526 (void *) portp, portp->brdnr, portp->panelnr, portp->portnr);
1527#endif
1528
1529 stl_setport(portp, &portp->tty.t_termios);
1530 portp->sigs = stl_getsignals(portp);
1531 stl_setsignals(portp, 1, 1);
1532 stl_enablerxtx(portp, 1, 1);
1533 stl_startrxtx(portp, 1, 0);
1534 return(0);
1535}
1536
1537/*****************************************************************************/
1538
1539/*
1540 * Shutdown the hardware of a port. Disable its transmitter and
1541 * receiver, and maybe drop signals if appropriate.
1542 */
1543
1544static int stl_rawclose(stlport_t *portp)
1545{
1546 struct tty *tp;
1547
1548#if STLDEBUG
e3869ec7 1549 kprintf("stl_rawclose(portp=%p): brdnr=%d panelnr=%d portnr=%d\n",
984263bc
MD		 1550 (void *) portp, portp->brdnr, portp->panelnr, portp->portnr);
1551#endif
1552
1553 tp = &portp->tty;
1554 stl_disableintrs(portp);
1555 stl_enablerxtx(portp, 0, 0);
1556 stl_flush(portp, (FWRITE | FREAD));
1557 if (tp->t_cflag & HUPCL) {
1558 stl_setsignals(portp, 0, 0);
1559 if (portp->dtrwait != 0) {
1560 portp->state |= ASY_DTRWAIT;
79b066dc
MD		 1561 callout_reset(&portp->dtr_ch, portp->dtrwait,
1562 stl_dtrwakeup, portp);
984263bc
MD		 1563 }
1564 }
1565 portp->callout = 0;
1566 portp->brklen = 0;
1567 portp->state &= ~(ASY_ACTIVE | ASY_RTSFLOW);
1568 wakeup(&portp->callout);
1569 wakeup(TSA_CARR_ON(tp));
1570 return(0);
1571}
1572
1573/*****************************************************************************/
1574
1575/*
1576 * Clear the DTR waiting flag, and wake up any sleepers waiting for
1577 * DTR wait period to finish.
1578 */
1579
1580static void stl_dtrwakeup(void *arg)
1581{
1582 stlport_t *portp;
1583
1584 portp = (stlport_t *) arg;
1585 portp->state &= ~ASY_DTRWAIT;
1586 wakeup(&portp->dtrwait);
1587}
1588
1589/*****************************************************************************/
1590
1591/*
1592 * Start (or continue) the transfer of TX data on this port. If the
1593 * port is not currently busy then load up the interrupt ring queue
1594 * buffer and kick of the transmitter. If the port is running low on
1595 * TX data then refill the ring queue. This routine is also used to
1596 * activate input flow control!
1597 */
1598
1599static void stl_start(struct tty *tp)
1600{
1601 stlport_t *portp;
1602 unsigned int len, stlen;
1603 char *head, *tail;
8d77660e 1604 int count;
984263bc
MD		 1605
1606 portp = (stlport_t *) tp;
1607
1608#if STLDEBUG
e3869ec7 1609 kprintf("stl_start(tp=%x): brdnr=%d portnr=%d\n", (int) tp,
984263bc
MD		 1610 portp->brdnr, portp->portnr);
1611#endif
1612
8d77660e 1613 crit_enter();
984263bc
MD		 1614
1615/*
1616 * Check if the ports input has been blocked, and take appropriate action.
1617 * Not very often do we really need to do anything, so make it quick.
1618 */
1619 if (tp->t_state & TS_TBLOCK) {
1620 if ((portp->state & ASY_RTSFLOWMODE) &&
1621 ((portp->state & ASY_RTSFLOW) == 0))
1622 stl_flowcontrol(portp, 0, -1);
1623 } else {
1624 if (portp->state & ASY_RTSFLOW)
1625 stl_flowcontrol(portp, 1, -1);
1626 }
1627
1628#if VFREEBSD == 205
1629/*
1630 * Check if the output cooked clist buffers are near empty, wake up
1631 * the line discipline to fill it up.
1632 */
1633 if (tp->t_outq.c_cc <= tp->t_lowat) {
1634 if (tp->t_state & TS_ASLEEP) {
1635 tp->t_state &= ~TS_ASLEEP;
1636 wakeup(&tp->t_outq);
1637 }
1638 selwakeup(&tp->t_wsel);
1639 }
1640#endif
1641
1642 if (tp->t_state & (TS_TIMEOUT | TS_TTSTOP)) {
8d77660e 1643 crit_exit();
984263bc
MD		 1644 return;
1645 }
1646
1647/*
1648 * Copy data from the clists into the interrupt ring queue. This will
1649 * require at most 2 copys... What we do is calculate how many chars
1650 * can fit into the ring queue, and how many can fit in 1 copy. If after
1651 * the first copy there is still more room then do the second copy.
1652 * The beauty of this type of ring queue is that we do not need to
1653 * spl protect our-selves, since we only ever update the head pointer,
1654 * and the interrupt routine only ever updates the tail pointer.
1655 */
1656 if (tp->t_outq.c_cc != 0) {
1657 head = portp->tx.head;
1658 tail = portp->tx.tail;
1659 if (head >= tail) {
1660 len = STL_TXBUFSIZE - (head - tail) - 1;
1661 stlen = portp->tx.endbuf - head;
1662 } else {
1663 len = tail - head - 1;
1664 stlen = len;
1665 }
1666
1667 if (len > 0) {
1668 stlen = MIN(len, stlen);
1669 count = q_to_b(&tp->t_outq, head, stlen);
1670 len -= count;
1671 head += count;
1672 if (head >= portp->tx.endbuf) {
1673 head = portp->tx.buf;
1674 if (len > 0) {
1675 stlen = q_to_b(&tp->t_outq, head, len);
1676 head += stlen;
1677 count += stlen;
1678 }
1679 }
1680 portp->tx.head = head;
1681 if (count > 0)
1682 stl_startrxtx(portp, -1, 1);
1683 }
1684
1685/*
1686 * If we sent something, make sure we are called again.
1687 */
1688 tp->t_state |= TS_BUSY;
1689 }
1690
1691#if VFREEBSD != 205
1692/*
1693 * Do any writer wakeups.
1694 */
1695 ttwwakeup(tp);
1696#endif
1697
8d77660e 1698 crit_exit();
984263bc
MD		 1699}
1700
1701/*****************************************************************************/
1702
1703static void stl_flush(stlport_t *portp, int flag)
1704{
1705 char *head, *tail;
8d77660e 1706 int len;
984263bc
MD		 1707
1708#if STLDEBUG
e3869ec7 1709 kprintf("stl_flush(portp=%x,flag=%x)\n", (int) portp, flag);
984263bc
MD		 1710#endif
1711
2038fb68 1712 if (portp == NULL)
984263bc
MD		 1713 return;
1714
8d77660e 1715 crit_enter();
984263bc
MD		 1716
1717 if (flag & FWRITE) {
1718 stl_uartflush(portp, FWRITE);
1719 portp->tx.tail = portp->tx.head;
1720 }
1721
1722/*
1723 * The only thing to watch out for when flushing the read side is
1724 * the RX status buffer. The interrupt code relys on the status
1725 * bytes as being zeroed all the time (it does not bother setting
1726 * a good char status to 0, it expects that it already will be).
1727 * We also need to un-flow the RX channel if flow control was
1728 * active.
1729 */
1730 if (flag & FREAD) {
1731 head = portp->rx.head;
1732 tail = portp->rx.tail;
1733 if (head != tail) {
1734 if (head >= tail) {
1735 len = head - tail;
1736 } else {
1737 len = portp->rx.endbuf - tail;
1738 bzero(portp->rxstatus.buf,
1739 (head - portp->rx.buf));
1740 }
1741 bzero((tail + STL_RXBUFSIZE), len);
1742 portp->rx.tail = head;
1743 }
1744
1745 if ((portp->state & ASY_RTSFLOW) &&
1746 ((portp->tty.t_state & TS_TBLOCK) == 0))
1747 stl_flowcontrol(portp, 1, -1);
1748 }
1749
8d77660e 1750 crit_exit();
984263bc
MD		 1751}
1752
1753/*****************************************************************************/
1754
1755/*
1756 * Interrupt handler for host based boards. Interrupts for all boards
1757 * are vectored through here.
1758 */
1759
477d3c1c 1760void stlintr(void *arg)
984263bc
MD		 1761{
1762 stlbrd_t *brdp;
1763 int i;
1764
1765#if STLDEBUG
e3869ec7 1766 kprintf("stlintr(unit=%d)\n", (int)arg);
984263bc
MD		 1767#endif
1768
1769 for (i = 0; (i < stl_nrbrds); i++) {
2038fb68 1770 if ((brdp = stl_brds[i]) == NULL)
984263bc
MD		 1771 continue;
1772 if (brdp->state == 0)
1773 continue;
1774 (* brdp->isr)(brdp);
1775 }
1776}
1777
1778/*****************************************************************************/
1779
1780#if NPCI > 0
1781
1782static void stlpciintr(void *arg)
1783{
60233e58 1784 stlintr(NULL);
984263bc
MD		 1785}
1786
1787#endif
1788
1789/*****************************************************************************/
1790
1791/*
1792 * Interrupt service routine for EasyIO boards.
1793 */
1794
1795static void stl_eiointr(stlbrd_t *brdp)
1796{
1797 stlpanel_t *panelp;
1798 int iobase;
1799
1800#if STLDEBUG
e3869ec7 1801 kprintf("stl_eiointr(brdp=%p)\n", brdp);
984263bc
MD		 1802#endif
1803
1804 panelp = (stlpanel_t *) brdp->panels[0];
1805 iobase = panelp->iobase;
1806 while (inb(brdp->iostatus) & EIO_INTRPEND)
1807 (* panelp->isr)(panelp, iobase);
1808}
1809
1810/*
1811 * Interrupt service routine for ECH-AT board types.
1812 */
1813
1814static void stl_echatintr(stlbrd_t *brdp)
1815{
1816 stlpanel_t *panelp;
1817 unsigned int ioaddr;
1818 int bnknr;
1819
1820 outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDENABLE));
1821
1822 while (inb(brdp->iostatus) & ECH_INTRPEND) {
1823 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1824 ioaddr = brdp->bnkstataddr[bnknr];
1825 if (inb(ioaddr) & ECH_PNLINTRPEND) {
1826 panelp = brdp->bnk2panel[bnknr];
1827 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1828 }
1829 }
1830 }
1831
1832 outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDDISABLE));
1833}
1834
1835/*****************************************************************************/
1836
1837/*
1838 * Interrupt service routine for ECH-MCA board types.
1839 */
1840
1841static void stl_echmcaintr(stlbrd_t *brdp)
1842{
1843 stlpanel_t *panelp;
1844 unsigned int ioaddr;
1845 int bnknr;
1846
1847 while (inb(brdp->iostatus) & ECH_INTRPEND) {
1848 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1849 ioaddr = brdp->bnkstataddr[bnknr];
1850 if (inb(ioaddr) & ECH_PNLINTRPEND) {
1851 panelp = brdp->bnk2panel[bnknr];
1852 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1853 }
1854 }
1855 }
1856}
1857
1858/*****************************************************************************/
1859
1860/*
1861 * Interrupt service routine for ECH-PCI board types.
1862 */
1863
1864static void stl_echpciintr(stlbrd_t *brdp)
1865{
1866 stlpanel_t *panelp;
1867 unsigned int ioaddr;
1868 int bnknr, recheck;
1869
1870#if STLDEBUG
e3869ec7 1871 kprintf("stl_echpciintr(brdp=%x)\n", (int) brdp);
984263bc
MD		 1872#endif
1873
1874 for (;;) {
1875 recheck = 0;
1876 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1877 outb(brdp->ioctrl, brdp->bnkpageaddr[bnknr]);
1878 ioaddr = brdp->bnkstataddr[bnknr];
1879 if (inb(ioaddr) & ECH_PNLINTRPEND) {
1880 panelp = brdp->bnk2panel[bnknr];
1881 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1882 recheck++;
1883 }
1884 }
1885 if (! recheck)
1886 break;
1887 }
1888}
1889
1890/*****************************************************************************/
1891
1892/*
1893 * Interrupt service routine for EC8/64-PCI board types.
1894 */
1895
1896static void stl_echpci64intr(stlbrd_t *brdp)
1897{
1898 stlpanel_t *panelp;
1899 unsigned int ioaddr;
1900 int bnknr;
1901
1902#if STLDEBUG
e3869ec7 1903 kprintf("stl_echpci64intr(brdp=%p)\n", brdp);
984263bc
MD		 1904#endif
1905
1906 while (inb(brdp->ioctrl) & 0x1) {
1907 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1908 ioaddr = brdp->bnkstataddr[bnknr];
1909#if STLDEBUG
e3869ec7 1910 kprintf(" --> ioaddr=%x status=%x(%x)\n", ioaddr, inb(ioaddr) & ECH_PNLINTRPEND, inb(ioaddr));
984263bc
MD		 1911#endif
1912 if (inb(ioaddr) & ECH_PNLINTRPEND) {
1913 panelp = brdp->bnk2panel[bnknr];
1914 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1915 }
1916 }
1917 }
1918}
1919
1920/*****************************************************************************/
1921
1922/*
1923 * If we haven't scheduled a timeout then do it, some port needs high
1924 * level processing.
1925 */
1926
ce63e0fa 1927static void stl_dotimeout(void)
984263bc
MD		 1928{
1929#if STLDEBUG
e3869ec7 1930 kprintf("stl_dotimeout()\n");
984263bc 1931#endif
984263bc 1932 if (stl_doingtimeout == 0) {
79b066dc
MD		 1933 if ((stl_poll_ch.c_flags & CALLOUT_DID_INIT) == 0)
1934 callout_init(&stl_poll_ch);
1935 callout_reset(&stl_poll_ch, 1, stl_poll, NULL);
984263bc
MD		 1936 stl_doingtimeout++;
1937 }
1938}
1939
1940/*****************************************************************************/
1941
1942/*
1943 * Service "software" level processing. Too slow or painfull to be done
1944 * at real hardware interrupt time. This way we might also be able to
1945 * do some service on other waiting ports as well...
1946 */
1947
1948static void stl_poll(void *arg)
1949{
1950 stlbrd_t *brdp;
1951 stlport_t *portp;
1952 struct tty *tp;
8d77660e 1953 int brdnr, portnr, rearm;
984263bc
MD		 1954
1955#if STLDEBUG
e3869ec7 1956 kprintf("stl_poll()\n");
984263bc
MD		 1957#endif
1958
1959 stl_doingtimeout = 0;
1960 rearm = 0;
1961
8d77660e 1962 crit_enter();
984263bc 1963 for (brdnr = 0; (brdnr < stl_nrbrds); brdnr++) {
2038fb68 1964 if ((brdp = stl_brds[brdnr]) == NULL)
984263bc
MD		 1965 continue;
1966 for (portnr = 0; (portnr < brdp->nrports); portnr++) {
2038fb68 1967 if ((portp = brdp->ports[portnr]) == NULL)
984263bc
MD		 1968 continue;
1969 if ((portp->state & ASY_ACTIVE) == 0)
1970 continue;
1971 tp = &portp->tty;
1972
1973 if (portp->state & ASY_RXDATA)
1974 stl_rxprocess(portp);
1975 if (portp->state & ASY_DCDCHANGE) {
1976 portp->state &= ~ASY_DCDCHANGE;
1977 portp->sigs = stl_getsignals(portp);
1978 (*linesw[tp->t_line].l_modem)(tp,
1979 (portp->sigs & TIOCM_CD));
1980 }
1981 if (portp->state & ASY_TXEMPTY) {
1982 if (stl_datastate(portp) == 0) {
1983 portp->state &= ~ASY_TXEMPTY;
1984 tp->t_state &= ~TS_BUSY;
1985 (*linesw[tp->t_line].l_start)(tp);
1986 }
1987 }
1988 if (portp->state & ASY_TXLOW) {
1989 portp->state &= ~ASY_TXLOW;
1990 (*linesw[tp->t_line].l_start)(tp);
1991 }
1992
1993 if (portp->state & ASY_ACTIVE)
1994 rearm++;
1995 }
1996 }
8d77660e 1997 crit_exit();
984263bc
MD		 1998
1999 if (rearm)
2000 stl_dotimeout();
2001}
2002
2003/*****************************************************************************/
2004
2005/*
2006 * Process the RX data that has been buffered up in the RX ring queue.
2007 */
2008
2009static void stl_rxprocess(stlport_t *portp)
2010{
2011 struct tty *tp;
2012 unsigned int len, stlen, lostlen;
2013 char *head, *tail;
2014 char status;
2015 int ch;
2016
2017#if STLDEBUG
e3869ec7 2018 kprintf("stl_rxprocess(portp=%x): brdnr=%d portnr=%d\n", (int) portp,
984263bc
MD		 2019 portp->brdnr, portp->portnr);
2020#endif
2021
2022 tp = &portp->tty;
2023 portp->state &= ~ASY_RXDATA;
2024
2025 if ((tp->t_state & TS_ISOPEN) == 0) {
2026 stl_flush(portp, FREAD);
2027 return;
2028 }
2029
2030/*
2031 * Calculate the amount of data in the RX ring queue. Also calculate
2032 * the largest single copy size...
2033 */
2034 head = portp->rx.head;
2035 tail = portp->rx.tail;
2036 if (head >= tail) {
2037 len = head - tail;
2038 stlen = len;
2039 } else {
2040 len = STL_RXBUFSIZE - (tail - head);
2041 stlen = portp->rx.endbuf - tail;
2042 }
2043
2044 if (tp->t_state & TS_CAN_BYPASS_L_RINT) {
2045 if (len > 0) {
2046 if (((tp->t_rawq.c_cc + len) >= TTYHOG) &&
2047 ((portp->state & ASY_RTSFLOWMODE) ||
2048 (tp->t_iflag & IXOFF)) &&
2049 ((tp->t_state & TS_TBLOCK) == 0)) {
2050 ch = TTYHOG - tp->t_rawq.c_cc - 1;
2051 len = (ch > 0) ? ch : 0;
2052 stlen = MIN(stlen, len);
2053 ttyblock(tp);
2054 }
2055 lostlen = b_to_q(tail, stlen, &tp->t_rawq);
2056 tail += stlen;
2057 len -= stlen;
2058 if (tail >= portp->rx.endbuf) {
2059 tail = portp->rx.buf;
2060 lostlen += b_to_q(tail, len, &tp->t_rawq);
2061 tail += len;
2062 }
2063 portp->stats.rxlost += lostlen;
2064 ttwakeup(tp);
2065 portp->rx.tail = tail;
2066 }
2067 } else {
2068 while (portp->rx.tail != head) {
2069 ch = (unsigned char) *(portp->rx.tail);
2070 status = *(portp->rx.tail + STL_RXBUFSIZE);
2071 if (status) {
2072 *(portp->rx.tail + STL_RXBUFSIZE) = 0;
2073 if (status & ST_BREAK)
2074 ch |= TTY_BI;
2075 if (status & ST_FRAMING)
2076 ch |= TTY_FE;
2077 if (status & ST_PARITY)
2078 ch |= TTY_PE;
2079 if (status & ST_OVERRUN)
2080 ch |= TTY_OE;
2081 }
2082 (*linesw[tp->t_line].l_rint)(ch, tp);
2083 if (portp->rx.tail == head)
2084 break;
2085
2086 if (++(portp->rx.tail) >= portp->rx.endbuf)
2087 portp->rx.tail = portp->rx.buf;
2088 }
2089 }
2090
2091 if (head != portp->rx.tail)
2092 portp->state |= ASY_RXDATA;
2093
2094/*
2095 * If we were flow controled then maybe the buffer is low enough that
2096 * we can re-activate it.
2097 */
2098 if ((portp->state & ASY_RTSFLOW) && ((tp->t_state & TS_TBLOCK) == 0))
2099 stl_flowcontrol(portp, 1, -1);
2100}
2101
2102/*****************************************************************************/
2103
2104static int stl_param(struct tty *tp, struct termios *tiosp)
2105{
2106 stlport_t *portp;
2107
2108 portp = (stlport_t *) tp;
2038fb68 2109 if (portp == NULL)
984263bc
MD		 2110 return(ENODEV);
2111
2112 return(stl_setport(portp, tiosp));
2113}
2114
2115/*****************************************************************************/
2116
2117/*
2118 * Action the flow control as required. The hw and sw args inform the
2119 * routine what flow control methods it should try.
2120 */
2121
2122static void stl_flowcontrol(stlport_t *portp, int hw, int sw)
2123{
2124 unsigned char *head, *tail;
2125 int len, hwflow;
2126
2127#if STLDEBUG
e3869ec7 2128 kprintf("stl_flowcontrol(portp=%x,hw=%d,sw=%d)\n", (int) portp, hw, sw);
984263bc
MD		 2129#endif
2130
2131 hwflow = -1;
2132
2133 if (portp->state & ASY_RTSFLOWMODE) {
2134 if (hw == 0) {
2135 if ((portp->state & ASY_RTSFLOW) == 0)
2136 hwflow = 0;
2137 } else if (hw > 0) {
2138 if (portp->state & ASY_RTSFLOW) {
2139 head = portp->rx.head;
2140 tail = portp->rx.tail;
2141 len = (head >= tail) ? (head - tail) :
2142 (STL_RXBUFSIZE - (tail - head));
2143 if (len < STL_RXBUFHIGH)
2144 hwflow = 1;
2145 }
2146 }
2147 }
2148
2149/*
2150 * We have worked out what to do, if anything. So now apply it to the
2151 * UART port.
2152 */
2153 stl_sendflow(portp, hwflow, sw);
2154}
2155
2156/*****************************************************************************/
2157
2158/*
2159 * Enable l_rint processing bypass mode if tty modes allow it.
2160 */
2161
2162static void stl_ttyoptim(stlport_t *portp, struct termios *tiosp)
2163{
2164 struct tty *tp;
2165
2166 tp = &portp->tty;
2167 if (((tiosp->c_iflag &
2168 (ICRNL | IGNCR | IMAXBEL | INLCR | ISTRIP)) == 0) &&
2169 (((tiosp->c_iflag & BRKINT) == 0) || (tiosp->c_iflag & IGNBRK)) &&
2170 (((tiosp->c_iflag & PARMRK) == 0) ||
2171 ((tiosp->c_iflag & (IGNPAR | IGNBRK)) == (IGNPAR | IGNBRK))) &&
2172 ((tiosp->c_lflag & (ECHO | ICANON | IEXTEN | ISIG | PENDIN)) ==0) &&
2173 (linesw[tp->t_line].l_rint == ttyinput))
2174 tp->t_state |= TS_CAN_BYPASS_L_RINT;
2175 else
2176 tp->t_state &= ~TS_CAN_BYPASS_L_RINT;
2177 portp->hotchar = linesw[tp->t_line].l_hotchar;
2178}
2179
2180/*****************************************************************************/
2181
2182/*
2183 * Try and find and initialize all the ports on a panel. We don't care
2184 * what sort of board these ports are on - since the port io registers
2185 * are almost identical when dealing with ports.
2186 */
2187
2188static int stl_initports(stlbrd_t *brdp, stlpanel_t *panelp)
2189{
2190 stlport_t *portp;
2191 unsigned int chipmask;
2192 int i, j;
2193
2194#if STLDEBUG
e3869ec7 2195 kprintf("stl_initports(panelp=%x)\n", (int) panelp);
984263bc
MD		 2196#endif
2197
2198 chipmask = stl_panelinit(brdp, panelp);
2199
2200/*
2201 * All UART's are initialized if found. Now go through and setup
2202 * each ports data structures. Also initialize each individual
2203 * UART port.
2204 */
2205 for (i = 0; (i < panelp->nrports); i++) {
efda3bd0 2206 portp = kmalloc(sizeof(stlport_t), M_TTYS, M_WAITOK | M_ZERO);
984263bc
MD		 2207
2208 portp->portnr = i;
2209 portp->brdnr = panelp->brdnr;
2210 portp->panelnr = panelp->panelnr;
2211 portp->uartp = panelp->uartp;
2212 portp->clk = brdp->clk;
2213 panelp->ports[i] = portp;
2214
2215 j = STL_TXBUFSIZE + (2 * STL_RXBUFSIZE);
efda3bd0 2216 portp->tx.buf = kmalloc(j, M_TTYS, M_WAITOK);
984263bc
MD		 2217 portp->tx.endbuf = portp->tx.buf + STL_TXBUFSIZE;
2218 portp->tx.head = portp->tx.buf;
2219 portp->tx.tail = portp->tx.buf;
2220 portp->rx.buf = portp->tx.buf + STL_TXBUFSIZE;
2221 portp->rx.endbuf = portp->rx.buf + STL_RXBUFSIZE;
2222 portp->rx.head = portp->rx.buf;
2223 portp->rx.tail = portp->rx.buf;
2224 portp->rxstatus.buf = portp->rx.buf + STL_RXBUFSIZE;
2225 portp->rxstatus.endbuf = portp->rxstatus.buf + STL_RXBUFSIZE;
2226 portp->rxstatus.head = portp->rxstatus.buf;
2227 portp->rxstatus.tail = portp->rxstatus.buf;
2228 bzero(portp->rxstatus.head, STL_RXBUFSIZE);
2229
2230 portp->initintios.c_ispeed = STL_DEFSPEED;
2231 portp->initintios.c_ospeed = STL_DEFSPEED;
2232 portp->initintios.c_cflag = STL_DEFCFLAG;
2233 portp->initintios.c_iflag = 0;
2234 portp->initintios.c_oflag = 0;
2235 portp->initintios.c_lflag = 0;
2236 bcopy(&ttydefchars[0], &portp->initintios.c_cc[0],
2237 sizeof(portp->initintios.c_cc));
2238 portp->initouttios = portp->initintios;
2239 portp->dtrwait = 3 * hz;
79b066dc 2240 callout_init(&portp->dtr_ch);
984263bc
MD		 2241
2242 stl_portinit(brdp, panelp, portp);
2243 }
2244
2245 return(0);
2246}
2247
2248/*****************************************************************************/
2249
2250/*
2251 * Try to find and initialize an EasyIO board.
2252 */
2253
2254static int stl_initeio(stlbrd_t *brdp)
2255{
2256 stlpanel_t *panelp;
2257 unsigned int status;
2258
2259#if STLDEBUG
e3869ec7 2260 kprintf("stl_initeio(brdp=%x)\n", (int) brdp);
984263bc
MD		 2261#endif
2262
2263 brdp->ioctrl = brdp->ioaddr1 + 1;
2264 brdp->iostatus = brdp->ioaddr1 + 2;
2265 brdp->clk = EIO_CLK;
2266 brdp->isr = stl_eiointr;
2267
2268 status = inb(brdp->iostatus);
2269 switch (status & EIO_IDBITMASK) {
2270 case EIO_8PORTM:
2271 brdp->clk = EIO_CLK8M;
2272 /* fall thru */
2273 case EIO_8PORTRS:
2274 case EIO_8PORTDI:
2275 brdp->nrports = 8;
2276 break;
2277 case EIO_4PORTRS:
2278 brdp->nrports = 4;
2279 break;
2280 case EIO_MK3:
2281 switch (status & EIO_BRDMASK) {
2282 case ID_BRD4:
2283 brdp->nrports = 4;
2284 break;
2285 case ID_BRD8:
2286 brdp->nrports = 8;
2287 break;
2288 case ID_BRD16:
2289 brdp->nrports = 16;
2290 break;
2291 default:
2292 return(ENODEV);
2293 }
2294 brdp->ioctrl++;
2295 break;
2296 default:
2297 return(ENODEV);
2298 }
2299
2300 if (brdp->brdtype == BRD_EASYIOPCI) {
2301 outb((brdp->ioaddr2 + 0x4c), 0x41);
2302 } else {
2303/*
2304 * Check that the supplied IRQ is good and then use it to setup the
2305 * programmable interrupt bits on EIO board. Also set the edge/level
2306 * triggered interrupt bit.
2307 */
2308 if ((brdp->irq < 0) || (brdp->irq > 15) ||
2309 (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
e3869ec7 2310 kprintf("STALLION: invalid irq=%d for brd=%d\n",
984263bc
MD		 2311 brdp->irq, brdp->brdnr);
2312 return(EINVAL);
2313 }
2314 outb(brdp->ioctrl, (stl_vecmap[brdp->irq] |
2315 ((brdp->irqtype) ? EIO_INTLEVEL : EIO_INTEDGE)));
2316 }
2317
efda3bd0 2318 panelp = kmalloc(sizeof(stlpanel_t), M_TTYS, M_WAITOK | M_ZERO);
984263bc
MD		 2319 panelp->brdnr = brdp->brdnr;
2320 panelp->panelnr = 0;
2321 panelp->nrports = brdp->nrports;
2322 panelp->iobase = brdp->ioaddr1;
2323 panelp->hwid = status;
2324 if ((status & EIO_IDBITMASK) == EIO_MK3) {
2325 panelp->uartp = (void *) &stl_sc26198uart;
2326 panelp->isr = stl_sc26198intr;
2327 } else {
2328 panelp->uartp = (void *) &stl_cd1400uart;
2329 panelp->isr = stl_cd1400eiointr;
2330 }
2331 brdp->panels[0] = panelp;
2332 brdp->nrpanels = 1;
2333 brdp->hwid = status;
2334 brdp->state |= BRD_FOUND;
2335 return(0);
2336}
2337
2338/*****************************************************************************/
2339
2340/*
2341 * Try to find an ECH board and initialize it. This code is capable of
2342 * dealing with all types of ECH board.
2343 */
2344
2345static int stl_initech(stlbrd_t *brdp)
2346{
2347 stlpanel_t *panelp;
2348 unsigned int status, nxtid;
2349 int panelnr, ioaddr, banknr, i;
2350
2351#if STLDEBUG
e3869ec7 2352 kprintf("stl_initech(brdp=%x)\n", (int) brdp);
984263bc
MD		 2353#endif
2354
2355/*
2356 * Set up the initial board register contents for boards. This varys a
2357 * bit between the different board types. So we need to handle each
2358 * separately. Also do a check that the supplied IRQ is good.
2359 */
2360 switch (brdp->brdtype) {
2361
2362 case BRD_ECH:
2363 brdp->isr = stl_echatintr;
2364 brdp->ioctrl = brdp->ioaddr1 + 1;
2365 brdp->iostatus = brdp->ioaddr1 + 1;
2366 status = inb(brdp->iostatus);
2367 if ((status & ECH_IDBITMASK) != ECH_ID)
2368 return(ENODEV);
2369 brdp->hwid = status;
2370
2371 if ((brdp->irq < 0) || (brdp->irq > 15) ||
2372 (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
e3869ec7 2373 kprintf("STALLION: invalid irq=%d for brd=%d\n",
984263bc
MD		 2374 brdp->irq, brdp->brdnr);
2375 return(EINVAL);
2376 }
2377 status = ((brdp->ioaddr2 & ECH_ADDR2MASK) >> 1);
2378 status |= (stl_vecmap[brdp->irq] << 1);
2379 outb(brdp->ioaddr1, (status | ECH_BRDRESET));
2380 brdp->ioctrlval = ECH_INTENABLE |
2381 ((brdp->irqtype) ? ECH_INTLEVEL : ECH_INTEDGE);
2382 outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDENABLE));
2383 outb(brdp->ioaddr1, status);
2384 break;
2385
2386 case BRD_ECHMC:
2387 brdp->isr = stl_echmcaintr;
2388 brdp->ioctrl = brdp->ioaddr1 + 0x20;
2389 brdp->iostatus = brdp->ioctrl;
2390 status = inb(brdp->iostatus);
2391 if ((status & ECH_IDBITMASK) != ECH_ID)
2392 return(ENODEV);
2393 brdp->hwid = status;
2394
2395 if ((brdp->irq < 0) || (brdp->irq > 15) ||
2396 (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
e3869ec7 2397 kprintf("STALLION: invalid irq=%d for brd=%d\n",
984263bc
MD		 2398 brdp->irq, brdp->brdnr);
2399 return(EINVAL);
2400 }
2401 outb(brdp->ioctrl, ECHMC_BRDRESET);
2402 outb(brdp->ioctrl, ECHMC_INTENABLE);
2403 break;
2404
2405 case BRD_ECHPCI:
2406 brdp->isr = stl_echpciintr;
2407 brdp->ioctrl = brdp->ioaddr1 + 2;
2408 break;
2409
2410 case BRD_ECH64PCI:
2411 brdp->isr = stl_echpci64intr;
2412 brdp->ioctrl = brdp->ioaddr2 + 0x40;
2413 outb((brdp->ioaddr1 + 0x4c), 0x43);
2414 break;
2415
2416 default:
e3869ec7 2417 kprintf("STALLION: unknown board type=%d\n", brdp->brdtype);
984263bc
MD		 2418 break;
2419 }
2420
2421 brdp->clk = ECH_CLK;
2422
2423/*
2424 * Scan through the secondary io address space looking for panels.
2425 * As we find'em allocate and initialize panel structures for each.
2426 */
2427 ioaddr = brdp->ioaddr2;
2428 panelnr = 0;
2429 nxtid = 0;
2430 banknr = 0;
2431
2432 for (i = 0; (i < STL_MAXPANELS); i++) {
2433 if (brdp->brdtype == BRD_ECHPCI) {
2434 outb(brdp->ioctrl, nxtid);
2435 ioaddr = brdp->ioaddr2;
2436 }
2437 status = inb(ioaddr + ECH_PNLSTATUS);
2438 if ((status & ECH_PNLIDMASK) != nxtid)
2439 break;
efda3bd0 2440 panelp = kmalloc(sizeof(stlpanel_t), M_TTYS, M_WAITOK | M_ZERO);
984263bc
MD		 2441 panelp->brdnr = brdp->brdnr;
2442 panelp->panelnr = panelnr;
2443 panelp->iobase = ioaddr;
2444 panelp->pagenr = nxtid;
2445 panelp->hwid = status;
2446 brdp->bnk2panel[banknr] = panelp;
2447 brdp->bnkpageaddr[banknr] = nxtid;
2448 brdp->bnkstataddr[banknr++] = ioaddr + ECH_PNLSTATUS;
2449
2450 if (status & ECH_PNLXPID) {
2451 panelp->uartp = (void *) &stl_sc26198uart;
2452 panelp->isr = stl_sc26198intr;
2453 if (status & ECH_PNL16PORT) {
2454 panelp->nrports = 16;
2455 brdp->bnk2panel[banknr] = panelp;
2456 brdp->bnkpageaddr[banknr] = nxtid;
2457 brdp->bnkstataddr[banknr++] = ioaddr + 4 +
2458 ECH_PNLSTATUS;
2459 } else {
2460 panelp->nrports = 8;
2461 }
2462 } else {
2463 panelp->uartp = (void *) &stl_cd1400uart;
2464 panelp->isr = stl_cd1400echintr;
2465 if (status & ECH_PNL16PORT) {
2466 panelp->nrports = 16;
2467 panelp->ackmask = 0x80;
2468 if (brdp->brdtype != BRD_ECHPCI)
2469 ioaddr += EREG_BANKSIZE;
2470 brdp->bnk2panel[banknr] = panelp;
2471 brdp->bnkpageaddr[banknr] = ++nxtid;
2472 brdp->bnkstataddr[banknr++] = ioaddr +
2473 ECH_PNLSTATUS;
2474 } else {
2475 panelp->nrports = 8;
2476 panelp->ackmask = 0xc0;
2477 }
2478 }
2479
2480 nxtid++;
2481 ioaddr += EREG_BANKSIZE;
2482 brdp->nrports += panelp->nrports;
2483 brdp->panels[panelnr++] = panelp;
2484 if ((brdp->brdtype == BRD_ECH) || (brdp->brdtype == BRD_ECHMC)){
2485 if (ioaddr >= (brdp->ioaddr2 + 0x20)) {
e3869ec7 2486 kprintf("STALLION: too many ports attached "
984263bc
MD		 2487 "to board %d, remove last module\n",
2488 brdp->brdnr);
2489 break;
2490 }
2491 }
2492 }
2493
2494 brdp->nrpanels = panelnr;
2495 brdp->nrbnks = banknr;
2496 if (brdp->brdtype == BRD_ECH)
2497 outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDDISABLE));
2498
2499 brdp->state |= BRD_FOUND;
2500 return(0);
2501}
2502
2503/*****************************************************************************/
2504
2505/*
2506 * Initialize and configure the specified board. This firstly probes
2507 * for the board, if it is found then the board is initialized and
2508 * then all its ports are initialized as well.
2509 */
2510
2511static int stl_brdinit(stlbrd_t *brdp)
2512{
2513 stlpanel_t *panelp;
2514 int i, j, k;
2515
2516#if STLDEBUG
e3869ec7 2517 kprintf("stl_brdinit(brdp=%x): unit=%d type=%d io1=%x io2=%x irq=%d\n",
984263bc
MD		 2518 (int) brdp, brdp->brdnr, brdp->brdtype, brdp->ioaddr1,
2519 brdp->ioaddr2, brdp->irq);
2520#endif
2521
2522 switch (brdp->brdtype) {
2523 case BRD_EASYIO:
2524 case BRD_EASYIOPCI:
2525 stl_initeio(brdp);
2526 break;
2527 case BRD_ECH:
2528 case BRD_ECHMC:
2529 case BRD_ECHPCI:
2530 case BRD_ECH64PCI:
2531 stl_initech(brdp);
2532 break;
2533 default:
e3869ec7 2534 kprintf("STALLION: unit=%d is unknown board type=%d\n",
984263bc
MD		 2535 brdp->brdnr, brdp->brdtype);
2536 return(ENODEV);
2537 }
2538
2539 stl_brds[brdp->brdnr] = brdp;
2540 if ((brdp->state & BRD_FOUND) == 0) {
2541#if 0
e3869ec7 2542 kprintf("STALLION: %s board not found, unit=%d io=%x irq=%d\n",
984263bc
MD		 2543 stl_brdnames[brdp->brdtype], brdp->brdnr,
2544 brdp->ioaddr1, brdp->irq);
2545#endif
2546 return(ENODEV);
2547 }
2548
2549 for (i = 0, k = 0; (i < STL_MAXPANELS); i++) {
2550 panelp = brdp->panels[i];
2038fb68 2551 if (panelp != NULL) {
984263bc
MD		 2552 stl_initports(brdp, panelp);
2553 for (j = 0; (j < panelp->nrports); j++)
2554 brdp->ports[k++] = panelp->ports[j];
2555 }
2556 }
2557
e3869ec7 2558 kprintf("stl%d: %s (driver version %s) unit=%d nrpanels=%d nrports=%d\n",
984263bc
MD		 2559 brdp->unitid, stl_brdnames[brdp->brdtype], stl_drvversion,
2560 brdp->brdnr, brdp->nrpanels, brdp->nrports);
2561 return(0);
2562}
2563
2564/*****************************************************************************/
2565
2566/*
2567 * Return the board stats structure to user app.
2568 */
2569
2570static int stl_getbrdstats(caddr_t data)
2571{
2572 stlbrd_t *brdp;
2573 stlpanel_t *panelp;
2574 int i;
2575
2576 stl_brdstats = *((combrd_t *) data);
2577 if (stl_brdstats.brd >= STL_MAXBRDS)
2578 return(-ENODEV);
2579 brdp = stl_brds[stl_brdstats.brd];
2038fb68 2580 if (brdp == NULL)
984263bc
MD		 2581 return(-ENODEV);
2582
2583 bzero(&stl_brdstats, sizeof(combrd_t));
2584 stl_brdstats.brd = brdp->brdnr;
2585 stl_brdstats.type = brdp->brdtype;
2586 stl_brdstats.hwid = brdp->hwid;
2587 stl_brdstats.state = brdp->state;
2588 stl_brdstats.ioaddr = brdp->ioaddr1;
2589 stl_brdstats.ioaddr2 = brdp->ioaddr2;
2590 stl_brdstats.irq = brdp->irq;
2591 stl_brdstats.nrpanels = brdp->nrpanels;
2592 stl_brdstats.nrports = brdp->nrports;
2593 for (i = 0; (i < brdp->nrpanels); i++) {
2594 panelp = brdp->panels[i];
2595 stl_brdstats.panels[i].panel = i;
2596 stl_brdstats.panels[i].hwid = panelp->hwid;
2597 stl_brdstats.panels[i].nrports = panelp->nrports;
2598 }
2599
fc6d0222 2600 *((combrd_t *) data) = stl_brdstats;
984263bc
MD		 2601 return(0);
2602}
2603
2604/*****************************************************************************/
2605
2606/*
2607 * Resolve the referenced port number into a port struct pointer.
2608 */
2609
2610static stlport_t *stl_getport(int brdnr, int panelnr, int portnr)
2611{
2612 stlbrd_t *brdp;
2613 stlpanel_t *panelp;
2614
2615 if ((brdnr < 0) || (brdnr >= STL_MAXBRDS))
2038fb68 2616 return(NULL);
984263bc 2617 brdp = stl_brds[brdnr];
2038fb68
SW		 2618 if (brdp == NULL)
2619 return(NULL);
984263bc 2620 if ((panelnr < 0) || (panelnr >= brdp->nrpanels))
2038fb68 2621 return(NULL);
984263bc 2622 panelp = brdp->panels[panelnr];
2038fb68
SW		 2623 if (panelp == NULL)
2624 return(NULL);
984263bc 2625 if ((portnr < 0) || (portnr >= panelp->nrports))
2038fb68 2626 return(NULL);
984263bc
MD		 2627 return(panelp->ports[portnr]);
2628}
2629
2630/*****************************************************************************/
2631
2632/*
2633 * Return the port stats structure to user app. A NULL port struct
2634 * pointer passed in means that we need to find out from the app
2635 * what port to get stats for (used through board control device).
2636 */
2637
2638static int stl_getportstats(stlport_t *portp, caddr_t data)
2639{
2640 unsigned char *head, *tail;
2641
2038fb68 2642 if (portp == NULL) {
984263bc
MD		 2643 stl_comstats = *((comstats_t *) data);
2644 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2645 stl_comstats.port);
2038fb68 2646 if (portp == NULL)
984263bc
MD		 2647 return(-ENODEV);
2648 }
2649
2650 portp->stats.state = portp->state;
2651 /*portp->stats.flags = portp->flags;*/
2652 portp->stats.hwid = portp->hwid;
2653 portp->stats.ttystate = portp->tty.t_state;
2654 portp->stats.cflags = portp->tty.t_cflag;
2655 portp->stats.iflags = portp->tty.t_iflag;
2656 portp->stats.oflags = portp->tty.t_oflag;
2657 portp->stats.lflags = portp->tty.t_lflag;
2658
2659 head = portp->tx.head;
2660 tail = portp->tx.tail;
2661 portp->stats.txbuffered = ((head >= tail) ? (head - tail) :
2662 (STL_TXBUFSIZE - (tail - head)));
2663
2664 head = portp->rx.head;
2665 tail = portp->rx.tail;
2666 portp->stats.rxbuffered = (head >= tail) ? (head - tail) :
2667 (STL_RXBUFSIZE - (tail - head));
2668
2669 portp->stats.signals = (unsigned long) stl_getsignals(portp);
2670
2671 *((comstats_t *) data) = portp->stats;
2672 return(0);
2673}
2674
2675/*****************************************************************************/
2676
2677/*
2678 * Clear the port stats structure. We also return it zeroed out...
2679 */
2680
2681static int stl_clrportstats(stlport_t *portp, caddr_t data)
2682{
2038fb68 2683 if (portp == NULL) {
984263bc
MD		 2684 stl_comstats = *((comstats_t *) data);
2685 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2686 stl_comstats.port);
2038fb68 2687 if (portp == NULL)
984263bc
MD		 2688 return(ENODEV);
2689 }
2690
2691 bzero(&portp->stats, sizeof(comstats_t));
2692 portp->stats.brd = portp->brdnr;
2693 portp->stats.panel = portp->panelnr;
2694 portp->stats.port = portp->portnr;
2695 *((comstats_t *) data) = stl_comstats;
2696 return(0);
2697}
2698
2699/*****************************************************************************/
2700
2701/*
2702 * The "staliomem" device is used for stats collection in this driver.
2703 */
2704
b13267a5 2705static int stl_memioctl(cdev_t dev, unsigned long cmd, caddr_t data, int flag)
984263bc
MD		 2706{
2707 int rc;
2708
2709#if STLDEBUG
e3869ec7 2710 kprintf("stl_memioctl(dev=%s,cmd=%lx,data=%p,flag=%x)\n",
984263bc
MD		 2711 devtoname(dev), cmd, (void *) data, flag);
2712#endif
2713
2714 rc = 0;
2715
2716 switch (cmd) {
2717 case COM_GETPORTSTATS:
2038fb68 2718 rc = stl_getportstats(NULL, data);
984263bc
MD		 2719 break;
2720 case COM_CLRPORTSTATS:
2038fb68 2721 rc = stl_clrportstats(NULL, data);
984263bc
MD		 2722 break;
2723 case COM_GETBRDSTATS:
2724 rc = stl_getbrdstats(data);
2725 break;
2726 default:
2727 rc = ENOTTY;
2728 break;
2729 }
2730
2731 return(rc);
2732}
2733
2734/*****************************************************************************/
2735
2736/*****************************************************************************/
2737/* CD1400 UART CODE */
2738/*****************************************************************************/
2739
2740/*
2741 * These functions get/set/update the registers of the cd1400 UARTs.
2742 * Access to the cd1400 registers is via an address/data io port pair.
2743 */
2744
2745static int stl_cd1400getreg(stlport_t *portp, int regnr)
2746{
2747 outb(portp->ioaddr, (regnr + portp->uartaddr));
2748 return(inb(portp->ioaddr + EREG_DATA));
2749}
2750
2751/*****************************************************************************/
2752
2753static void stl_cd1400setreg(stlport_t *portp, int regnr, int value)
2754{
2755 outb(portp->ioaddr, (regnr + portp->uartaddr));
2756 outb((portp->ioaddr + EREG_DATA), value);
2757}
2758
2759/*****************************************************************************/
2760
2761static int stl_cd1400updatereg(stlport_t *portp, int regnr, int value)
2762{
2763 outb(portp->ioaddr, (regnr + portp->uartaddr));
2764 if (inb(portp->ioaddr + EREG_DATA) != value) {
2765 outb((portp->ioaddr + EREG_DATA), value);
2766 return(1);
2767 }
2768 return(0);
2769}
2770
2771/*****************************************************************************/
2772
2773static void stl_cd1400flush(stlport_t *portp, int flag)
2774{
984263bc
MD		 2775
2776#if STLDEBUG
e3869ec7 2777 kprintf("stl_cd1400flush(portp=%x,flag=%x)\n", (int) portp, flag);
984263bc
MD		 2778#endif
2779
2038fb68 2780 if (portp == NULL)
984263bc
MD		 2781 return;
2782
8d77660e 2783 crit_enter();
984263bc
MD		 2784
2785 if (flag & FWRITE) {
2786 BRDENABLE(portp->brdnr, portp->pagenr);
2787 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2788 stl_cd1400ccrwait(portp);
2789 stl_cd1400setreg(portp, CCR, CCR_TXFLUSHFIFO);
2790 stl_cd1400ccrwait(portp);
2791 BRDDISABLE(portp->brdnr);
2792 }
2793
2794 if (flag & FREAD) {
2795 /* Hmmm */
2796 }
2797
8d77660e 2798 crit_exit();
984263bc
MD		 2799}
2800
2801/*****************************************************************************/
2802
2803static void stl_cd1400ccrwait(stlport_t *portp)
2804{
2805 int i;
2806
2807 for (i = 0; (i < CCR_MAXWAIT); i++) {
2808 if (stl_cd1400getreg(portp, CCR) == 0)
2809 return;
2810 }
2811
e3869ec7 2812 kprintf("stl%d: cd1400 device not responding, panel=%d port=%d\n",
984263bc
MD		 2813 portp->brdnr, portp->panelnr, portp->portnr);
2814}
2815
2816/*****************************************************************************/
2817
2818/*
2819 * Transmit interrupt handler. This has gotta be fast! Handling TX
2820 * chars is pretty simple, stuff as many as possible from the TX buffer
2821 * into the cd1400 FIFO. Must also handle TX breaks here, since they
2822 * are embedded as commands in the data stream. Oh no, had to use a goto!
2823 */
2824
2825static __inline void stl_cd1400txisr(stlpanel_t *panelp, int ioaddr)
2826{
2827 struct tty *tp;
2828 stlport_t *portp;
2829 unsigned char ioack, srer;
2830 char *head, *tail;
2831 int len, stlen;
2832
2833#if STLDEBUG
e3869ec7 2834 kprintf("stl_cd1400txisr(panelp=%x,ioaddr=%x)\n", (int) panelp, ioaddr);
984263bc
MD		 2835#endif
2836
2837 ioack = inb(ioaddr + EREG_TXACK);
2838 if (((ioack & panelp->ackmask) != 0) ||
2839 ((ioack & ACK_TYPMASK) != ACK_TYPTX)) {
e3869ec7 2840 kprintf("STALLION: bad TX interrupt ack value=%x\n",
984263bc
MD		 2841 ioack);
2842 return;
2843 }
2844 portp = panelp->ports[(ioack >> 3)];
2845 tp = &portp->tty;
2846
2847/*
2848 * Unfortunately we need to handle breaks in the data stream, since
2849 * this is the only way to generate them on the cd1400. Do it now if
2850 * a break is to be sent. Some special cases here: brklen is -1 then
2851 * start sending an un-timed break, if brklen is -2 then stop sending
2852 * an un-timed break, if brklen is -3 then we have just sent an
2853 * un-timed break and do not want any data to go out, if brklen is -4
2854 * then a break has just completed so clean up the port settings.
2855 */
2856 if (portp->brklen != 0) {
2857 if (portp->brklen >= -1) {
2858 outb(ioaddr, (TDR + portp->uartaddr));
2859 outb((ioaddr + EREG_DATA), ETC_CMD);
2860 outb((ioaddr + EREG_DATA), ETC_STARTBREAK);
2861 if (portp->brklen > 0) {
2862 outb((ioaddr + EREG_DATA), ETC_CMD);
2863 outb((ioaddr + EREG_DATA), ETC_DELAY);
2864 outb((ioaddr + EREG_DATA), portp->brklen);
2865 outb((ioaddr + EREG_DATA), ETC_CMD);
2866 outb((ioaddr + EREG_DATA), ETC_STOPBREAK);
2867 portp->brklen = -4;
2868 } else {
2869 portp->brklen = -3;
2870 }
2871 } else if (portp->brklen == -2) {
2872 outb(ioaddr, (TDR + portp->uartaddr));
2873 outb((ioaddr + EREG_DATA), ETC_CMD);
2874 outb((ioaddr + EREG_DATA), ETC_STOPBREAK);
2875 portp->brklen = -4;
2876 } else if (portp->brklen == -3) {
2877 outb(ioaddr, (SRER + portp->uartaddr));
2878 srer = inb(ioaddr + EREG_DATA);
2879 srer &= ~(SRER_TXDATA | SRER_TXEMPTY);
2880 outb((ioaddr + EREG_DATA), srer);
2881 } else {
2882 outb(ioaddr, (COR2 + portp->uartaddr));
2883 outb((ioaddr + EREG_DATA),
2884 (inb(ioaddr + EREG_DATA) & ~COR2_ETC));
2885 portp->brklen = 0;
2886 }
2887 goto stl_txalldone;
2888 }
2889
2890 head = portp->tx.head;
2891 tail = portp->tx.tail;
2892 len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
2893 if ((len == 0) || ((len < STL_TXBUFLOW) &&
2894 ((portp->state & ASY_TXLOW) == 0))) {
2895 portp->state |= ASY_TXLOW;
2896 stl_dotimeout();
2897 }
2898
2899 if (len == 0) {
2900 outb(ioaddr, (SRER + portp->uartaddr));
2901 srer = inb(ioaddr + EREG_DATA);
2902 if (srer & SRER_TXDATA) {
2903 srer = (srer & ~SRER_TXDATA) | SRER_TXEMPTY;
2904 } else {
2905 srer &= ~(SRER_TXDATA | SRER_TXEMPTY);
2906 portp->state |= ASY_TXEMPTY;
2907 portp->state &= ~ASY_TXBUSY;
2908 }
2909 outb((ioaddr + EREG_DATA), srer);
2910 } else {
2911 len = MIN(len, CD1400_TXFIFOSIZE);
2912 portp->stats.txtotal += len;
2913 stlen = MIN(len, (portp->tx.endbuf - tail));
2914 outb(ioaddr, (TDR + portp->uartaddr));
2915 outsb((ioaddr + EREG_DATA), tail, stlen);
2916 len -= stlen;
2917 tail += stlen;
2918 if (tail >= portp->tx.endbuf)
2919 tail = portp->tx.buf;
2920 if (len > 0) {
2921 outsb((ioaddr + EREG_DATA), tail, len);
2922 tail += len;
2923 }
2924 portp->tx.tail = tail;
2925 }
2926
2927stl_txalldone:
2928 outb(ioaddr, (EOSRR + portp->uartaddr));
2929 outb((ioaddr + EREG_DATA), 0);
2930}
2931
2932/*****************************************************************************/
2933
2934/*
2935 * Receive character interrupt handler. Determine if we have good chars
2936 * or bad chars and then process appropriately.
2937 */
2938
2939static __inline void stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr)
2940{
2941 stlport_t *portp;
2942 struct tty *tp;
2943 unsigned int ioack, len, buflen, stlen;
2944 unsigned char status;
2945 char ch;
2946 char *head, *tail;
2947
2948#if STLDEBUG
e3869ec7 2949 kprintf("stl_cd1400rxisr(panelp=%x,ioaddr=%x)\n", (int) panelp, ioaddr);
984263bc
MD		 2950#endif
2951
2952 ioack = inb(ioaddr + EREG_RXACK);
2953 if ((ioack & panelp->ackmask) != 0) {
e3869ec7 2954 kprintf("STALLION: bad RX interrupt ack value=%x\n", ioack);
984263bc
MD		 2955 return;
2956 }
2957 portp = panelp->ports[(ioack >> 3)];
2958 tp = &portp->tty;
2959
2960/*
2961 * First up, calculate how much room there is in the RX ring queue.
2962 * We also want to keep track of the longest possible copy length,
2963 * this has to allow for the wrapping of the ring queue.
2964 */
2965 head = portp->rx.head;
2966 tail = portp->rx.tail;
2967 if (head >= tail) {
2968 buflen = STL_RXBUFSIZE - (head - tail) - 1;
2969 stlen = portp->rx.endbuf - head;
2970 } else {
2971 buflen = tail - head - 1;
2972 stlen = buflen;
2973 }
2974
2975/*
2976 * Check if the input buffer is near full. If so then we should take
2977 * some flow control action... It is very easy to do hardware and
2978 * software flow control from here since we have the port selected on
2979 * the UART.
2980 */
2981 if (buflen <= (STL_RXBUFSIZE - STL_RXBUFHIGH)) {
2982 if (((portp->state & ASY_RTSFLOW) == 0) &&
2983 (portp->state & ASY_RTSFLOWMODE)) {
2984 portp->state |= ASY_RTSFLOW;
2985 stl_cd1400setreg(portp, MCOR1,
2986 (stl_cd1400getreg(portp, MCOR1) & 0xf0));
2987 stl_cd1400setreg(portp, MSVR2, 0);
2988 portp->stats.rxrtsoff++;
2989 }
2990 }
2991
2992/*
2993 * OK we are set, process good data... If the RX ring queue is full
2994 * just chuck the chars - don't leave them in the UART.
2995 */
2996 if ((ioack & ACK_TYPMASK) == ACK_TYPRXGOOD) {
2997 outb(ioaddr, (RDCR + portp->uartaddr));
2998 len = inb(ioaddr + EREG_DATA);
2999 if (buflen == 0) {
3000 outb(ioaddr, (RDSR + portp->uartaddr));
3001 insb((ioaddr + EREG_DATA), &stl_unwanted[0], len);
3002 portp->stats.rxlost += len;
3003 portp->stats.rxtotal += len;
3004 } else {
3005 len = MIN(len, buflen);
3006 portp->stats.rxtotal += len;
3007 stlen = MIN(len, stlen);
3008 if (len > 0) {
3009 outb(ioaddr, (RDSR + portp->uartaddr));
3010 insb((ioaddr + EREG_DATA), head, stlen);
3011 head += stlen;
3012 if (head >= portp->rx.endbuf) {
3013 head = portp->rx.buf;
3014 len -= stlen;
3015 insb((ioaddr + EREG_DATA), head, len);
3016 head += len;
3017 }
3018 }
3019 }
3020 } else if ((ioack & ACK_TYPMASK) == ACK_TYPRXBAD) {
3021 outb(ioaddr, (RDSR + portp->uartaddr));
3022 status = inb(ioaddr + EREG_DATA);
3023 ch = inb(ioaddr + EREG_DATA);
3024 if (status & ST_BREAK)
3025 portp->stats.rxbreaks++;
3026 if (status & ST_FRAMING)
3027 portp->stats.rxframing++;
3028 if (status & ST_PARITY)
3029 portp->stats.rxparity++;
3030 if (status & ST_OVERRUN)
3031 portp->stats.rxoverrun++;
3032 if (status & ST_SCHARMASK) {
3033 if ((status & ST_SCHARMASK) == ST_SCHAR1)
3034 portp->stats.txxon++;
3035 if ((status & ST_SCHARMASK) == ST_SCHAR2)
3036 portp->stats.txxoff++;
3037 goto stl_rxalldone;
3038 }
3039 if ((portp->rxignoremsk & status) == 0) {
3040 if ((tp->t_state & TS_CAN_BYPASS_L_RINT) &&
3041 ((status & ST_FRAMING) ||
3042 ((status & ST_PARITY) && (tp->t_iflag & INPCK))))
3043 ch = 0;
3044 if ((portp->rxmarkmsk & status) == 0)
3045 status = 0;
3046 *(head + STL_RXBUFSIZE) = status;
3047 *head++ = ch;
3048 if (head >= portp->rx.endbuf)
3049 head = portp->rx.buf;
3050 }
3051 } else {
e3869ec7 3052 kprintf("STALLION: bad RX interrupt ack value=%x\n", ioack);
984263bc
MD		 3053 return;
3054 }
3055
3056 portp->rx.head = head;
3057 portp->state |= ASY_RXDATA;
3058 stl_dotimeout();
3059
3060stl_rxalldone:
3061 outb(ioaddr, (EOSRR + portp->uartaddr));
3062 outb((ioaddr + EREG_DATA), 0);
3063}
3064
3065/*****************************************************************************/
3066
3067/*
3068 * Modem interrupt handler. The is called when the modem signal line
3069 * (DCD) has changed state.
3070 */
3071
3072static __inline void stl_cd1400mdmisr(stlpanel_t *panelp, int ioaddr)
3073{
3074 stlport_t *portp;
3075 unsigned int ioack;
3076 unsigned char misr;
3077
3078#if STLDEBUG
e3869ec7 3079 kprintf("stl_cd1400mdmisr(panelp=%x,ioaddr=%x)\n", (int) panelp, ioaddr);
984263bc
MD		 3080#endif
3081
3082 ioack = inb(ioaddr + EREG_MDACK);
3083 if (((ioack & panelp->ackmask) != 0) ||
3084 ((ioack & ACK_TYPMASK) != ACK_TYPMDM)) {
e3869ec7 3085 kprintf("STALLION: bad MODEM interrupt ack value=%x\n", ioack);
984263bc
MD		 3086 return;
3087 }
3088 portp = panelp->ports[(ioack >> 3)];
3089
3090 outb(ioaddr, (MISR + portp->uartaddr));
3091 misr = inb(ioaddr + EREG_DATA);
3092 if (misr & MISR_DCD) {
3093 portp->state |= ASY_DCDCHANGE;
3094 portp->stats.modem++;
3095 stl_dotimeout();
3096 }
3097
3098 outb(ioaddr, (EOSRR + portp->uartaddr));
3099 outb((ioaddr + EREG_DATA), 0);
3100}
3101
3102/*****************************************************************************/
3103
3104/*
3105 * Interrupt service routine for cd1400 EasyIO boards.
3106 */
3107
3108static void stl_cd1400eiointr(stlpanel_t *panelp, unsigned int iobase)
3109{
3110 unsigned char svrtype;
3111
3112#if STLDEBUG
e3869ec7 3113 kprintf("stl_cd1400eiointr(panelp=%x,iobase=%x)\n", (int) panelp,
984263bc
MD		 3114 iobase);
3115#endif
3116
3117 outb(iobase, SVRR);
3118 svrtype = inb(iobase + EREG_DATA);
3119 if (panelp->nrports > 4) {
3120 outb(iobase, (SVRR + 0x80));
3121 svrtype |= inb(iobase + EREG_DATA);
3122 }
3123#if STLDEBUG
e3869ec7 3124kprintf("stl_cd1400eiointr(panelp=%x,iobase=%x): svrr=%x\n", (int) panelp, iobase, svrtype);
984263bc
MD		 3125#endif
3126
3127 if (svrtype & SVRR_RX)
3128 stl_cd1400rxisr(panelp, iobase);
3129 else if (svrtype & SVRR_TX)
3130 stl_cd1400txisr(panelp, iobase);
3131 else if (svrtype & SVRR_MDM)
3132 stl_cd1400mdmisr(panelp, iobase);
3133}
3134
3135/*****************************************************************************/
3136
3137/*
3138 * Interrupt service routine for cd1400 panels.
3139 */
3140
3141static void stl_cd1400echintr(stlpanel_t *panelp, unsigned int iobase)
3142{
3143 unsigned char svrtype;
3144
3145#if STLDEBUG
e3869ec7 3146 kprintf("stl_cd1400echintr(panelp=%x,iobase=%x)\n", (int) panelp,
984263bc
MD		 3147 iobase);
3148#endif
3149
3150 outb(iobase, SVRR);
3151 svrtype = inb(iobase + EREG_DATA);
3152 outb(iobase, (SVRR + 0x80));
3153 svrtype |= inb(iobase + EREG_DATA);
3154 if (svrtype & SVRR_RX)
3155 stl_cd1400rxisr(panelp, iobase);
3156 else if (svrtype & SVRR_TX)
3157 stl_cd1400txisr(panelp, iobase);
3158 else if (svrtype & SVRR_MDM)
3159 stl_cd1400mdmisr(panelp, iobase);
3160}
3161
3162/*****************************************************************************/
3163
3164/*
3165 * Set up the cd1400 registers for a port based on the termios port
3166 * settings.
3167 */
3168
3169static int stl_cd1400setport(stlport_t *portp, struct termios *tiosp)
3170{
3171 unsigned int clkdiv;
3172 unsigned char cor1, cor2, cor3;
3173 unsigned char cor4, cor5, ccr;
3174 unsigned char srer, sreron, sreroff;
3175 unsigned char mcor1, mcor2, rtpr;
3176 unsigned char clk, div;
984263bc
MD		 3177
3178#if STLDEBUG
e3869ec7 3179 kprintf("stl_cd1400setport(portp=%x,tiosp=%x): brdnr=%d portnr=%d\n",
984263bc
MD		 3180 (int) portp, (int) tiosp, portp->brdnr, portp->portnr);
3181#endif
3182
3183 cor1 = 0;
3184 cor2 = 0;
3185 cor3 = 0;
3186 cor4 = 0;
3187 cor5 = 0;
3188 ccr = 0;
3189 rtpr = 0;
3190 clk = 0;
3191 div = 0;
3192 mcor1 = 0;
3193 mcor2 = 0;
3194 sreron = 0;
3195 sreroff = 0;
3196
3197/*
3198 * Set up the RX char ignore mask with those RX error types we
3199 * can ignore. We could have used some special modes of the cd1400
3200 * UART to help, but it is better this way because we can keep stats
3201 * on the number of each type of RX exception event.
3202 */
3203 portp->rxignoremsk = 0;
3204 if (tiosp->c_iflag & IGNPAR)
3205 portp->rxignoremsk |= (ST_PARITY | ST_FRAMING | ST_OVERRUN);
3206 if (tiosp->c_iflag & IGNBRK)
3207 portp->rxignoremsk |= ST_BREAK;
3208
3209 portp->rxmarkmsk = ST_OVERRUN;
3210 if (tiosp->c_iflag & (INPCK | PARMRK))
3211 portp->rxmarkmsk |= (ST_PARITY | ST_FRAMING);
3212 if (tiosp->c_iflag & BRKINT)
3213 portp->rxmarkmsk |= ST_BREAK;
3214
3215/*
3216 * Go through the char size, parity and stop bits and set all the
3217 * option registers appropriately.
3218 */
3219 switch (tiosp->c_cflag & CSIZE) {
3220 case CS5:
3221 cor1 |= COR1_CHL5;
3222 break;
3223 case CS6:
3224 cor1 |= COR1_CHL6;
3225 break;
3226 case CS7:
3227 cor1 |= COR1_CHL7;
3228 break;
3229 default:
3230 cor1 |= COR1_CHL8;
3231 break;
3232 }
3233
3234 if (tiosp->c_cflag & CSTOPB)
3235 cor1 |= COR1_STOP2;
3236 else
3237 cor1 |= COR1_STOP1;
3238
3239 if (tiosp->c_cflag & PARENB) {
3240 if (tiosp->c_cflag & PARODD)
3241 cor1 |= (COR1_PARENB | COR1_PARODD);
3242 else
3243 cor1 |= (COR1_PARENB | COR1_PAREVEN);
3244 } else {
3245 cor1 |= COR1_PARNONE;
3246 }
3247
3248/*
3249 * Set the RX FIFO threshold at 6 chars. This gives a bit of breathing
3250 * space for hardware flow control and the like. This should be set to
3251 * VMIN. Also here we will set the RX data timeout to 10ms - this should
3252 * really be based on VTIME...
3253 */
3254 cor3 |= FIFO_RXTHRESHOLD;
3255 rtpr = 2;
3256
3257/*
3258 * Calculate the baud rate timers. For now we will just assume that
3259 * the input and output baud are the same. Could have used a baud
3260 * table here, but this way we can generate virtually any baud rate
3261 * we like!
3262 */
3263 if (tiosp->c_ispeed == 0)
3264 tiosp->c_ispeed = tiosp->c_ospeed;
3265 if ((tiosp->c_ospeed < 0) || (tiosp->c_ospeed > CD1400_MAXBAUD))
3266 return(EINVAL);
3267
3268 if (tiosp->c_ospeed > 0) {
3269 for (clk = 0; (clk < CD1400_NUMCLKS); clk++) {
3270 clkdiv = ((portp->clk / stl_cd1400clkdivs[clk]) /
3271 tiosp->c_ospeed);
3272 if (clkdiv < 0x100)
3273 break;
3274 }
3275 div = (unsigned char) clkdiv;
3276 }
3277
3278/*
3279 * Check what form of modem signaling is required and set it up.
3280 */
3281 if ((tiosp->c_cflag & CLOCAL) == 0) {
3282 mcor1 |= MCOR1_DCD;
3283 mcor2 |= MCOR2_DCD;
3284 sreron |= SRER_MODEM;
3285 }
3286
3287/*
3288 * Setup cd1400 enhanced modes if we can. In particular we want to
3289 * handle as much of the flow control as possbile automatically. As
3290 * well as saving a few CPU cycles it will also greatly improve flow
3291 * control reliablilty.
3292 */
3293 if (tiosp->c_iflag & IXON) {
3294 cor2 |= COR2_TXIBE;
3295 cor3 |= COR3_SCD12;
3296 if (tiosp->c_iflag & IXANY)
3297 cor2 |= COR2_IXM;
3298 }
3299
3300 if (tiosp->c_cflag & CCTS_OFLOW)
3301 cor2 |= COR2_CTSAE;
3302 if (tiosp->c_cflag & CRTS_IFLOW)
3303 mcor1 |= FIFO_RTSTHRESHOLD;
3304
3305/*
3306 * All cd1400 register values calculated so go through and set them
3307 * all up.
3308 */
3309#if STLDEBUG
e3869ec7 3310 kprintf("SETPORT: portnr=%d panelnr=%d brdnr=%d\n", portp->portnr,
984263bc 3311 portp->panelnr, portp->brdnr);
e3869ec7 3312 kprintf(" cor1=%x cor2=%x cor3=%x cor4=%x cor5=%x\n", cor1, cor2,
984263bc 3313 cor3, cor4, cor5);
e3869ec7 3314 kprintf(" mcor1=%x mcor2=%x rtpr=%x sreron=%x sreroff=%x\n",
984263bc 3315 mcor1, mcor2, rtpr, sreron, sreroff);
e3869ec7
SW		 3316 kprintf(" tcor=%x tbpr=%x rcor=%x rbpr=%x\n", clk, div, clk, div);
3317 kprintf(" schr1=%x schr2=%x schr3=%x schr4=%x\n",
984263bc
MD		 3318 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP], tiosp->c_cc[VSTART],
3319 tiosp->c_cc[VSTOP]);
3320#endif
3321
8d77660e 3322 crit_enter();
984263bc
MD		 3323 BRDENABLE(portp->brdnr, portp->pagenr);
3324 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3325 srer = stl_cd1400getreg(portp, SRER);
3326 stl_cd1400setreg(portp, SRER, 0);
3327 ccr += stl_cd1400updatereg(portp, COR1, cor1);
3328 ccr += stl_cd1400updatereg(portp, COR2, cor2);
3329 ccr += stl_cd1400updatereg(portp, COR3, cor3);
3330 if (ccr) {
3331 stl_cd1400ccrwait(portp);
3332 stl_cd1400setreg(portp, CCR, CCR_CORCHANGE);
3333 }
3334 stl_cd1400setreg(portp, COR4, cor4);
3335 stl_cd1400setreg(portp, COR5, cor5);
3336 stl_cd1400setreg(portp, MCOR1, mcor1);
3337 stl_cd1400setreg(portp, MCOR2, mcor2);
3338 if (tiosp->c_ospeed == 0) {
3339 stl_cd1400setreg(portp, MSVR1, 0);
3340 } else {
3341 stl_cd1400setreg(portp, MSVR1, MSVR1_DTR);
3342 stl_cd1400setreg(portp, TCOR, clk);
3343 stl_cd1400setreg(portp, TBPR, div);
3344 stl_cd1400setreg(portp, RCOR, clk);
3345 stl_cd1400setreg(portp, RBPR, div);
3346 }
3347 stl_cd1400setreg(portp, SCHR1, tiosp->c_cc[VSTART]);
3348 stl_cd1400setreg(portp, SCHR2, tiosp->c_cc[VSTOP]);
3349 stl_cd1400setreg(portp, SCHR3, tiosp->c_cc[VSTART]);
3350 stl_cd1400setreg(portp, SCHR4, tiosp->c_cc[VSTOP]);
3351 stl_cd1400setreg(portp, RTPR, rtpr);
3352 mcor1 = stl_cd1400getreg(portp, MSVR1);
3353 if (mcor1 & MSVR1_DCD)
3354 portp->sigs |= TIOCM_CD;
3355 else
3356 portp->sigs &= ~TIOCM_CD;
3357 stl_cd1400setreg(portp, SRER, ((srer & ~sreroff) | sreron));
3358 BRDDISABLE(portp->brdnr);
3359 portp->state &= ~(ASY_RTSFLOWMODE | ASY_CTSFLOWMODE);
3360 portp->state |= ((tiosp->c_cflag & CRTS_IFLOW) ? ASY_RTSFLOWMODE : 0);
3361 portp->state |= ((tiosp->c_cflag & CCTS_OFLOW) ? ASY_CTSFLOWMODE : 0);
3362 stl_ttyoptim(portp, tiosp);
8d77660e 3363 crit_exit();
984263bc
MD		 3364
3365 return(0);
3366}
3367
3368/*****************************************************************************/
3369
3370/*
3371 * Action the flow control as required. The hw and sw args inform the
3372 * routine what flow control methods it should try.
3373 */
3374
3375static void stl_cd1400sendflow(stlport_t *portp, int hw, int sw)
3376{
984263bc
MD		 3377
3378#if STLDEBUG
e3869ec7 3379 kprintf("stl_cd1400sendflow(portp=%x,hw=%d,sw=%d)\n",
984263bc
MD		 3380 (int) portp, hw, sw);
3381#endif
3382
8d77660e 3383 crit_enter();
984263bc
MD		 3384 BRDENABLE(portp->brdnr, portp->pagenr);
3385 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3386
3387 if (sw >= 0) {
3388 stl_cd1400ccrwait(portp);
3389 if (sw) {
3390 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2);
3391 portp->stats.rxxoff++;
3392 } else {
3393 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1);
3394 portp->stats.rxxon++;
3395 }
3396 stl_cd1400ccrwait(portp);
3397 }
3398
3399 if (hw == 0) {
3400 portp->state |= ASY_RTSFLOW;
3401 stl_cd1400setreg(portp, MCOR1,
3402 (stl_cd1400getreg(portp, MCOR1) & 0xf0));
3403 stl_cd1400setreg(portp, MSVR2, 0);
3404 portp->stats.rxrtsoff++;
3405 } else if (hw > 0) {
3406 portp->state &= ~ASY_RTSFLOW;
3407 stl_cd1400setreg(portp, MSVR2, MSVR2_RTS);
3408 stl_cd1400setreg(portp, MCOR1,
3409 (stl_cd1400getreg(portp, MCOR1) | FIFO_RTSTHRESHOLD));
3410 portp->stats.rxrtson++;
3411 }
3412
3413 BRDDISABLE(portp->brdnr);
8d77660e 3414 crit_exit();
984263bc
MD		 3415}
3416
3417/*****************************************************************************/
3418
3419/*
3420 * Return the current state of data flow on this port. This is only
3421 * really interresting when determining if data has fully completed
3422 * transmission or not... This is easy for the cd1400, it accurately
3423 * maintains the busy port flag.
3424 */
3425
3426static int stl_cd1400datastate(stlport_t *portp)
3427{
3428#if STLDEBUG
e3869ec7 3429 kprintf("stl_cd1400datastate(portp=%x)\n", (int) portp);
984263bc
MD		 3430#endif
3431
2038fb68 3432 if (portp == NULL)
984263bc
MD		 3433 return(0);
3434
3435 return((portp->state & ASY_TXBUSY) ? 1 : 0);
3436}
3437
3438/*****************************************************************************/
3439
3440/*
3441 * Set the state of the DTR and RTS signals. Got to do some extra
3442 * work here to deal hardware flow control.
3443 */
3444
3445static void stl_cd1400setsignals(stlport_t *portp, int dtr, int rts)
3446{
3447 unsigned char msvr1, msvr2;
984263bc
MD		 3448
3449#if STLDEBUG
e3869ec7 3450 kprintf("stl_cd1400setsignals(portp=%x,dtr=%d,rts=%d)\n", (int) portp,
984263bc
MD		 3451 dtr, rts);
3452#endif
3453
3454 msvr1 = 0;
3455 msvr2 = 0;
3456 if (dtr > 0)
3457 msvr1 = MSVR1_DTR;
3458 if (rts > 0)
3459 msvr2 = MSVR2_RTS;
3460
8d77660e 3461 crit_enter();
984263bc
MD		 3462 BRDENABLE(portp->brdnr, portp->pagenr);
3463 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3464 if (rts >= 0) {
3465 if (portp->tty.t_cflag & CRTS_IFLOW) {
3466 if (rts == 0) {
3467 stl_cd1400setreg(portp, MCOR1,
3468 (stl_cd1400getreg(portp, MCOR1) & 0xf0));
3469 portp->stats.rxrtsoff++;
3470 } else {
3471 stl_cd1400setreg(portp, MCOR1,
3472 (stl_cd1400getreg(portp, MCOR1) |
3473 FIFO_RTSTHRESHOLD));
3474 portp->stats.rxrtson++;
3475 }
3476 }
3477 stl_cd1400setreg(portp, MSVR2, msvr2);
3478 }
3479 if (dtr >= 0)
3480 stl_cd1400setreg(portp, MSVR1, msvr1);
3481 BRDDISABLE(portp->brdnr);
8d77660e 3482 crit_exit();
984263bc
MD		 3483}
3484
3485/*****************************************************************************/
3486
3487/*
3488 * Get the state of the signals.
3489 */
3490
3491static int stl_cd1400getsignals(stlport_t *portp)
3492{
3493 unsigned char msvr1, msvr2;
8d77660e 3494 int sigs;
984263bc
MD		 3495
3496#if STLDEBUG
e3869ec7 3497 kprintf("stl_cd1400getsignals(portp=%x)\n", (int) portp);
984263bc
MD		 3498#endif
3499
8d77660e 3500 crit_enter();
984263bc
MD		 3501 BRDENABLE(portp->brdnr, portp->pagenr);
3502 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3503 msvr1 = stl_cd1400getreg(portp, MSVR1);
3504 msvr2 = stl_cd1400getreg(portp, MSVR2);
3505 BRDDISABLE(portp->brdnr);
8d77660e 3506 crit_exit();
984263bc
MD		 3507
3508 sigs = 0;
3509 sigs |= (msvr1 & MSVR1_DCD) ? TIOCM_CD : 0;
3510 sigs |= (msvr1 & MSVR1_CTS) ? TIOCM_CTS : 0;
3511 sigs |= (msvr1 & MSVR1_DTR) ? TIOCM_DTR : 0;
3512 sigs |= (msvr2 & MSVR2_RTS) ? TIOCM_RTS : 0;
3513#if 0
3514 sigs |= (msvr1 & MSVR1_RI) ? TIOCM_RI : 0;
3515 sigs |= (msvr1 & MSVR1_DSR) ? TIOCM_DSR : 0;
3516#else
3517 sigs |= TIOCM_DSR;
3518#endif
3519 return(sigs);
3520}
3521
3522/*****************************************************************************/
3523
3524/*
3525 * Enable or disable the Transmitter and/or Receiver.
3526 */
3527
3528static void stl_cd1400enablerxtx(stlport_t *portp, int rx, int tx)
3529{
3530 unsigned char ccr;
984263bc
MD		 3531
3532#if STLDEBUG
e3869ec7 3533 kprintf("stl_cd1400enablerxtx(portp=%x,rx=%d,tx=%d)\n",
984263bc
MD		 3534 (int) portp, rx, tx);
3535#endif
3536
3537 ccr = 0;
3538 if (tx == 0)
3539 ccr |= CCR_TXDISABLE;
3540 else if (tx > 0)
3541 ccr |= CCR_TXENABLE;
3542 if (rx == 0)
3543 ccr |= CCR_RXDISABLE;
3544 else if (rx > 0)
3545 ccr |= CCR_RXENABLE;
3546
8d77660e 3547 crit_enter();
984263bc
MD		 3548 BRDENABLE(portp->brdnr, portp->pagenr);
3549 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3550 stl_cd1400ccrwait(portp);
3551 stl_cd1400setreg(portp, CCR, ccr);
3552 stl_cd1400ccrwait(portp);
3553 BRDDISABLE(portp->brdnr);
8d77660e 3554 crit_exit();
984263bc
MD		 3555}
3556
3557/*****************************************************************************/
3558
3559/*
3560 * Start or stop the Transmitter and/or Receiver.
3561 */
3562
3563static void stl_cd1400startrxtx(stlport_t *portp, int rx, int tx)
3564{
3565 unsigned char sreron, sreroff;
984263bc
MD		 3566
3567#if STLDEBUG
e3869ec7 3568 kprintf("stl_cd1400startrxtx(portp=%x,rx=%d,tx=%d)\n",
984263bc
MD		 3569 (int) portp, rx, tx);
3570#endif
3571
3572 sreron = 0;
3573 sreroff = 0;
3574 if (tx == 0)
3575 sreroff |= (SRER_TXDATA | SRER_TXEMPTY);
3576 else if (tx == 1)
3577 sreron |= SRER_TXDATA;
3578 else if (tx >= 2)
3579 sreron |= SRER_TXEMPTY;
3580 if (rx == 0)
3581 sreroff |= SRER_RXDATA;
3582 else if (rx > 0)
3583 sreron |= SRER_RXDATA;
3584
8d77660e 3585 crit_enter();
984263bc
MD		 3586 BRDENABLE(portp->brdnr, portp->pagenr);
3587 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3588 stl_cd1400setreg(portp, SRER,
3589 ((stl_cd1400getreg(portp, SRER) & ~sreroff) | sreron));
3590 BRDDISABLE(portp->brdnr);
3591 if (tx > 0) {
3592 portp->state |= ASY_TXBUSY;
3593 portp->tty.t_state |= TS_BUSY;
3594 }
8d77660e 3595 crit_exit();
984263bc
MD		 3596}
3597
3598/*****************************************************************************/
3599
3600/*
3601 * Disable all interrupts from this port.
3602 */
3603
3604static void stl_cd1400disableintrs(stlport_t *portp)
3605{
984263bc
MD		 3606
3607#if STLDEBUG
e3869ec7 3608 kprintf("stl_cd1400disableintrs(portp=%x)\n", (int) portp);
984263bc
MD		 3609#endif
3610
8d77660e 3611 crit_enter();
984263bc
MD		 3612 BRDENABLE(portp->brdnr, portp->pagenr);
3613 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3614 stl_cd1400setreg(portp, SRER, 0);
3615 BRDDISABLE(portp->brdnr);
8d77660e 3616 crit_exit();
984263bc
MD		 3617}
3618
3619/*****************************************************************************/
3620
3621static void stl_cd1400sendbreak(stlport_t *portp, long len)
3622{
984263bc
MD		 3623
3624#if STLDEBUG
e3869ec7 3625