1*e5fbc36aSthorpej /* $NetBSD: scn.c,v 1.11 2023/12/20 15:29:07 thorpej Exp $ */
2b610ccb0Srumble
3b610ccb0Srumble /*
4b610ccb0Srumble * Resurrected from the old pc532 port 1/18/2009.
5b610ccb0Srumble *
6b610ccb0Srumble * XXX- The locking in this is probably totally broken. I haven't attempted
7b610ccb0Srumble * to get it right, but it seems to work okay anyhow.
8b610ccb0Srumble */
9b610ccb0Srumble
10b610ccb0Srumble /*
11b610ccb0Srumble * Copyright (c) 1991, 1992, 1993
12b610ccb0Srumble * The Regents of the University of California. All rights reserved.
13b610ccb0Srumble *
14b610ccb0Srumble * Portions of this software were developed by the Computer Systems
15b610ccb0Srumble * Engineering group at Lawrence Berkeley Laboratory under DARPA
16b610ccb0Srumble * contract BG 91-66 and contributed to Berkeley.
17b610ccb0Srumble *
18b610ccb0Srumble * All advertising materials mentioning features or use of this software
19b610ccb0Srumble * must display the following acknowledgement:
20b610ccb0Srumble * This product includes software developed by the University of
21b610ccb0Srumble * California, Lawrence Berkeley Laboratory.
22b610ccb0Srumble *
23b610ccb0Srumble * Redistribution and use in source and binary forms, with or without
24b610ccb0Srumble * modification, are permitted provided that the following conditions
25b610ccb0Srumble * are met:
26b610ccb0Srumble * 1. Redistributions of source code must retain the above copyright
27b610ccb0Srumble * notice, this list of conditions and the following disclaimer.
28b610ccb0Srumble * 2. Redistributions in binary form must reproduce the above copyright
29b610ccb0Srumble * notice, this list of conditions and the following disclaimer in the
30b610ccb0Srumble * documentation and/or other materials provided with the distribution.
31b610ccb0Srumble * 3. Neither the name of the University nor the names of its contributors
32b610ccb0Srumble * may be used to endorse or promote products derived from this software
33b610ccb0Srumble * without specific prior written permission.
34b610ccb0Srumble *
35b610ccb0Srumble * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
36b610ccb0Srumble * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37b610ccb0Srumble * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
38b610ccb0Srumble * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
39b610ccb0Srumble * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
40b610ccb0Srumble * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
41b610ccb0Srumble * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
42b610ccb0Srumble * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
43b610ccb0Srumble * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
44b610ccb0Srumble * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
45b610ccb0Srumble * SUCH DAMAGE.
46b610ccb0Srumble *
47b610ccb0Srumble * from: @(#)com.c 7.5 (Berkeley) 5/16/91
48b610ccb0Srumble */
49b610ccb0Srumble
50b610ccb0Srumble /*
51b610ccb0Srumble * Copyright (c) 1996, 1997 Philip L. Budne.
52b610ccb0Srumble * Copyright (c) 1993 Philip A. Nelson.
53b610ccb0Srumble *
54b610ccb0Srumble * Portions of this software were developed by the Computer Systems
55b610ccb0Srumble * Engineering group at Lawrence Berkeley Laboratory under DARPA
56b610ccb0Srumble * contract BG 91-66 and contributed to Berkeley.
57b610ccb0Srumble *
58b610ccb0Srumble * All advertising materials mentioning features or use of this software
59b610ccb0Srumble * must display the following acknowledgement:
60b610ccb0Srumble * This product includes software developed by the University of
61b610ccb0Srumble * California, Lawrence Berkeley Laboratory.
62b610ccb0Srumble *
63b610ccb0Srumble * Redistribution and use in source and binary forms, with or without
64b610ccb0Srumble * modification, are permitted provided that the following conditions
65b610ccb0Srumble * are met:
66b610ccb0Srumble * 1. Redistributions of source code must retain the above copyright
67b610ccb0Srumble * notice, this list of conditions and the following disclaimer.
68b610ccb0Srumble * 2. Redistributions in binary form must reproduce the above copyright
69b610ccb0Srumble * notice, this list of conditions and the following disclaimer in the
70b610ccb0Srumble * documentation and/or other materials provided with the distribution.
71b610ccb0Srumble * 3. All advertising materials mentioning features or use of this software
72b610ccb0Srumble * must display the following acknowledgement:
73b610ccb0Srumble * This product includes software developed by the University of
74b610ccb0Srumble * California, Berkeley and its contributors.
75b610ccb0Srumble * 4. Neither the name of the University nor the names of its contributors
76b610ccb0Srumble * may be used to endorse or promote products derived from this software
77b610ccb0Srumble * without specific prior written permission.
78b610ccb0Srumble *
79b610ccb0Srumble * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
80b610ccb0Srumble * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
81b610ccb0Srumble * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
82b610ccb0Srumble * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
83b610ccb0Srumble * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
84b610ccb0Srumble * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
85b610ccb0Srumble * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
86b610ccb0Srumble * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
87b610ccb0Srumble * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
88b610ccb0Srumble * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
89b610ccb0Srumble * SUCH DAMAGE.
90b610ccb0Srumble *
91b610ccb0Srumble * from: @(#)com.c 7.5 (Berkeley) 5/16/91
92b610ccb0Srumble */
93b610ccb0Srumble
94b610ccb0Srumble #include <sys/cdefs.h>
95*e5fbc36aSthorpej __KERNEL_RCSID(0, "$NetBSD: scn.c,v 1.11 2023/12/20 15:29:07 thorpej Exp $");
96b610ccb0Srumble
97b610ccb0Srumble #include "opt_ddb.h"
98b610ccb0Srumble #include "opt_kgdb.h"
99b610ccb0Srumble #include "scn.h"
100b610ccb0Srumble
101b610ccb0Srumble #include <sys/param.h>
102b610ccb0Srumble #include <sys/systm.h>
103b610ccb0Srumble #include <sys/ioctl.h>
104b610ccb0Srumble #include <sys/select.h>
105b610ccb0Srumble #include <sys/tty.h>
106b610ccb0Srumble #include <sys/proc.h>
107b610ccb0Srumble #include <sys/file.h>
108b610ccb0Srumble #include <sys/uio.h>
109b610ccb0Srumble #include <sys/kernel.h>
110b610ccb0Srumble #include <sys/syslog.h>
111b610ccb0Srumble #include <sys/types.h>
112b610ccb0Srumble #include <sys/device.h>
113b610ccb0Srumble #include <sys/conf.h>
114b610ccb0Srumble #include <sys/intr.h>
115b610ccb0Srumble #ifdef KGDB
116b610ccb0Srumble #include <sys/kgdb.h>
117b610ccb0Srumble #endif
118b610ccb0Srumble #include <sys/kauth.h>
119b610ccb0Srumble
120b610ccb0Srumble #include <dev/cons.h>
121b610ccb0Srumble
122b610ccb0Srumble #include <machine/autoconf.h>
123b610ccb0Srumble #include <machine/machtype.h>
124b610ccb0Srumble
125b610ccb0Srumble #include <sgimips/dev/scnreg.h>
126b610ccb0Srumble #include <sgimips/dev/scnvar.h>
127b610ccb0Srumble
128b610ccb0Srumble int scn_match(device_t, struct cfdata *, void *);
129b610ccb0Srumble void scn_attach(device_t, device_t, void *);
130b610ccb0Srumble int scnparam(struct tty *, struct termios *);
131b610ccb0Srumble void scnstart(struct tty *);
132b610ccb0Srumble int scnhwiflow(struct tty *, int);
133b610ccb0Srumble
134b610ccb0Srumble void scncnprobe(struct consdev *);
135b610ccb0Srumble void scncninit(struct consdev *);
136b610ccb0Srumble int scncngetc(dev_t);
137b610ccb0Srumble void scncnputc(dev_t, int);
138b610ccb0Srumble void scncnpollc(dev_t, int);
139b610ccb0Srumble int scninit(dev_t, int);
140b610ccb0Srumble void scncnreinit(void *);
141b610ccb0Srumble
142cbab9cadSchs CFATTACH_DECL_NEW(scn, sizeof(struct scn_softc),
143b610ccb0Srumble scn_match, scn_attach, NULL, NULL);
144b610ccb0Srumble
145b610ccb0Srumble extern struct cfdriver scn_cd;
146b610ccb0Srumble
147b610ccb0Srumble dev_type_open(scnopen);
148b610ccb0Srumble dev_type_close(scnclose);
149b610ccb0Srumble dev_type_read(scnread);
150b610ccb0Srumble dev_type_write(scnwrite);
151b610ccb0Srumble dev_type_ioctl(scnioctl);
152b610ccb0Srumble dev_type_stop(scnstop);
153b610ccb0Srumble dev_type_tty(scntty);
154b610ccb0Srumble dev_type_poll(scnpoll);
155b610ccb0Srumble
156b610ccb0Srumble const struct cdevsw scn_cdevsw = {
157a68f9396Sdholland .d_open = scnopen,
158a68f9396Sdholland .d_close = scnclose,
159a68f9396Sdholland .d_read = scnread,
160a68f9396Sdholland .d_write = scnwrite,
161a68f9396Sdholland .d_ioctl = scnioctl,
162a68f9396Sdholland .d_stop = scnstop,
163a68f9396Sdholland .d_tty = scntty,
164a68f9396Sdholland .d_poll = scnpoll,
165a68f9396Sdholland .d_mmap = nommap,
166a68f9396Sdholland .d_kqfilter = ttykqfilter,
167f9228f42Sdholland .d_discard = nodiscard,
168a68f9396Sdholland .d_flag = D_TTY
169b610ccb0Srumble };
170b610ccb0Srumble
171b610ccb0Srumble struct consdev scn_cn = {
172b610ccb0Srumble scncnprobe,
173b610ccb0Srumble scncninit,
174b610ccb0Srumble scncngetc,
175b610ccb0Srumble scncnputc,
176b610ccb0Srumble scncnpollc,
177b610ccb0Srumble NULL,
178b610ccb0Srumble NULL,
179b610ccb0Srumble NULL,
180b610ccb0Srumble NODEV,
181b610ccb0Srumble CN_NORMAL
182b610ccb0Srumble };
183b610ccb0Srumble
184b610ccb0Srumble #ifndef CONSOLE_SPEED
185b610ccb0Srumble #define CONSOLE_SPEED TTYDEF_SPEED
186b610ccb0Srumble #endif
187b610ccb0Srumble
188b610ccb0Srumble #ifndef SCNDEF_CFLAG
189b610ccb0Srumble #define SCNDEF_CFLAG TTYDEF_CFLAG
190b610ccb0Srumble #endif
191b610ccb0Srumble
192b610ccb0Srumble #ifdef CPU30MHZ
193b610ccb0Srumble #define RECOVER() __asm volatile("bispsrw 0x800" : : : "cc")
194b610ccb0Srumble #else
195b610ccb0Srumble #define RECOVER()
196b610ccb0Srumble #endif
197b610ccb0Srumble
198b610ccb0Srumble int scndefaultrate = TTYDEF_SPEED;
199b610ccb0Srumble int scnconsrate = CONSOLE_SPEED;
200b610ccb0Srumble
201b610ccb0Srumble static inline struct scn_softc *
SOFTC(int unit)202b610ccb0Srumble SOFTC(int unit)
203b610ccb0Srumble {
204b610ccb0Srumble if (unit < 0 || unit >= scn_cd.cd_ndevs)
205b610ccb0Srumble return (NULL);
206cbab9cadSchs return device_private(scn_cd.cd_devs[unit]);
207b610ccb0Srumble }
208b610ccb0Srumble
209b610ccb0Srumble static int scnintr(void *);
210b610ccb0Srumble static void scnrxintr(void *);
211b610ccb0Srumble static int scn_rxintr(struct scn_softc *);
212b610ccb0Srumble static void scnsoft(void *);
213b610ccb0Srumble static void scn_setchip(struct scn_softc *sc);
214b610ccb0Srumble static int scniter(int *, int, int*, int*, struct chan *, int);
215b610ccb0Srumble static int scn_config(int, int, int, int, u_char, u_char);
216b610ccb0Srumble static void scn_rxenable(struct scn_softc *);
217b610ccb0Srumble static void scn_rxdisable(struct scn_softc *);
218b610ccb0Srumble static void dcd_int(struct scn_softc *, struct tty *, u_char);
219b610ccb0Srumble static void scnoverrun(int, long *, const char *);
220b610ccb0Srumble static u_char opbits(struct scn_softc *, int);
221b610ccb0Srumble
222b610ccb0Srumble static void *scnsir = NULL; /* s/w intr cookie */
223b610ccb0Srumble #define setsoftscn() softint_schedule(scnsir)
224b610ccb0Srumble
225b610ccb0Srumble #ifdef SCN_TIMING
226b610ccb0Srumble /*
227b610ccb0Srumble * Keep timing info on latency of software interrupt used by
228b610ccb0Srumble * the ringbuf code to empty ring buffer.
229b610ccb0Srumble * "getinfo" program reads data from /dev/kmem.
230b610ccb0Srumble */
231b610ccb0Srumble static struct timeval tstart;
232b610ccb0Srumble #define NJITTER 100
233b610ccb0Srumble int scn_njitter = NJITTER;
234b610ccb0Srumble int scn_jitter[NJITTER];
235b610ccb0Srumble #endif
236b610ccb0Srumble
237b610ccb0Srumble #define SCN_CLOCK 3686400 /* input clock */
238b610ccb0Srumble
239b610ccb0Srumble /* speed table groups ACR[7] */
240b610ccb0Srumble #define GRP_A 0
241b610ccb0Srumble #define GRP_B ACR_BRG
242b610ccb0Srumble
243b610ccb0Srumble /* combo of MR0[2:0] and ACR[7] */
244b610ccb0Srumble #define MODE0A MR0_MODE_0
245b610ccb0Srumble #define MODE0B (MR0_MODE_0|ACR_BRG)
246b610ccb0Srumble #define MODE1A MR0_MODE_1
247b610ccb0Srumble #define MODE1B (MR0_MODE_1|ACR_BRG)
248b610ccb0Srumble #define MODE2A MR0_MODE_2
249b610ccb0Srumble #define MODE2B (MR0_MODE_2|ACR_BRG)
250b610ccb0Srumble
251b610ccb0Srumble #define ANYMODE -1
252b610ccb0Srumble #define DEFMODE(C92) MODE0A /* use MODE4A if 26c92? */
253b610ccb0Srumble
254b610ccb0Srumble /* speed code for Counter/Timer (all modes, groups) */
255b610ccb0Srumble #define USE_CT 0xd
256b610ccb0Srumble
257b610ccb0Srumble /*
258b610ccb0Srumble * Rate table, ordered by speed, then mode.
259b610ccb0Srumble * NOTE: ordering of modes must be done carefully!
260b610ccb0Srumble */
261b610ccb0Srumble struct tabent {
262b610ccb0Srumble int32_t speed;
263b610ccb0Srumble int16_t code;
264b610ccb0Srumble int16_t mode;
265b610ccb0Srumble } table[] = {
266b610ccb0Srumble { 50, 0x0, MODE0A },
267b610ccb0Srumble { 75, 0x0, MODE0B },
268b610ccb0Srumble { 110, 0x1, MODE0A },
269b610ccb0Srumble { 110, 0x1, MODE0B },
270b610ccb0Srumble { 110, 0x1, MODE1A },
271b610ccb0Srumble { 110, 0x1, MODE1B },
272b610ccb0Srumble { 134, 0x2, MODE0A }, /* 134.5 */
273b610ccb0Srumble { 134, 0x2, MODE0B }, /* 134.5 */
274b610ccb0Srumble { 134, 0x2, MODE1A }, /* 134.5 */
275b610ccb0Srumble { 134, 0x2, MODE1B }, /* 134.5 */
276b610ccb0Srumble { 150, 0x3, MODE0A },
277b610ccb0Srumble { 150, 0x3, MODE0A },
278b610ccb0Srumble { 200, 0x3, MODE0A },
279b610ccb0Srumble { 300, 0x4, MODE0A },
280b610ccb0Srumble { 300, 0x4, MODE0B },
281b610ccb0Srumble { 300, 0x0, MODE1A },
282b610ccb0Srumble { 450, 0x0, MODE1B },
283b610ccb0Srumble { 600, 0x5, MODE0A },
284b610ccb0Srumble { 600, 0x5, MODE0B },
285b610ccb0Srumble { 880, 0x1, MODE2A },
286b610ccb0Srumble { 880, 0x1, MODE2B },
287b610ccb0Srumble { 900, 0x3, MODE1B },
288b610ccb0Srumble { 1050, 0x7, MODE0A },
289b610ccb0Srumble { 1050, 0x7, MODE1A },
290b610ccb0Srumble { 1076, 0x2, MODE2A },
291b610ccb0Srumble { 1076, 0x2, MODE2B },
292b610ccb0Srumble { 1200, 0x6, MODE0A },
293b610ccb0Srumble { 1200, 0x6, MODE0B },
294b610ccb0Srumble { 1200, 0x3, MODE1A },
295b610ccb0Srumble { 1800, 0xa, MODE0B },
296b610ccb0Srumble { 1800, 0x4, MODE1A },
297b610ccb0Srumble { 1800, 0x4, MODE1B },
298b610ccb0Srumble { 2000, 0x7, MODE0B },
299b610ccb0Srumble { 2000, 0x7, MODE1B },
300b610ccb0Srumble { 2400, 0x8, MODE0A },
301b610ccb0Srumble { 2400, 0x8, MODE0B },
302b610ccb0Srumble { 3600, 0x5, MODE1A },
303b610ccb0Srumble { 3600, 0x5, MODE1B },
304b610ccb0Srumble { 4800, 0x9, MODE2A },
305b610ccb0Srumble { 4800, 0x9, MODE2B },
306b610ccb0Srumble { 4800, 0x9, MODE0A },
307b610ccb0Srumble { 4800, 0x9, MODE0B },
308b610ccb0Srumble { 7200, 0xa, MODE0A },
309b610ccb0Srumble { 7200, 0x0, MODE2B },
310b610ccb0Srumble { 7200, 0x6, MODE1A },
311b610ccb0Srumble { 7200, 0x6, MODE1B },
312b610ccb0Srumble { 9600, 0xb, MODE2A },
313b610ccb0Srumble { 9600, 0xb, MODE2B },
314b610ccb0Srumble { 9600, 0xb, MODE0A },
315b610ccb0Srumble { 9600, 0xb, MODE0B },
316b610ccb0Srumble { 9600, 0xd, MODE1A }, /* use C/T as entre' to mode1 */
317b610ccb0Srumble { 9600, 0xd, MODE1B }, /* use C/T as entre' to mode1 */
318b610ccb0Srumble { 14400, 0x3, MODE2B },
319b610ccb0Srumble { 14400, 0x8, MODE1A },
320b610ccb0Srumble { 14400, 0x8, MODE1B },
321b610ccb0Srumble { 19200, 0x3, MODE2A },
322b610ccb0Srumble { 19200, 0xc, MODE2B },
323b610ccb0Srumble { 19200, 0xc, MODE0B },
324b610ccb0Srumble { 19200, 0xd, MODE1A }, /* use C/T as entre' to mode1 */
325b610ccb0Srumble { 19200, 0xd, MODE1B }, /* use C/T as entre' to mode1 */
326b610ccb0Srumble { 28800, 0x4, MODE2A },
327b610ccb0Srumble { 28800, 0x4, MODE2B },
328b610ccb0Srumble { 28800, 0x9, MODE1A },
329b610ccb0Srumble { 28800, 0x9, MODE1B },
330b610ccb0Srumble { 38400, 0xc, MODE2A },
331b610ccb0Srumble { 38400, 0xc, MODE0A },
332b610ccb0Srumble { 57600, 0x5, MODE2A },
333b610ccb0Srumble { 57600, 0x5, MODE2B },
334b610ccb0Srumble { 57600, 0xb, MODE1A },
335b610ccb0Srumble { 57600, 0xb, MODE1B },
336b610ccb0Srumble { 115200, 0x6, MODE2A },
337b610ccb0Srumble { 115200, 0x6, MODE2B },
338b610ccb0Srumble { 115200, 0xc, MODE1B },
339b610ccb0Srumble { 230400, 0xc, MODE1A }
340b610ccb0Srumble };
341b610ccb0Srumble #define TABENTRIES (sizeof(table)/sizeof(table[0]))
342b610ccb0Srumble
343b610ccb0Srumble /*
344b610ccb0Srumble * boolean for speed codes which are identical in both A/B BRG groups
345b610ccb0Srumble * in all modes
346b610ccb0Srumble */
347b610ccb0Srumble static u_char bothgroups[16] = {
348b610ccb0Srumble 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1
349b610ccb0Srumble };
350b610ccb0Srumble
351b610ccb0Srumble /*
352b610ccb0Srumble * Manually constructed divisors table
353b610ccb0Srumble * for minimum error (from some of Dave Rand's code)
354b610ccb0Srumble */
355b610ccb0Srumble const struct {
356b610ccb0Srumble uint16_t speed;
357b610ccb0Srumble uint16_t div;
358b610ccb0Srumble } divs[] = {
359b610ccb0Srumble { 50, 2303 }, /* 2304 is exact?? */
360b610ccb0Srumble { 110, 1047 }, /* Should be 1047.27 */
361b610ccb0Srumble { 134, 857 }, /* Should be 856.505576 */
362b610ccb0Srumble { 1050, 110 }, /* Should be 109.7142857 */
363b610ccb0Srumble { 2000, 57 } /* Should be 57.6 */
364b610ccb0Srumble };
365b610ccb0Srumble #define DIVS (sizeof(divs)/sizeof(divs[0]))
366b610ccb0Srumble
367b610ccb0Srumble /*
368b610ccb0Srumble * minor unit bit decode:
369b610ccb0Srumble * CxxxUUU
370b610ccb0Srumble *
371b610ccb0Srumble * C - carrier
372b610ccb0Srumble * 0 - delay open until carrier high
373b610ccb0Srumble * 1 - allow open with carrier low
374b610ccb0Srumble * UUU - unit 0-7
375b610ccb0Srumble */
376b610ccb0Srumble
377b610ccb0Srumble #define DEV_UNIT(x) (minor(x) & 0x7)
378b610ccb0Srumble #define DEV_DIALOUT(x) (minor(x) & 0x80)
379b610ccb0Srumble
380b610ccb0Srumble #define SCN_MAXDUART 4
381b610ccb0Srumble static struct duart scn_duart[SCN_MAXDUART];
382b610ccb0Srumble
383b610ccb0Srumble #ifdef KGDB
384b610ccb0Srumble extern int kgdb_dev;
385b610ccb0Srumble extern int kgdb_rate;
386b610ccb0Srumble extern int kgdb_debug_init;
387b610ccb0Srumble #endif
388b610ccb0Srumble
389b610ccb0Srumble /* XXXXX - fix this */
390b610ccb0Srumble #define splrtty() spltty()
391b610ccb0Srumble
392b610ccb0Srumble /* RS-232 configuration routines */
393b610ccb0Srumble
394b610ccb0Srumble /*
395b610ccb0Srumble * set chip parameters, or mark for delayed change.
396b610ccb0Srumble * called at spltty() or on TxEMPTY interrupt.
397b610ccb0Srumble *
398b610ccb0Srumble * Reads current values to avoid glitches from redundant sets.
399b610ccb0Srumble * Perhaps should save last value set to avoid read/write? NOTE:
400b610ccb0Srumble * Would still need to do read if write not needed to advance MR
401b610ccb0Srumble * pointer.
402b610ccb0Srumble *
403b610ccb0Srumble * new 2/97 -plb
404b610ccb0Srumble */
405b610ccb0Srumble
406b610ccb0Srumble static void
scn_setchip(struct scn_softc * sc)407b610ccb0Srumble scn_setchip(struct scn_softc *sc)
408b610ccb0Srumble {
409b610ccb0Srumble struct duart *dp;
410b610ccb0Srumble u_char acr, csr, mr1, mr2;
411b610ccb0Srumble int chan;
412b610ccb0Srumble
413b610ccb0Srumble if (sc->sc_tty && (sc->sc_tty->t_state & TS_BUSY)) {
414b610ccb0Srumble sc->sc_heldchanges = 1;
415b610ccb0Srumble return;
416b610ccb0Srumble }
417b610ccb0Srumble
418b610ccb0Srumble chan = sc->sc_channel;
419b610ccb0Srumble dp = sc->sc_duart;
420b610ccb0Srumble if (dp->type == SC26C92) {
421b610ccb0Srumble u_char nmr0a, mr0a;
422b610ccb0Srumble
423b610ccb0Srumble /* input rate high enough so 64 bit time watchdog not
424b610ccb0Srumble * onerous? */
425b610ccb0Srumble if (dp->chan[chan].ispeed >= 1200) {
426b610ccb0Srumble /* set FIFO threshold at 6 for other
427b610ccb0Srumble * thresholds we could have to set MR1_FFULL
428b610ccb0Srumble */
429b610ccb0Srumble dp->chan[chan].mr0 |= MR0_RXWD | MR0_RXINT;
430b610ccb0Srumble } else {
431b610ccb0Srumble dp->chan[chan].mr0 &= ~(MR0_RXWD | MR0_RXINT);
432b610ccb0Srumble }
433b610ccb0Srumble
434b610ccb0Srumble /* select BRG mode (MR0A only) */
435b610ccb0Srumble nmr0a = dp->chan[0].mr0 | (dp->mode & MR0_MODE);
436b610ccb0Srumble
437b610ccb0Srumble dp->base[CH_CR] = CR_CMD_MR0;
438b610ccb0Srumble RECOVER();
439b610ccb0Srumble
440b610ccb0Srumble mr0a = dp->base[CH_MR];
441b610ccb0Srumble if (mr0a != nmr0a) {
442b610ccb0Srumble dp->base[CH_CR] = CR_CMD_MR0;
443b610ccb0Srumble RECOVER();
444b610ccb0Srumble dp->base[CH_MR] = nmr0a;
445b610ccb0Srumble }
446b610ccb0Srumble
447b610ccb0Srumble if (chan) { /* channel B? */
448b610ccb0Srumble u_char mr0b;
449b610ccb0Srumble
450b610ccb0Srumble sc->sc_chbase[CH_CR] = CR_CMD_MR0;
451b610ccb0Srumble RECOVER();
452b610ccb0Srumble mr0b = dp->base[CH_MR];
453b610ccb0Srumble
454b610ccb0Srumble if (dp->chan[chan].mr0 != mr0b) {
455b610ccb0Srumble sc->sc_chbase[CH_CR] = CR_CMD_MR0;
456b610ccb0Srumble RECOVER();
457b610ccb0Srumble sc->sc_chbase[CH_MR] = dp->chan[chan].mr0;
458b610ccb0Srumble }
459b610ccb0Srumble }
460b610ccb0Srumble } else {
461b610ccb0Srumble sc->sc_chbase[CH_CR] = CR_CMD_MR1;
462b610ccb0Srumble RECOVER();
463b610ccb0Srumble }
464b610ccb0Srumble
465b610ccb0Srumble mr1 = sc->sc_chbase[CH_MR];
466b610ccb0Srumble mr2 = sc->sc_chbase[CH_MR];
467b610ccb0Srumble if (mr1 != dp->chan[chan].new_mr1 ||
468b610ccb0Srumble mr2 != dp->chan[chan].new_mr2) {
469b610ccb0Srumble sc->sc_chbase[CH_CR] = CR_CMD_MR1;
470b610ccb0Srumble RECOVER();
471b610ccb0Srumble sc->sc_chbase[CH_MR] = dp->chan[chan].new_mr1;
472b610ccb0Srumble sc->sc_chbase[CH_MR] = dp->chan[chan].new_mr2;
473b610ccb0Srumble }
474b610ccb0Srumble
475b610ccb0Srumble acr = dp->acr | (dp->mode & ACR_BRG);
476b610ccb0Srumble dp->base[DU_ACR] = acr; /* write-only reg! */
477b610ccb0Srumble
478b610ccb0Srumble /* set speed codes */
479b610ccb0Srumble csr = (dp->chan[chan].icode<<4) | dp->chan[chan].ocode;
480b610ccb0Srumble if (sc->sc_chbase[CH_CSR] != csr) {
481b610ccb0Srumble sc->sc_chbase[CH_CSR] = csr;
482b610ccb0Srumble }
483b610ccb0Srumble
484b610ccb0Srumble /* see if counter/timer in use */
485b610ccb0Srumble if (dp->counter &&
486b610ccb0Srumble (dp->chan[0].icode == USE_CT || dp->chan[0].ocode == USE_CT ||
487b610ccb0Srumble dp->chan[1].icode == USE_CT || dp->chan[1].ocode == USE_CT)) {
488b610ccb0Srumble
489b610ccb0Srumble /* program counter/timer only if necessary */
490b610ccb0Srumble if (dp->counter != dp->ocounter) {
491b610ccb0Srumble uint16_t div;
492b610ccb0Srumble #ifdef DIVS
493b610ccb0Srumble int i;
494b610ccb0Srumble
495b610ccb0Srumble /* look for precalculated rate, for minimum error */
496b610ccb0Srumble for (i = 0; i < DIVS && divs[i].speed <= dp->counter; i++) {
497b610ccb0Srumble if (divs[i].speed == dp->counter) {
498b610ccb0Srumble div = divs[i].div;
499b610ccb0Srumble goto found;
500b610ccb0Srumble }
501b610ccb0Srumble }
502b610ccb0Srumble #endif
503b610ccb0Srumble
504b610ccb0Srumble /* not found in table; calculate a value (rounding up) */
505b610ccb0Srumble div = ((long)SCN_CLOCK/16/2 + dp->counter/2) / dp->counter;
506b610ccb0Srumble
507b610ccb0Srumble found:
508b610ccb0Srumble /* halt before loading? may ALWAYS glitch?
509b610ccb0Srumble * reload race may only sometimes glitch??
510b610ccb0Srumble */
511b610ccb0Srumble dp->base[DU_CTUR] = div >> 8;
512b610ccb0Srumble dp->base[DU_CTLR] = div & 255;
513b610ccb0Srumble if (dp->ocounter == 0) {
514b610ccb0Srumble /* not previously used? */
515b610ccb0Srumble u_char temp;
516b610ccb0Srumble /* start C/T running */
517b610ccb0Srumble temp = dp->base[DU_CSTRT];
51821af650cSchristos __USE(temp);
519b610ccb0Srumble }
520b610ccb0Srumble dp->ocounter = dp->counter;
521b610ccb0Srumble }
522b610ccb0Srumble } else {
523b610ccb0Srumble /* counter not in use; mark as free */
524b610ccb0Srumble dp->counter = 0;
525b610ccb0Srumble }
526b610ccb0Srumble sc->sc_heldchanges = 0;
527b610ccb0Srumble
528b610ccb0Srumble /*
529b610ccb0Srumble * delay a tiny bit to try and avoid tx glitching.
530b610ccb0Srumble * I know we're at spltty(), but this is much better than the
531b610ccb0Srumble * old version used DELAY((96000 / out_speed) * 10000)
532b610ccb0Srumble * -plb
533b610ccb0Srumble */
534b610ccb0Srumble DELAY(10);
535b610ccb0Srumble }
536b610ccb0Srumble
537b610ccb0Srumble /*
538b610ccb0Srumble * iterator function for speeds.
539b610ccb0Srumble * (could be called "findnextcode")
540b610ccb0Srumble * Returns sequence of possible speed codes for a given rate.
541b610ccb0Srumble * should set index to zero before first call.
542b610ccb0Srumble *
543b610ccb0Srumble * Could be implemented as a "checkspeed()" function called
544b610ccb0Srumble * to evaluate table entries, BUT this allows more variety in
545b610ccb0Srumble * use of C/T with fewer table entries.
546b610ccb0Srumble */
547b610ccb0Srumble
548b610ccb0Srumble static int
scniter(int * index,int wanted,int * counter,int * mode,struct chan * other,int c92)549b610ccb0Srumble scniter(int *index, int wanted, int *counter, int *mode, struct chan *other,
550b610ccb0Srumble int c92)
551b610ccb0Srumble {
552b610ccb0Srumble
553b610ccb0Srumble while (*index < TABENTRIES) {
554b610ccb0Srumble struct tabent *tp;
555b610ccb0Srumble
556b610ccb0Srumble tp = table + (*index)++;
557b610ccb0Srumble if (tp->speed != wanted)
558b610ccb0Srumble continue;
559b610ccb0Srumble
560b610ccb0Srumble /* if not a 26C92 only look at MODE0 entries */
561b610ccb0Srumble if (!c92 && (tp->mode & MR0_MODE) != MR0_MODE_0)
562b610ccb0Srumble continue;
563b610ccb0Srumble
564b610ccb0Srumble /*
565b610ccb0Srumble * check mode;
566b610ccb0Srumble * OK if this table entry for current mode, or mode not
567b610ccb0Srumble * yet set, or other channel's rates are available in both
568b610ccb0Srumble * A and B groups.
569b610ccb0Srumble */
570b610ccb0Srumble
571b610ccb0Srumble if (tp->mode == *mode || *mode == ANYMODE ||
572b610ccb0Srumble (other != NULL && (tp->mode & MR0_MODE) == (*mode & MR0_MODE) &&
573b610ccb0Srumble bothgroups[other->icode] && bothgroups[other->ocode])) {
574b610ccb0Srumble /*
575b610ccb0Srumble * for future table entries specifying
576b610ccb0Srumble * use of counter/timer
577b610ccb0Srumble */
578b610ccb0Srumble if (tp->code == USE_CT) {
579b610ccb0Srumble if (*counter != wanted && *counter != 0)
580b610ccb0Srumble continue; /* counter busy */
581b610ccb0Srumble *counter = wanted;
582b610ccb0Srumble }
583b610ccb0Srumble *mode = tp->mode;
584b610ccb0Srumble return tp->code;
585b610ccb0Srumble }
586b610ccb0Srumble }
587b610ccb0Srumble
588b610ccb0Srumble /* here after returning all applicable table entries */
589b610ccb0Srumble /* XXX return sequence of USE_CT with all possible modes?? */
590b610ccb0Srumble if ((*index)++ == TABENTRIES) {
591b610ccb0Srumble /* Max C/T rate (even on 26C92?) is 57600 */
592b610ccb0Srumble if (wanted <= 57600 && (*counter == wanted || *counter == 0)) {
593b610ccb0Srumble *counter = wanted;
594b610ccb0Srumble return USE_CT;
595b610ccb0Srumble }
596b610ccb0Srumble }
597b610ccb0Srumble
598b610ccb0Srumble return -1; /* FAIL */
599b610ccb0Srumble }
600b610ccb0Srumble
601b610ccb0Srumble /*
602b610ccb0Srumble * calculate configuration
603b610ccb0Srumble * rewritten 2/97 -plb
604b610ccb0Srumble */
605b610ccb0Srumble static int
scn_config(int unit,int chan,int ispeed,int ospeed,u_char mr1,u_char mr2)606b610ccb0Srumble scn_config(int unit, int chan, int ispeed, int ospeed, u_char mr1, u_char mr2)
607b610ccb0Srumble {
608b610ccb0Srumble struct scn_softc *sc;
609b610ccb0Srumble struct duart *dp;
610b610ccb0Srumble int other; /* opposite of chan */
611b610ccb0Srumble int mode;
612b610ccb0Srumble int counter;
613b610ccb0Srumble int i, o; /* input, output iterator indexes */
614b610ccb0Srumble int ic, oc; /* input, output codes */
615b610ccb0Srumble struct chan *ocp; /* other duart channel */
616b610ccb0Srumble struct tty *otp; /* other channel tty struct */
617b610ccb0Srumble int c92; /* true if duart is sc26c92 */
618b610ccb0Srumble int s;
619b610ccb0Srumble
620b610ccb0Srumble /* Set up softc pointer. */
621b610ccb0Srumble if (unit >= scn_cd.cd_ndevs)
622b610ccb0Srumble return ENXIO;
623b610ccb0Srumble sc = SOFTC(unit);
624b610ccb0Srumble chan = sc->sc_channel;
625b610ccb0Srumble other = chan ^ 1;
626b610ccb0Srumble dp = sc->sc_duart;
627b610ccb0Srumble ocp = &dp->chan[other];
628b610ccb0Srumble otp = ocp->tty;
629b610ccb0Srumble c92 = (dp->type == SC26C92);
630b610ccb0Srumble
631b610ccb0Srumble /*
632b610ccb0Srumble * Right now the first combination that works is used.
633b610ccb0Srumble * Perhaps it should search entire solution space for "best"
634b610ccb0Srumble * combination. For example, use heuristic weighting of mode
635b610ccb0Srumble * preferences, and use of counter timer?
636b610ccb0Srumble *
637b610ccb0Srumble * For example right now with 2681/2692 when default rate is
638b610ccb0Srumble * 9600 and other channel is closed setting 19200 will pick
639b610ccb0Srumble * mode 0a and use counter/timer. Better solution might be
640b610ccb0Srumble * mode 0b, leaving counter/timer free!
641b610ccb0Srumble *
642b610ccb0Srumble * When other channel is open might want to prefer
643b610ccb0Srumble * leaving counter timer free, or not flipping A/B group?
644b610ccb0Srumble */
645b610ccb0Srumble if (otp && (otp->t_state & TS_ISOPEN)) {
646b610ccb0Srumble
647b610ccb0Srumble /*
648b610ccb0Srumble * Other channel open;
649b610ccb0Srumble * Find speed codes compatible with current mode/counter.
650b610ccb0Srumble */
651b610ccb0Srumble
652b610ccb0Srumble i = 0;
653b610ccb0Srumble for (;;) {
654b610ccb0Srumble mode = dp->mode;
655b610ccb0Srumble counter = dp->counter;
656b610ccb0Srumble
657b610ccb0Srumble /* NOTE: pass other chan pointer to allow group flipping */
658b610ccb0Srumble ic = scniter(&i, ispeed, &counter, &mode, ocp, c92);
659b610ccb0Srumble if (ic == -1)
660b610ccb0Srumble break;
661b610ccb0Srumble
662b610ccb0Srumble o = 0;
663b610ccb0Srumble if ((oc = scniter(&o, ospeed, &counter,
664b610ccb0Srumble &mode, NULL, c92)) != -1) {
665b610ccb0Srumble /*
666b610ccb0Srumble * take first match
667b610ccb0Srumble *
668b610ccb0Srumble * Perhaps calculate heuristic "score",
669b610ccb0Srumble * save score,codes,mode,counter if score
670b610ccb0Srumble * better than previous best?
671b610ccb0Srumble */
672b610ccb0Srumble goto gotit;
673b610ccb0Srumble }
674b610ccb0Srumble }
675b610ccb0Srumble /* XXX try looping for ospeed? */
676b610ccb0Srumble } else {
677b610ccb0Srumble /* other channel closed */
678b610ccb0Srumble int oo, oi; /* other input, output iterators */
679b610ccb0Srumble int oic, ooc; /* other input, output codes */
680b610ccb0Srumble
681b610ccb0Srumble /*
682b610ccb0Srumble * Here when other channel closed. Finds first
683b610ccb0Srumble * combination that will allow other channel to be opened
684b610ccb0Srumble * (with defaults) and fits our needs.
685b610ccb0Srumble */
686b610ccb0Srumble oi = 0;
687b610ccb0Srumble for (;;) {
688b610ccb0Srumble mode = ANYMODE;
689b610ccb0Srumble counter = 0;
690b610ccb0Srumble
691b610ccb0Srumble oic = scniter(&oi, ocp->ispeed, &counter, &mode, NULL, c92);
692b610ccb0Srumble if (oic == -1)
693b610ccb0Srumble break;
694b610ccb0Srumble
695b610ccb0Srumble oo = 0;
696b610ccb0Srumble while ((ooc = scniter(&oo, ocp->ospeed, &counter,
697b610ccb0Srumble &mode, NULL, c92)) != -1) {
698b610ccb0Srumble i = 0;
699b610ccb0Srumble while ((ic = scniter(&i, ispeed, &counter,
700b610ccb0Srumble &mode, NULL, c92)) != -1) {
701b610ccb0Srumble o = 0;
702b610ccb0Srumble if ((oc = scniter(&o, ospeed, &counter,
703b610ccb0Srumble &mode, NULL, c92)) != -1) {
704b610ccb0Srumble /*
705b610ccb0Srumble * take first match
706b610ccb0Srumble *
707b610ccb0Srumble * Perhaps calculate heuristic
708b610ccb0Srumble * "score", save
709b610ccb0Srumble * score,codes,mode,counter
710b610ccb0Srumble * if score better than
711b610ccb0Srumble * previous best?
712b610ccb0Srumble */
713b610ccb0Srumble s = spltty();
714b610ccb0Srumble dp->chan[other].icode = oic;
715b610ccb0Srumble dp->chan[other].ocode = ooc;
716b610ccb0Srumble goto gotit2;
717b610ccb0Srumble }
718b610ccb0Srumble }
719b610ccb0Srumble }
720b610ccb0Srumble }
721b610ccb0Srumble }
722b610ccb0Srumble return EINVAL;
723b610ccb0Srumble
724b610ccb0Srumble gotit:
725b610ccb0Srumble s = spltty();
726b610ccb0Srumble gotit2:
727b610ccb0Srumble dp->chan[chan].new_mr1 = mr1;
728b610ccb0Srumble dp->chan[chan].new_mr2 = mr2;
729b610ccb0Srumble dp->chan[chan].ispeed = ispeed;
730b610ccb0Srumble dp->chan[chan].ospeed = ospeed;
731b610ccb0Srumble dp->chan[chan].icode = ic;
732b610ccb0Srumble dp->chan[chan].ocode = oc;
733b610ccb0Srumble if (mode == ANYMODE) /* no mode selected?? */
734b610ccb0Srumble mode = DEFMODE(c92);
735b610ccb0Srumble dp->mode = mode;
736b610ccb0Srumble dp->counter = counter;
737b610ccb0Srumble
738b610ccb0Srumble scn_setchip(sc); /* set chip now, if possible */
739b610ccb0Srumble splx(s);
740b610ccb0Srumble return (0);
741b610ccb0Srumble }
742b610ccb0Srumble
743b610ccb0Srumble int
scn_match(device_t parent,struct cfdata * cf,void * aux)744b610ccb0Srumble scn_match(device_t parent, struct cfdata *cf, void *aux)
745b610ccb0Srumble {
746b610ccb0Srumble struct mainbus_attach_args *ma = aux;
747b610ccb0Srumble
748b610ccb0Srumble if ((mach_type == MACH_SGI_IP6 || mach_type == MACH_SGI_IP10) &&
749b610ccb0Srumble ma->ma_addr == 0x1fb80004)
750b610ccb0Srumble return (1);
751b610ccb0Srumble
752b610ccb0Srumble return (0);
753b610ccb0Srumble }
754b610ccb0Srumble
755b610ccb0Srumble /*
756b610ccb0Srumble * No need to make scn_rx{en,dis}able too efficient,
757b610ccb0Srumble * they're only called on setup, open & close!
758b610ccb0Srumble */
759b610ccb0Srumble static inline void
scn_rxenable(struct scn_softc * sc)760b610ccb0Srumble scn_rxenable(struct scn_softc *sc)
761b610ccb0Srumble {
762b610ccb0Srumble struct duart *dp;
763b610ccb0Srumble int channel;
764b610ccb0Srumble
765b610ccb0Srumble dp = sc->sc_duart;
766b610ccb0Srumble channel = sc->sc_channel;
767b610ccb0Srumble
768b610ccb0Srumble /* Outputs wire-ored and connected to ICU input for fast rx interrupt. */
769b610ccb0Srumble if (channel == 0)
770b610ccb0Srumble dp->opcr |= OPCR_OP4_RXRDYA;
771b610ccb0Srumble else
772b610ccb0Srumble dp->opcr |= OPCR_OP5_RXRDYB;
773b610ccb0Srumble dp->base[DU_OPCR] = dp->opcr;
774b610ccb0Srumble dp->imr |= sc->sc_rx_int;
775b610ccb0Srumble dp->base[DU_IMR] = dp->imr;
776b610ccb0Srumble }
777b610ccb0Srumble
778b610ccb0Srumble static inline void
scn_rxdisable(struct scn_softc * sc)779b610ccb0Srumble scn_rxdisable(struct scn_softc *sc)
780b610ccb0Srumble {
781b610ccb0Srumble struct duart *dp;
782b610ccb0Srumble int channel;
783b610ccb0Srumble
784b610ccb0Srumble dp = sc->sc_duart;
785b610ccb0Srumble channel = sc->sc_channel;
786b610ccb0Srumble
787b610ccb0Srumble /* Outputs wire-ored and connected to ICU input for fast rx interrupt. */
788b610ccb0Srumble if (channel == 0)
789b610ccb0Srumble dp->opcr &= ~OPCR_OP4_RXRDYA;
790b610ccb0Srumble else
791b610ccb0Srumble dp->opcr &= ~OPCR_OP5_RXRDYB;
792b610ccb0Srumble dp->base[DU_OPCR] = dp->opcr;
793b610ccb0Srumble dp->imr &= ~sc->sc_rx_int;
794b610ccb0Srumble dp->base[DU_IMR] = dp->imr;
795b610ccb0Srumble }
796b610ccb0Srumble
797b610ccb0Srumble void
scn_attach(device_t parent,device_t self,void * aux)798b610ccb0Srumble scn_attach(device_t parent, device_t self, void *aux)
799b610ccb0Srumble {
800b610ccb0Srumble struct mainbus_attach_args *ma = aux;
801b610ccb0Srumble struct scn_softc *sc;
802b610ccb0Srumble struct duart *duart;
803b610ccb0Srumble volatile u_char *ch_base;
804b610ccb0Srumble volatile u_char *duart_base;
805b610ccb0Srumble int channel;
806b610ccb0Srumble int speed;
807b610ccb0Srumble int s;
80821af650cSchristos int maj __diagused;
809b610ccb0Srumble u_char unit;
810b610ccb0Srumble u_char duartno;
811b610ccb0Srumble u_char delim = ':';
812b610ccb0Srumble u_char mr1, mr2;
813b610ccb0Srumble enum scntype scntype = SCNUNK;
814b610ccb0Srumble const char *duart_type = "Unknown";
815b610ccb0Srumble bool console, first;
816b610ccb0Srumble devmajor_t major;
817b610ccb0Srumble
818b610ccb0Srumble (void)major;
819b610ccb0Srumble
820b610ccb0Srumble sc = device_private(self);
821b610ccb0Srumble unit = device_unit(self);
822b610ccb0Srumble
823b610ccb0Srumble /* XXX - hard-coded */
824b610ccb0Srumble if (ma->ma_addr == 0x1fb80004)
825b610ccb0Srumble duartno = 1;
826b610ccb0Srumble else
827b610ccb0Srumble duartno = 0;
828b610ccb0Srumble channel = 0;
829b610ccb0Srumble console = 1;
830b610ccb0Srumble
831b610ccb0Srumble duart = sc->sc_duart = &scn_duart[duartno];
832b610ccb0Srumble duart->chan[channel].sc = sc;
833b610ccb0Srumble first = (duart->base == NULL);
834b610ccb0Srumble
835b610ccb0Srumble if (console) {
836b610ccb0Srumble sc->sc_isconsole = 1;
837b610ccb0Srumble sc->sc_swflags |= SCN_SW_SOFTCAR; /* ignore carrier */
838b610ccb0Srumble }
839b610ccb0Srumble
840b610ccb0Srumble duart_base = (volatile u_char *)MIPS_PHYS_TO_KSEG1(ma->ma_addr);
841b610ccb0Srumble ch_base = duart_base; /* XXX */
842b610ccb0Srumble
843b610ccb0Srumble if (first) {
844b610ccb0Srumble /* Probe DUART type */
845b610ccb0Srumble s = spltty();
846b610ccb0Srumble if (console) {
847b610ccb0Srumble ch_base[CH_CR] = CR_DIS_TX;
848b610ccb0Srumble delay(5 * 10000);
849b610ccb0Srumble }
850b610ccb0Srumble ch_base[CH_CR] = CR_CMD_MR1;
851b610ccb0Srumble RECOVER();
852b610ccb0Srumble mr1 = ch_base[CH_MR];
853b610ccb0Srumble mr2 = ch_base[CH_MR];
854b610ccb0Srumble ch_base[CH_CR] = CR_CMD_MR1;
855b610ccb0Srumble RECOVER();
856b610ccb0Srumble ch_base[CH_MR] = 1;
857b610ccb0Srumble ch_base[CH_MR] = 0;
858b610ccb0Srumble ch_base[CH_CR] = CR_CMD_MR1;
859b610ccb0Srumble RECOVER();
860b610ccb0Srumble if (ch_base[CH_MR] == 1) {
861b610ccb0Srumble /* MR 2 selected */
862b610ccb0Srumble ch_base[CH_CR] = CR_CMD_MR0;
863b610ccb0Srumble RECOVER();
864b610ccb0Srumble /* if 2681, MR2 still selected */
865b610ccb0Srumble ch_base[CH_MR] = 1;
866b610ccb0Srumble ch_base[CH_CR] = CR_CMD_MR1;
867b610ccb0Srumble RECOVER();
868b610ccb0Srumble ch_base[CH_MR] = 0; /* MR1 */
869b610ccb0Srumble ch_base[CH_MR] = 0; /* MR2 */
870b610ccb0Srumble ch_base[CH_CR] = CR_CMD_MR0;
871b610ccb0Srumble RECOVER();
872b610ccb0Srumble /* if 2681, MR2 still selected */
873b610ccb0Srumble if((ch_base[CH_MR] & 1) == 1) {
874b610ccb0Srumble duart_type = "sc26c92";
875b610ccb0Srumble scntype = SC26C92;
876b610ccb0Srumble } else {
877b610ccb0Srumble /* 2681 treats as MR1 Select */
878b610ccb0Srumble ch_base[CH_CR] = CR_CMD_RTS_OFF;
879b610ccb0Srumble RECOVER();
880b610ccb0Srumble ch_base[CH_MR] = 1;
881b610ccb0Srumble ch_base[CH_MR] = 0;
882b610ccb0Srumble ch_base[CH_CR] = CR_CMD_RTS_OFF;
883b610ccb0Srumble RECOVER();
884b610ccb0Srumble if (ch_base[CH_MR] == 1) {
885b610ccb0Srumble duart_type = "scn2681";
886b610ccb0Srumble scntype = SCN2681;
887b610ccb0Srumble } else {
888b610ccb0Srumble duart_type = "scn2692";
889b610ccb0Srumble scntype = SCN2692;
890b610ccb0Srumble }
891b610ccb0Srumble }
892b610ccb0Srumble }
893b610ccb0Srumble
894b610ccb0Srumble /* If a 2681, the CR_CMD_MR0 is interpreted as a TX_RESET */
895b610ccb0Srumble if (console) {
896b610ccb0Srumble ch_base[CH_CR] = CR_ENA_TX;
897b610ccb0Srumble RECOVER();
898b610ccb0Srumble }
899b610ccb0Srumble ch_base[CH_CR] = CR_CMD_MR1;
900b610ccb0Srumble RECOVER();
901b610ccb0Srumble ch_base[CH_MR] = mr1;
902b610ccb0Srumble ch_base[CH_MR] = mr2;
903b610ccb0Srumble splx(s);
904b610ccb0Srumble
905b610ccb0Srumble /*
906b610ccb0Srumble * On IP6 the console chip is duart1. The keyboard/mouse
907b610ccb0Srumble * is duart0. Each chip has two channels and the channels
908b610ccb0Srumble * share an interrupt. Duart0 is interrupt 0, duart1 is
909b610ccb0Srumble * interrupt 1.
910b610ccb0Srumble */
911b610ccb0Srumble if (duartno != 0 && duartno != 1)
912b610ccb0Srumble panic("scn_attach: bad duartno: %d", duartno);
913b610ccb0Srumble cpu_intr_establish(duartno, IPL_TTY, scnintr, duart);
914b610ccb0Srumble
915b610ccb0Srumble printf("%c %s", delim, duart_type);
916b610ccb0Srumble delim = ',';
917b610ccb0Srumble
918b610ccb0Srumble duart->base = duart_base;
919b610ccb0Srumble duart->type = scntype;
920b610ccb0Srumble }
921b610ccb0Srumble /* Record channel, uart */
922b610ccb0Srumble sc->sc_channel = channel;
923b610ccb0Srumble sc->sc_chbase = ch_base;
924b610ccb0Srumble
925b610ccb0Srumble /* Initialize modem/interrupt bit masks */
926b610ccb0Srumble if (channel == 0) {
927b610ccb0Srumble sc->sc_op_rts = OP_RTSA;
928b610ccb0Srumble sc->sc_op_dtr = OP_DTRA;
929b610ccb0Srumble sc->sc_ip_cts = IP_CTSA;
930b610ccb0Srumble sc->sc_ip_dcd = IP_DCDA;
931b610ccb0Srumble
932b610ccb0Srumble sc->sc_tx_int = INT_TXA;
933b610ccb0Srumble sc->sc_rx_int = INT_RXA;
934b610ccb0Srumble } else {
935b610ccb0Srumble sc->sc_op_rts = OP_RTSB;
936b610ccb0Srumble sc->sc_op_dtr = OP_DTRB;
937b610ccb0Srumble sc->sc_ip_cts = IP_CTSB;
938b610ccb0Srumble sc->sc_ip_dcd = IP_DCDB;
939b610ccb0Srumble
940b610ccb0Srumble sc->sc_tx_int = INT_TXB;
941b610ccb0Srumble sc->sc_rx_int = INT_RXB;
942b610ccb0Srumble }
943b610ccb0Srumble
944b610ccb0Srumble /* Initialize counters */
945b610ccb0Srumble sc->sc_framing_errors = 0;
946b610ccb0Srumble sc->sc_fifo_overruns = 0;
947b610ccb0Srumble sc->sc_parity_errors = 0;
948b610ccb0Srumble sc->sc_breaks = 0;
949b610ccb0Srumble
950b610ccb0Srumble if (console) {
951b610ccb0Srumble DELAY(5 * 10000); /* Let the output go out.... */
952b610ccb0Srumble }
953b610ccb0Srumble
954b610ccb0Srumble /*
955b610ccb0Srumble * Set up the hardware to a base state, in particular:
956b610ccb0Srumble * o reset transmitter and receiver
957b610ccb0Srumble * o set speeds and configurations
958b610ccb0Srumble * o receiver interrupts only (RxRDY and BREAK)
959b610ccb0Srumble */
960b610ccb0Srumble
961b610ccb0Srumble s = spltty();
962b610ccb0Srumble /* RTS off... */
963b610ccb0Srumble SCN_OP_BIC(sc, sc->sc_op_rts); /* "istop" */
964b610ccb0Srumble
965b610ccb0Srumble ch_base[CH_CR] = CR_DIS_RX | CR_DIS_TX;
966b610ccb0Srumble RECOVER();
967b610ccb0Srumble ch_base[CH_CR] = CR_CMD_RESET_RX;
968b610ccb0Srumble RECOVER();
969b610ccb0Srumble ch_base[CH_CR] = CR_CMD_RESET_TX;
970b610ccb0Srumble RECOVER();
971b610ccb0Srumble ch_base[CH_CR] = CR_CMD_RESET_ERR;
972b610ccb0Srumble RECOVER();
973b610ccb0Srumble ch_base[CH_CR] = CR_CMD_RESET_BRK;
974b610ccb0Srumble RECOVER();
975b610ccb0Srumble ch_base[CH_CR] = CR_CMD_MR1;
976b610ccb0Srumble RECOVER();
977b610ccb0Srumble
978b610ccb0Srumble /* No receiver control of RTS. */
979b610ccb0Srumble ch_base[CH_MR] = 0;
980b610ccb0Srumble ch_base[CH_MR] = 0;
981b610ccb0Srumble
982b610ccb0Srumble /* Initialize the uart structure if this is channel A. */
983b610ccb0Srumble if (first) {
984b610ccb0Srumble /* Disable all interrupts. */
985b610ccb0Srumble duart_base[DU_IMR] = duart->imr = 0;
986b610ccb0Srumble
987b610ccb0Srumble /* Output port config */
988b610ccb0Srumble duart_base[DU_OPCR] = duart->opcr = 0;
989b610ccb0Srumble
990b610ccb0Srumble /* Speeds... */
991b610ccb0Srumble duart->mode = 0;
992b610ccb0Srumble
993b610ccb0Srumble /*
994b610ccb0Srumble * Set initial speed to an illegal code that can be changed to
995b610ccb0Srumble * any other baud.
996b610ccb0Srumble */
997b610ccb0Srumble duart->chan[0].icode = duart->chan[0].ocode = 0x2f;
998b610ccb0Srumble duart->chan[1].icode = duart->chan[1].ocode = 0x2f;
999b610ccb0Srumble duart->chan[0].ispeed = duart->chan[0].ospeed = 0;
1000b610ccb0Srumble duart->chan[1].ispeed = duart->chan[1].ospeed = 0;
1001b610ccb0Srumble
1002b610ccb0Srumble duart->acr = 0;
1003b610ccb0Srumble duart->acr |= ACR_CT_TCLK1; /* timer mode 1x clk */
1004b610ccb0Srumble }
1005b610ccb0Srumble
1006b610ccb0Srumble if (channel == 0) {
1007b610ccb0Srumble duart->acr |= ACR_DELTA_DCDA; /* Set CD int */
1008b610ccb0Srumble } else {
1009b610ccb0Srumble duart->acr |= ACR_DELTA_DCDB; /* Set CD int */
1010b610ccb0Srumble }
1011b610ccb0Srumble
1012b610ccb0Srumble if (scnsir == NULL) {
1013b610ccb0Srumble /* software intr: calls tty code, hence IPL_TTY */
1014b610ccb0Srumble scnsir = softint_establish(SOFTINT_SERIAL, scnsoft, NULL);
1015b610ccb0Srumble }
1016b610ccb0Srumble
1017b610ccb0Srumble duart_base[DU_ACR] = (duart->mode & ACR_BRG) | duart->acr;
1018b610ccb0Srumble
1019b610ccb0Srumble if (console)
1020b610ccb0Srumble speed = scnconsrate;
1021b610ccb0Srumble else
1022b610ccb0Srumble speed = scndefaultrate;
1023b610ccb0Srumble
1024b610ccb0Srumble scn_config(unit, channel, speed, speed, MR1_PNONE | MR1_CS8, MR2_STOP1);
1025b610ccb0Srumble if (console) {
1026b610ccb0Srumble maj = cdevsw_lookup_major(&scn_cdevsw);
1027b610ccb0Srumble KASSERT(maj != NODEVMAJOR);
1028b610ccb0Srumble shutdownhook_establish(scncnreinit, NULL);
1029b610ccb0Srumble /* Make sure console can do scncngetc */
1030b610ccb0Srumble duart_base[DU_OPSET] = channel ? (OP_RTSB | OP_DTRB) :
1031b610ccb0Srumble (OP_RTSA | OP_DTRA);
1032b610ccb0Srumble }
1033b610ccb0Srumble
1034b610ccb0Srumble /* Turn on the receiver and transmitters */
1035b610ccb0Srumble ch_base[CH_CR] = CR_ENA_RX | CR_ENA_TX;
1036b610ccb0Srumble
1037b610ccb0Srumble /* Set up the interrupts. */
1038b610ccb0Srumble duart->imr |= INT_IP;
1039b610ccb0Srumble scn_rxdisable(sc);
1040b610ccb0Srumble splx(s);
1041b610ccb0Srumble
1042b610ccb0Srumble if (sc->sc_swflags) {
1043b610ccb0Srumble printf("%c flags %d", delim, sc->sc_swflags);
1044b610ccb0Srumble delim = ',';
1045b610ccb0Srumble }
1046b610ccb0Srumble
1047b610ccb0Srumble #ifdef KGDB
1048b610ccb0Srumble major = cdevsw_lookup_major(&scn_cdevsw);
1049b610ccb0Srumble KASSERT(major != NODEVMAJOR);
1050b610ccb0Srumble if (kgdb_dev == makedev(major, unit)) {
1051b610ccb0Srumble if (console)
1052b610ccb0Srumble kgdb_dev = NODEV; /* can't debug over console port */
1053b610ccb0Srumble else {
1054b610ccb0Srumble scninit(kgdb_dev, kgdb_rate);
1055b610ccb0Srumble scn_rxenable(sc);
1056b610ccb0Srumble scn->sc_iskgdb = 1;
1057b610ccb0Srumble kgdb_attach(scncngetc, scncnputc, kgdb_dev);
1058b610ccb0Srumble if (kgdb_debug_init) {
1059b610ccb0Srumble printf("%c ", delim);
1060b610ccb0Srumble kgdb_connect(1);
1061b610ccb0Srumble } else
1062b610ccb0Srumble printf("%c kgdb enabled", delim);
1063b610ccb0Srumble delim = ',';
1064b610ccb0Srumble }
1065b610ccb0Srumble }
1066b610ccb0Srumble #endif
1067b610ccb0Srumble printf("\n");
1068b610ccb0Srumble }
1069b610ccb0Srumble
1070b610ccb0Srumble /* ARGSUSED */
1071b610ccb0Srumble int
scnopen(dev_t dev,int flags,int mode,struct lwp * l)1072b610ccb0Srumble scnopen(dev_t dev, int flags, int mode, struct lwp *l)
1073b610ccb0Srumble {
1074b610ccb0Srumble struct tty *tp;
1075b610ccb0Srumble int unit = DEV_UNIT(dev);
1076b610ccb0Srumble struct scn_softc *sc;
1077b610ccb0Srumble int error = 0;
1078b610ccb0Srumble
1079b610ccb0Srumble if (unit >= scn_cd.cd_ndevs)
1080b610ccb0Srumble return ENXIO;
1081b610ccb0Srumble sc = SOFTC(unit);
1082b610ccb0Srumble if (!sc)
1083b610ccb0Srumble return ENXIO;
1084b610ccb0Srumble
1085b610ccb0Srumble tp = sc->sc_tty;
1086b610ccb0Srumble if (!tp) {
10872626d576Srmind tp = tty_alloc();
1088b610ccb0Srumble sc->sc_tty = sc->sc_duart->chan[sc->sc_channel].tty = tp;
1089b610ccb0Srumble tty_attach(tp);
1090b610ccb0Srumble }
1091b610ccb0Srumble
1092b610ccb0Srumble tp->t_oproc = scnstart;
1093b610ccb0Srumble tp->t_param = scnparam;
1094b610ccb0Srumble tp->t_hwiflow = scnhwiflow;
1095b610ccb0Srumble tp->t_dev = dev;
1096b610ccb0Srumble
1097b610ccb0Srumble if (kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_OPEN, tp))
1098b610ccb0Srumble return (EBUSY);
1099b610ccb0Srumble
1100b62ffa8bSriastradh ttylock(tp);
1101b610ccb0Srumble
1102b610ccb0Srumble if ((tp->t_state & TS_ISOPEN) == 0 && tp->t_wopen == 0) {
1103b610ccb0Srumble ttychars(tp);
1104b610ccb0Srumble tp->t_iflag = TTYDEF_IFLAG;
1105b610ccb0Srumble tp->t_oflag = TTYDEF_OFLAG;
1106b610ccb0Srumble tp->t_cflag = SCNDEF_CFLAG;
1107b610ccb0Srumble
1108b610ccb0Srumble sc->sc_rx_blocked = 0;
1109b610ccb0Srumble
1110b610ccb0Srumble if (sc->sc_swflags & SCN_SW_CLOCAL)
1111b610ccb0Srumble tp->t_cflag |= CLOCAL;
1112b610ccb0Srumble if (sc->sc_swflags & SCN_SW_CRTSCTS)
1113b610ccb0Srumble tp->t_cflag |= CCTS_OFLOW | CRTS_IFLOW;
1114b610ccb0Srumble tp->t_lflag = TTYDEF_LFLAG;
1115b610ccb0Srumble if (sc->sc_isconsole)
1116b610ccb0Srumble tp->t_ispeed = tp->t_ospeed = scnconsrate;
1117b610ccb0Srumble else
1118b610ccb0Srumble tp->t_ispeed = tp->t_ospeed = scndefaultrate;
1119b610ccb0Srumble scnparam(tp, &tp->t_termios);
1120b610ccb0Srumble ttsetwater(tp);
1121b610ccb0Srumble
1122b610ccb0Srumble /* Turn on DTR and RTS. */
1123b610ccb0Srumble SCN_OP_BIS(sc, sc->sc_op_rts | sc->sc_op_dtr);
1124b610ccb0Srumble
1125b610ccb0Srumble /* enable receiver interrupts */
1126b610ccb0Srumble scn_rxenable(sc);
1127b610ccb0Srumble
1128b610ccb0Srumble /* set carrier state; */
1129b610ccb0Srumble if ((sc->sc_swflags & SCN_SW_SOFTCAR) || /* check ttyflags */
1130b610ccb0Srumble SCN_DCD(sc) || /* check h/w */
1131b610ccb0Srumble DEV_DIALOUT(dev))
1132b610ccb0Srumble tp->t_state |= TS_CARR_ON;
1133b610ccb0Srumble else
1134b610ccb0Srumble tp->t_state &= ~TS_CARR_ON;
1135b610ccb0Srumble }
1136b610ccb0Srumble
1137b62ffa8bSriastradh ttyunlock(tp);
1138b610ccb0Srumble
1139b610ccb0Srumble error = ttyopen(tp, SCN_DIALOUT(sc), flags & O_NONBLOCK);
1140b610ccb0Srumble if (error) printf("ttyopen failed line %d, error %d\n", __LINE__, error);
1141b610ccb0Srumble if (error)
1142b610ccb0Srumble goto bad;
1143b610ccb0Srumble
1144b610ccb0Srumble error = (*tp->t_linesw->l_open) (dev, tp);
1145b610ccb0Srumble if (error) printf("l_open failed line %d, error %d\n", __LINE__, error);
1146b610ccb0Srumble if (error)
1147b610ccb0Srumble goto bad;
1148b610ccb0Srumble
1149b610ccb0Srumble return (0);
1150b610ccb0Srumble
1151b610ccb0Srumble bad:
1152b610ccb0Srumble if ((tp->t_state & TS_ISOPEN) == 0 && tp->t_wopen == 0) {
1153b610ccb0Srumble scn_rxdisable(sc);
1154b610ccb0Srumble SCN_OP_BIC(sc, sc->sc_op_rts | sc->sc_op_dtr);
1155b610ccb0Srumble }
1156b610ccb0Srumble
1157b610ccb0Srumble return (error);
1158b610ccb0Srumble }
1159b610ccb0Srumble
1160b610ccb0Srumble
1161b610ccb0Srumble /*ARGSUSED*/
1162b610ccb0Srumble int
scnclose(dev_t dev,int flags,int mode,struct lwp * l)1163b610ccb0Srumble scnclose(dev_t dev, int flags, int mode, struct lwp *l)
1164b610ccb0Srumble {
1165b610ccb0Srumble int unit = DEV_UNIT(dev);
1166b610ccb0Srumble struct scn_softc *sc = SOFTC(unit);
1167b610ccb0Srumble struct tty *tp = sc->sc_tty;
1168b610ccb0Srumble devmajor_t major;
1169b610ccb0Srumble
1170b610ccb0Srumble (void)major;
1171b610ccb0Srumble
1172b610ccb0Srumble if ((tp->t_state & TS_ISOPEN) == 0)
1173b610ccb0Srumble return 0;
1174b610ccb0Srumble
1175b610ccb0Srumble (*tp->t_linesw->l_close) (tp, flags);
1176b610ccb0Srumble
1177b610ccb0Srumble #ifdef KGDB
1178b610ccb0Srumble /* do not disable interrupts if debugging */
1179b610ccb0Srumble major = cdevsw_lookup_major(&scn_devsw);
1180b610ccb0Srumble KASSERT(major != cdevsw_lookup_major);
1181b610ccb0Srumble if (kgdb_dev != makedev(major, unit))
1182b610ccb0Srumble #endif
1183b610ccb0Srumble if ((tp->t_state & TS_ISOPEN) == 0) {
1184b610ccb0Srumble scn_rxdisable(sc);
1185b610ccb0Srumble }
1186b610ccb0Srumble if ((tp->t_cflag & HUPCL) && (sc->sc_swflags & SCN_SW_SOFTCAR) == 0) {
1187b610ccb0Srumble SCN_OP_BIC(sc, sc->sc_op_dtr);
1188b610ccb0Srumble /* hold low for 1 second */
1189b610ccb0Srumble tsleep(sc, TTIPRI, ttclos, hz);
1190b610ccb0Srumble }
1191b610ccb0Srumble SCN_CLRDIALOUT(sc);
1192b610ccb0Srumble ttyclose(tp);
1193b610ccb0Srumble
1194b610ccb0Srumble #if 0
1195b610ccb0Srumble if ((tp->t_state & TS_ISOPEN) == 0) {
11962626d576Srmind tty_free(tp);
1197b610ccb0Srumble sc->sc_tty = (struct tty *) NULL;
1198b610ccb0Srumble }
1199b610ccb0Srumble #endif
1200b610ccb0Srumble
1201b610ccb0Srumble return (0);
1202b610ccb0Srumble }
1203b610ccb0Srumble
1204b610ccb0Srumble int
scnread(dev_t dev,struct uio * uio,int flags)1205b610ccb0Srumble scnread(dev_t dev, struct uio *uio, int flags)
1206b610ccb0Srumble {
1207b610ccb0Srumble struct scn_softc *sc = SOFTC(DEV_UNIT(dev));
1208b610ccb0Srumble struct tty *tp = sc->sc_tty;
1209b610ccb0Srumble
1210b610ccb0Srumble return ((*tp->t_linesw->l_read) (tp, uio, flags));
1211b610ccb0Srumble }
1212b610ccb0Srumble
1213b610ccb0Srumble int
scnwrite(dev_t dev,struct uio * uio,int flags)1214b610ccb0Srumble scnwrite(dev_t dev, struct uio *uio, int flags)
1215b610ccb0Srumble {
1216b610ccb0Srumble struct scn_softc *sc = SOFTC(DEV_UNIT(dev));
1217b610ccb0Srumble struct tty *tp = sc->sc_tty;
1218b610ccb0Srumble
1219b610ccb0Srumble return ((*tp->t_linesw->l_write) (tp, uio, flags));
1220b610ccb0Srumble }
1221b610ccb0Srumble
1222b610ccb0Srumble int
scnpoll(dev_t dev,int events,struct lwp * l)1223b610ccb0Srumble scnpoll(dev_t dev, int events, struct lwp *l)
1224b610ccb0Srumble {
1225b610ccb0Srumble struct scn_softc *sc = SOFTC(DEV_UNIT(dev));
1226b610ccb0Srumble struct tty *tp = sc->sc_tty;
1227b610ccb0Srumble
1228b610ccb0Srumble return ((*tp->t_linesw->l_poll)(tp, events, l));
1229b610ccb0Srumble }
1230b610ccb0Srumble
1231b610ccb0Srumble struct tty *
scntty(dev_t dev)1232b610ccb0Srumble scntty(dev_t dev)
1233b610ccb0Srumble {
1234b610ccb0Srumble struct scn_softc *sc = SOFTC(DEV_UNIT(dev));
1235b610ccb0Srumble
1236b610ccb0Srumble return sc->sc_tty;
1237b610ccb0Srumble }
1238b610ccb0Srumble
1239b610ccb0Srumble /* Worker routines for interrupt processing */
1240b610ccb0Srumble static inline void
dcd_int(struct scn_softc * sc,struct tty * tp,u_char new)1241b610ccb0Srumble dcd_int(struct scn_softc *sc, struct tty *tp, u_char new)
1242b610ccb0Srumble {
1243b610ccb0Srumble
1244b610ccb0Srumble if (sc->sc_swflags & SCN_SW_SOFTCAR)
1245b610ccb0Srumble return;
1246b610ccb0Srumble
1247b610ccb0Srumble #if 0
1248b610ccb0Srumble printf("scn%d: dcd_int ip %x SCN_DCD %x new %x ipcr %x\n",
1249b610ccb0Srumble sc->unit,
1250b610ccb0Srumble sc->sc_duart->base[DU_IP],
1251b610ccb0Srumble SCN_DCD(sc),
1252b610ccb0Srumble new,
1253b610ccb0Srumble sc->sc_duart->base[DU_IPCR]
1254b610ccb0Srumble );
1255b610ccb0Srumble #endif
1256b610ccb0Srumble
1257b610ccb0Srumble /* XXX set some flag to have some lower (soft) int call line discipline? */
1258b610ccb0Srumble if (!(*tp->t_linesw->l_modem) (tp, new == 0? 1: 0)) {
1259b610ccb0Srumble SCN_OP_BIC(sc, sc->sc_op_rts | sc->sc_op_dtr);
1260b610ccb0Srumble }
1261b610ccb0Srumble }
1262b610ccb0Srumble
1263b610ccb0Srumble /*
1264b610ccb0Srumble * Print out a ring or fifo overrun error message.
1265b610ccb0Srumble */
1266b610ccb0Srumble static void
scnoverrun(int unit,long * ptime,const char * what)1267b610ccb0Srumble scnoverrun(int unit, long *ptime, const char *what)
1268b610ccb0Srumble {
1269b610ccb0Srumble
1270b610ccb0Srumble if (*ptime != time_second) {
1271b610ccb0Srumble *ptime = time_second;
1272b610ccb0Srumble log(LOG_WARNING, "scn%d: %s overrun\n", unit, what);
1273b610ccb0Srumble }
1274b610ccb0Srumble }
1275b610ccb0Srumble
1276b610ccb0Srumble /*
1277b610ccb0Srumble * Try to block or unblock input using hardware flow-control.
1278b610ccb0Srumble * This is called by kern/tty.c if MDMBUF|CRTSCTS is set, and
1279b610ccb0Srumble * if this function returns non-zero, the TS_TBLOCK flag will
1280b610ccb0Srumble * be set or cleared according to the "stop" arg passed.
1281b610ccb0Srumble */
1282b610ccb0Srumble int
scnhwiflow(struct tty * tp,int stop)1283b610ccb0Srumble scnhwiflow(struct tty *tp, int stop)
1284b610ccb0Srumble {
1285b610ccb0Srumble int unit = DEV_UNIT(tp->t_dev);
1286b610ccb0Srumble struct scn_softc *sc = SOFTC(unit);
1287b610ccb0Srumble int s;
1288b610ccb0Srumble
1289b610ccb0Srumble s = splrtty();
1290b610ccb0Srumble if (!stop) {
1291b610ccb0Srumble if (sc->sc_rbput - sc->sc_rbget - 1) {
1292b610ccb0Srumble setsoftscn();
1293b610ccb0Srumble }
1294b610ccb0Srumble }
1295b610ccb0Srumble splx(s);
1296b610ccb0Srumble return 1;
1297b610ccb0Srumble }
1298b610ccb0Srumble
1299b610ccb0Srumble static int
scnintr(void * arg)1300b610ccb0Srumble scnintr(void *arg)
1301b610ccb0Srumble {
1302b610ccb0Srumble struct duart *duart = arg;
1303b610ccb0Srumble struct scn_softc *sc0 = duart->chan[0].sc;
1304b610ccb0Srumble struct scn_softc *sc1 = duart->chan[1].sc;
1305b610ccb0Srumble
1306b610ccb0Srumble struct tty *tp0 = (sc0 != NULL) ? sc0->sc_tty : NULL;
1307b610ccb0Srumble struct tty *tp1 = (sc1 != NULL) ? sc1->sc_tty : NULL;
1308b610ccb0Srumble
1309b610ccb0Srumble char rs_work;
1310b610ccb0Srumble u_char rs_stat;
1311b610ccb0Srumble u_char rs_ipcr;
1312b610ccb0Srumble
1313b610ccb0Srumble /* Check for RX interrupts first, since we cannot distinguish by irq. */
1314b610ccb0Srumble scnrxintr(duart);
1315b610ccb0Srumble
1316b610ccb0Srumble do {
1317b610ccb0Srumble /* Loop to pick up ALL pending interrupts for device. */
1318b610ccb0Srumble rs_work = false;
1319b610ccb0Srumble rs_stat = duart->base[DU_ISR];
1320b610ccb0Srumble
1321b610ccb0Srumble /* channel a */
1322b610ccb0Srumble if (tp0 != NULL) {
1323b610ccb0Srumble if ((rs_stat & INT_TXA) && (tp0->t_state & TS_BUSY)) {
1324b610ccb0Srumble /* output char done. */
1325b610ccb0Srumble tp0->t_state &= ~(TS_BUSY | TS_FLUSH);
1326b610ccb0Srumble
1327b610ccb0Srumble /* disable tx ints */
1328b610ccb0Srumble duart->imr &= ~sc0->sc_tx_int;
1329b610ccb0Srumble duart->base[DU_IMR] = duart->imr;
1330b610ccb0Srumble
1331b610ccb0Srumble if (sc0->sc_heldchanges) {
1332b610ccb0Srumble scn_setchip(sc0);
1333b610ccb0Srumble }
1334b610ccb0Srumble
1335b610ccb0Srumble (*tp0->t_linesw->l_start) (tp0);
1336b610ccb0Srumble rs_work = true;
1337b610ccb0Srumble }
1338b610ccb0Srumble }
1339b610ccb0Srumble /* channel b */
1340b610ccb0Srumble if (tp1 != NULL) {
1341b610ccb0Srumble if ((rs_stat & INT_TXB) && (tp1->t_state & TS_BUSY)) {
1342b610ccb0Srumble /* output char done. */
1343b610ccb0Srumble tp1->t_state &= ~(TS_BUSY | TS_FLUSH);
1344b610ccb0Srumble
1345b610ccb0Srumble /* disable tx ints */
1346b610ccb0Srumble duart->imr &= ~sc1->sc_tx_int;
1347b610ccb0Srumble duart->base[DU_IMR] = duart->imr;
1348b610ccb0Srumble
1349b610ccb0Srumble if (sc1->sc_heldchanges) {
1350b610ccb0Srumble scn_setchip(sc1);
1351b610ccb0Srumble }
1352b610ccb0Srumble
1353b610ccb0Srumble (*tp1->t_linesw->l_start) (tp1);
1354b610ccb0Srumble rs_work = true;
1355b610ccb0Srumble }
1356b610ccb0Srumble }
1357b610ccb0Srumble if (rs_stat & INT_IP) {
1358b610ccb0Srumble rs_work = true;
1359b610ccb0Srumble rs_ipcr = duart->base[DU_IPCR];
1360b610ccb0Srumble
1361b610ccb0Srumble if (rs_ipcr & IPCR_DELTA_DCDA && tp0 != NULL) {
1362b610ccb0Srumble dcd_int(sc0, tp0, rs_ipcr & IPCR_DCDA);
1363b610ccb0Srumble }
1364b610ccb0Srumble if (rs_ipcr & IPCR_DELTA_DCDB && tp1 != NULL) {
1365b610ccb0Srumble dcd_int(sc1, tp1, rs_ipcr & IPCR_DCDB);
1366b610ccb0Srumble }
1367b610ccb0Srumble }
1368b610ccb0Srumble } while (rs_work);
1369b610ccb0Srumble
1370b610ccb0Srumble return (1); /* ? */
1371b610ccb0Srumble }
1372b610ccb0Srumble
1373b610ccb0Srumble /*
1374b610ccb0Srumble * Handle rxrdy/ffull interrupt: QUICKLY poll both channels (checking
1375b610ccb0Srumble * status first) and stash data in a ring buffer. Ring buffer scheme
1376b610ccb0Srumble * borowed from sparc/zs.c requires NO interlock on data!
1377b610ccb0Srumble *
1378b610ccb0Srumble * This interrupt should NOT be included in spltty() mask since it
1379b610ccb0Srumble * invokes NO tty code! The whole point is to allow tty input as much
1380b610ccb0Srumble * of the time as possible, while deferring "heavy" character
1381b610ccb0Srumble * processing until later.
1382b610ccb0Srumble *
1383b610ccb0Srumble * see scn.hw.README and scnsoft() for more info.
1384b610ccb0Srumble *
1385b610ccb0Srumble * THIS ROUTINE SHOULD BE KEPT AS CLEAN AS POSSIBLE!!
1386b610ccb0Srumble * IT'S A CANDIDATE FOR RECODING IN ASSEMBLER!!
1387b610ccb0Srumble */
1388b610ccb0Srumble static inline int
scn_rxintr(struct scn_softc * sc)1389b610ccb0Srumble scn_rxintr(struct scn_softc *sc)
1390b610ccb0Srumble {
1391b610ccb0Srumble char sr;
1392b610ccb0Srumble int i, n;
1393b610ccb0Srumble int work;
1394b610ccb0Srumble
1395b610ccb0Srumble work = 0;
1396b610ccb0Srumble i = sc->sc_rbput;
1397b610ccb0Srumble while (work <= 10) {
1398b610ccb0Srumble #define SCN_GETCH(SC) \
1399b610ccb0Srumble sr = (SC)->sc_chbase[CH_SR]; \
1400b610ccb0Srumble if ((sr & SR_RX_RDY) == 0) \
1401b610ccb0Srumble break; \
1402b610ccb0Srumble if (sr & (SR_PARITY | SR_FRAME | SR_BREAK | SR_OVERRUN)) \
1403b610ccb0Srumble goto exception; \
1404b610ccb0Srumble work++; \
1405b610ccb0Srumble (SC)->sc_rbuf[i++ & SCN_RING_MASK] = (SC)->sc_chbase[CH_DAT]
1406b610ccb0Srumble
1407b610ccb0Srumble SCN_GETCH(sc); SCN_GETCH(sc); SCN_GETCH(sc);
1408b610ccb0Srumble /* XXX more here if 26C92? -plb */
1409b610ccb0Srumble continue;
1410b610ccb0Srumble exception:
1411b610ccb0Srumble #if defined(DDB)
1412b610ccb0Srumble if (sc->sc_isconsole && (sr & SR_BREAK)) {
1413b610ccb0Srumble Debugger();
1414b610ccb0Srumble sr = sc->sc_chbase[CH_SR];
1415b610ccb0Srumble }
1416b610ccb0Srumble #endif
1417b610ccb0Srumble #if defined(KGDB)
1418b610ccb0Srumble if (sc->sc_iskgdb && (sr & SR_RX_RDY)) {
1419b610ccb0Srumble kgdb_connect(1);
1420b610ccb0Srumble sr = sc->sc_chbase[CH_SR];
1421b610ccb0Srumble }
1422b610ccb0Srumble #endif
1423b610ccb0Srumble work++;
1424b610ccb0Srumble sc->sc_rbuf[i++ & SCN_RING_MASK] = (sr << 8) | sc->sc_chbase[CH_DAT];
1425b610ccb0Srumble sc->sc_chbase[CH_CR] = CR_CMD_RESET_ERR; /* resets break? */
1426b610ccb0Srumble RECOVER();
1427b610ccb0Srumble }
1428b610ccb0Srumble /*
1429b610ccb0Srumble * If ring is getting too full, try to block input.
1430b610ccb0Srumble */
1431b610ccb0Srumble n = i - sc->sc_rbget;
1432b610ccb0Srumble if (sc->sc_rbhiwat && (n > sc->sc_rbhiwat)) {
1433b610ccb0Srumble /* If not CRTSCTS sc_rbhiwat is such that this
1434b610ccb0Srumble * never happens.
1435b610ccb0Srumble * Clear RTS
1436b610ccb0Srumble */
1437b610ccb0Srumble SCN_OP_BIC(sc, sc->sc_op_rts);
1438b610ccb0Srumble sc->sc_rx_blocked = 1;
1439b610ccb0Srumble }
1440b610ccb0Srumble sc->sc_rbput = i;
1441b610ccb0Srumble
1442b610ccb0Srumble return work;
1443b610ccb0Srumble }
1444b610ccb0Srumble
1445b610ccb0Srumble static void
scnrxintr(void * arg)1446b610ccb0Srumble scnrxintr(void *arg)
1447b610ccb0Srumble {
1448b610ccb0Srumble struct duart *duart = arg;
1449b610ccb0Srumble int work = 0;
1450b610ccb0Srumble
1451b610ccb0Srumble if (duart->chan[0].sc != NULL)
1452b610ccb0Srumble work += scn_rxintr(duart->chan[0].sc);
1453b610ccb0Srumble if (duart->chan[1].sc != NULL)
1454b610ccb0Srumble work += scn_rxintr(duart->chan[1].sc);
1455b610ccb0Srumble if (work > 0) {
1456b610ccb0Srumble setsoftscn(); /* trigger s/w intr */
1457b610ccb0Srumble #ifdef SCN_TIMING
1458b610ccb0Srumble microtime(&tstart);
1459b610ccb0Srumble #endif
1460b610ccb0Srumble }
1461b610ccb0Srumble }
1462b610ccb0Srumble
1463b610ccb0Srumble /*
1464b610ccb0Srumble * Here on soft interrupt (at spltty) to empty ring buffers.
1465b610ccb0Srumble *
1466b610ccb0Srumble * Dave's original scheme was to use the DUART receiver timeout
1467b610ccb0Srumble * interrupt. This requires 2692's (which my board doesn't have), and
1468b610ccb0Srumble * I also liked the idea of using the C/T to generate alternate and/or
1469b610ccb0Srumble * arbitrary bauds. -plb
1470b610ccb0Srumble *
1471b610ccb0Srumble * The ringbuffer code comes from Chris Torek's SPARC 44bsd zs driver
1472b610ccb0Srumble * (hence the LBL notice on top of this file), DOES NOT require
1473b610ccb0Srumble * interlocking with interrupt levels!
1474b610ccb0Srumble *
1475b610ccb0Srumble * The 44bsd sparc/zs driver reads the ring buffer from a separate
1476b610ccb0Srumble * zssoftint, while the SunOS 4.x zs driver appears to use
1477b610ccb0Srumble * timeout()'s. timeouts seem to be too slow to deal with high data
1478b610ccb0Srumble * rates. I know, I tried them.
1479b610ccb0Srumble * -plb.
1480b610ccb0Srumble */
1481b610ccb0Srumble static void
scnsoft(void * arg)1482b610ccb0Srumble scnsoft(void *arg)
1483b610ccb0Srumble {
1484b610ccb0Srumble int s, unit;
1485b610ccb0Srumble #ifdef SCN_TIMING
1486b610ccb0Srumble struct timeval tend;
1487b610ccb0Srumble u_long t;
1488b610ccb0Srumble
1489b610ccb0Srumble microtime(&tend);
1490b610ccb0Srumble t = (tend.tv_sec - tstart.tv_sec) * 1000000 + (tend.tv_usec - tstart.tv_usec);
1491b610ccb0Srumble t = (t + tick / 20) / (tick / 10);
1492b610ccb0Srumble if (t >= NJITTER - 1) {
1493b610ccb0Srumble t = NJITTER - 1;
1494b610ccb0Srumble }
1495b610ccb0Srumble scn_jitter[t]++;
1496b610ccb0Srumble #endif
1497b610ccb0Srumble
1498b610ccb0Srumble for (unit = 0; unit < scn_cd.cd_ndevs; unit++) {
1499b610ccb0Srumble struct scn_softc *sc;
1500b610ccb0Srumble struct tty *tp;
1501b610ccb0Srumble int n, get;
1502b610ccb0Srumble
1503b610ccb0Srumble sc = SOFTC(unit);
1504b610ccb0Srumble if (sc == NULL) {
1505b610ccb0Srumble continue;
1506b610ccb0Srumble }
1507b610ccb0Srumble tp = sc->sc_tty;
1508b610ccb0Srumble #ifdef KGDB
1509b610ccb0Srumble if (tp == NULL) {
1510b610ccb0Srumble sc->sc_rbget = sc->sc_rbput;
1511b610ccb0Srumble continue;
1512b610ccb0Srumble }
1513b610ccb0Srumble #endif
1514b610ccb0Srumble if (tp == NULL || tp->t_state & TS_TBLOCK) {
1515b610ccb0Srumble continue;
1516b610ccb0Srumble }
1517b610ccb0Srumble
1518b610ccb0Srumble
1519b610ccb0Srumble get = sc->sc_rbget;
1520b610ccb0Srumble
1521b610ccb0Srumble /* NOTE: fetch from rbput is atomic */
1522b610ccb0Srumble while (get != (n = sc->sc_rbput)) {
1523b610ccb0Srumble /*
1524b610ccb0Srumble * Compute the number of interrupts in the receive ring.
1525b610ccb0Srumble * If the count is overlarge, we lost some events, and
1526b610ccb0Srumble * must advance to the first valid one. It may get
1527b610ccb0Srumble * overwritten if more data are arriving, but this is
1528b610ccb0Srumble * too expensive to check and gains nothing (we already
1529b610ccb0Srumble * lost out; all we can do at this point is trade one
1530b610ccb0Srumble * kind of loss for another).
1531b610ccb0Srumble */
1532b610ccb0Srumble n -= get;
1533b610ccb0Srumble if (n > SCN_RING_SIZE) {
1534b610ccb0Srumble scnoverrun(unit, &sc->sc_rotime, "ring");
1535b610ccb0Srumble get += n - SCN_RING_SIZE;
1536b610ccb0Srumble n = SCN_RING_SIZE;
1537b610ccb0Srumble sc->sc_ring_overruns++;
1538b610ccb0Srumble }
1539b610ccb0Srumble while (--n >= 0) {
1540b610ccb0Srumble int c, sr;
1541b610ccb0Srumble
1542b610ccb0Srumble if (tp->t_state & TS_TBLOCK) {
1543b610ccb0Srumble sc->sc_rbget = get;
1544b610ccb0Srumble goto done;
1545b610ccb0Srumble }
1546b610ccb0Srumble /* Race to keep ahead of incoming interrupts. */
1547b610ccb0Srumble c = sc->sc_rbuf[get++ & SCN_RING_MASK];
1548b610ccb0Srumble
1549b610ccb0Srumble sr = c >> 8; /* extract status */
1550b610ccb0Srumble c &= 0xff; /* leave just character */
1551b610ccb0Srumble
1552b610ccb0Srumble if (sr & SR_OVERRUN) {
1553b610ccb0Srumble scnoverrun(unit, &sc->sc_fotime, "fifo");
1554b610ccb0Srumble sc->sc_fifo_overruns++;
1555b610ccb0Srumble }
1556b610ccb0Srumble if (sr & SR_PARITY) {
1557b610ccb0Srumble c |= TTY_PE;
1558b610ccb0Srumble sc->sc_parity_errors++;
1559b610ccb0Srumble }
1560b610ccb0Srumble if (sr & SR_FRAME) {
1561b610ccb0Srumble c |= TTY_FE;
1562b610ccb0Srumble sc->sc_framing_errors++;
1563b610ccb0Srumble }
1564b610ccb0Srumble if (sr & SR_BREAK) {
1565b610ccb0Srumble #if 0
1566b610ccb0Srumble /*
1567b610ccb0Srumble * See DDB_CHECK() comments in
1568b610ccb0Srumble * scnrxintr()
1569b610ccb0Srumble */
1570b610ccb0Srumble if (sc->sc_isconsole)
1571b610ccb0Srumble Debugger();
1572b610ccb0Srumble #endif
1573b610ccb0Srumble c = TTY_FE | 0;
1574b610ccb0Srumble sc->sc_breaks++;
1575b610ccb0Srumble }
1576b610ccb0Srumble
1577b610ccb0Srumble (*tp->t_linesw->l_rint) (c, tp);
1578b610ccb0Srumble
1579b610ccb0Srumble if (sc->sc_rx_blocked && n < SCN_RING_THRESH) {
1580b610ccb0Srumble s = splrtty();
1581b610ccb0Srumble sc->sc_rx_blocked = 0;
1582b610ccb0Srumble SCN_OP_BIS(sc, sc->sc_op_rts);
1583b610ccb0Srumble splx(s);
1584b610ccb0Srumble }
1585b610ccb0Srumble
1586b610ccb0Srumble }
1587b610ccb0Srumble sc->sc_rbget = get;
1588b610ccb0Srumble }
1589b610ccb0Srumble done: ;
1590b610ccb0Srumble }
1591b610ccb0Srumble }
1592b610ccb0Srumble
1593b610ccb0Srumble /* Convert TIOCM_xxx bits to output port bits. */
1594b610ccb0Srumble static unsigned char
opbits(struct scn_softc * sc,int tioc_bits)1595b610ccb0Srumble opbits(struct scn_softc *sc, int tioc_bits)
1596b610ccb0Srumble {
1597b610ccb0Srumble
1598b610ccb0Srumble return ((((tioc_bits) & TIOCM_DTR) ? sc->sc_op_dtr : 0) |
1599b610ccb0Srumble (((tioc_bits) & TIOCM_RTS) ? sc->sc_op_rts : 0));
1600b610ccb0Srumble }
1601b610ccb0Srumble
1602b610ccb0Srumble int
scnioctl(dev_t dev,u_long cmd,void * data,int flags,struct lwp * l)1603b610ccb0Srumble scnioctl(dev_t dev, u_long cmd, void *data, int flags, struct lwp *l)
1604b610ccb0Srumble {
1605b610ccb0Srumble int unit = DEV_UNIT(dev);
1606b610ccb0Srumble struct scn_softc *sc = SOFTC(unit);
1607b610ccb0Srumble struct tty *tp = sc->sc_tty;
1608b610ccb0Srumble int error;
1609b610ccb0Srumble
1610b610ccb0Srumble error = (*tp->t_linesw->l_ioctl) (tp, cmd, data, flags, l);
1611b610ccb0Srumble if (error != EPASSTHROUGH)
1612b610ccb0Srumble return (error);
1613b610ccb0Srumble
1614b610ccb0Srumble error = ttioctl(tp, cmd, data, flags, l);
1615b610ccb0Srumble if (error != EPASSTHROUGH)
1616b610ccb0Srumble return (error);
1617b610ccb0Srumble
1618b610ccb0Srumble switch (cmd) {
1619b610ccb0Srumble case TIOCSBRK:
1620b610ccb0Srumble sc->sc_chbase[CH_CR] = CR_CMD_START_BRK;
1621b610ccb0Srumble break;
1622b610ccb0Srumble
1623b610ccb0Srumble case TIOCCBRK:
1624b610ccb0Srumble sc->sc_chbase[CH_CR] = CR_CMD_STOP_BRK;
1625b610ccb0Srumble break;
1626b610ccb0Srumble
1627b610ccb0Srumble case TIOCSDTR:
1628b610ccb0Srumble SCN_OP_BIS(sc, sc->sc_op_dtr | sc->sc_op_rts);
1629b610ccb0Srumble break;
1630b610ccb0Srumble
1631b610ccb0Srumble case TIOCCDTR:
1632b610ccb0Srumble SCN_OP_BIC(sc, sc->sc_op_dtr | sc->sc_op_rts);
1633b610ccb0Srumble break;
1634b610ccb0Srumble
1635b610ccb0Srumble case TIOCMSET: {
1636b610ccb0Srumble int s;
1637b610ccb0Srumble unsigned char sbits, cbits;
1638b610ccb0Srumble
1639b610ccb0Srumble /* set bits */
1640b610ccb0Srumble sbits = opbits(sc, *(int *) data);
1641b610ccb0Srumble
1642b610ccb0Srumble /* get bits to clear */
1643b610ccb0Srumble cbits = ~sbits & (sc->sc_op_dtr | sc->sc_op_rts);
1644b610ccb0Srumble
1645b610ccb0Srumble s = spltty();
1646b610ccb0Srumble if (sbits) {
1647b610ccb0Srumble SCN_OP_BIS(sc, sbits);
1648b610ccb0Srumble }
1649b610ccb0Srumble if (cbits) {
1650b610ccb0Srumble SCN_OP_BIC(sc, cbits);
1651b610ccb0Srumble }
1652b610ccb0Srumble splx(s);
1653b610ccb0Srumble break;
1654b610ccb0Srumble }
1655b610ccb0Srumble
1656b610ccb0Srumble case TIOCMBIS:
1657b610ccb0Srumble SCN_OP_BIS(sc, opbits(sc, *(int *) data));
1658b610ccb0Srumble break;
1659b610ccb0Srumble
1660b610ccb0Srumble case TIOCMBIC:
1661b610ccb0Srumble SCN_OP_BIC(sc, opbits(sc, *(int *) data));
1662b610ccb0Srumble break;
1663b610ccb0Srumble
1664b610ccb0Srumble case TIOCMGET: {
1665b610ccb0Srumble int bits;
166621af650cSchristos unsigned char ip;
1667b610ccb0Srumble
1668b610ccb0Srumble /* s = spltty(); */
1669b610ccb0Srumble ip = sc->sc_duart->base[DU_IP];
1670b610ccb0Srumble /* splx(s); */
1671b610ccb0Srumble
1672b610ccb0Srumble bits = 0;
1673b610ccb0Srumble if (ip & sc->sc_ip_dcd)
1674b610ccb0Srumble bits |= TIOCM_CD;
1675b610ccb0Srumble if (ip & sc->sc_ip_cts)
1676b610ccb0Srumble bits |= TIOCM_CTS;
1677b610ccb0Srumble
1678b610ccb0Srumble #if 0
167921af650cSchristos /*
168021af650cSchristos * XXX sigh; cannot get op current state!! even if
168121af650cSchristos * maintained in private, RTS is done in h/w!!
168221af650cSchristos */
168321af650cSchristos unsigned char op = 0;
1684b610ccb0Srumble if (op & sc->sc_op_dtr)
1685b610ccb0Srumble bits |= TIOCM_DTR;
1686b610ccb0Srumble if (op & sc->sc_op_rts)
1687b610ccb0Srumble bits |= TIOCM_RTS;
1688b610ccb0Srumble #endif
1689b610ccb0Srumble
1690b610ccb0Srumble *(int *) data = bits;
1691b610ccb0Srumble break;
1692b610ccb0Srumble }
1693b610ccb0Srumble
1694b610ccb0Srumble case TIOCGFLAGS:{
1695b610ccb0Srumble int bits = 0;
1696b610ccb0Srumble
1697b610ccb0Srumble if (sc->sc_swflags & SCN_SW_SOFTCAR)
1698b610ccb0Srumble bits |= TIOCFLAG_SOFTCAR;
1699b610ccb0Srumble if (sc->sc_swflags & SCN_SW_CLOCAL)
1700b610ccb0Srumble bits |= TIOCFLAG_CLOCAL;
1701b610ccb0Srumble if (sc->sc_swflags & SCN_SW_CRTSCTS)
1702b610ccb0Srumble bits |= TIOCFLAG_CRTSCTS;
1703b610ccb0Srumble if (sc->sc_swflags & SCN_SW_MDMBUF)
1704b610ccb0Srumble bits |= TIOCFLAG_MDMBUF;
1705b610ccb0Srumble
1706b610ccb0Srumble *(int *) data = bits;
1707b610ccb0Srumble break;
1708b610ccb0Srumble }
1709b610ccb0Srumble case TIOCSFLAGS:{
1710b610ccb0Srumble int userbits, driverbits = 0;
1711b610ccb0Srumble
1712b610ccb0Srumble error = kauth_authorize_device_tty(l->l_cred,
1713b610ccb0Srumble KAUTH_DEVICE_TTY_PRIVSET, tp);
1714b610ccb0Srumble if (error != 0)
1715b610ccb0Srumble return (EPERM);
1716b610ccb0Srumble
1717b610ccb0Srumble userbits = *(int *) data;
1718b610ccb0Srumble if (userbits & TIOCFLAG_SOFTCAR)
1719b610ccb0Srumble driverbits |= SCN_SW_SOFTCAR;
1720b610ccb0Srumble if (userbits & TIOCFLAG_CLOCAL)
1721b610ccb0Srumble driverbits |= SCN_SW_CLOCAL;
1722b610ccb0Srumble if (userbits & TIOCFLAG_CRTSCTS)
1723b610ccb0Srumble driverbits |= SCN_SW_CRTSCTS;
1724b610ccb0Srumble if (userbits & TIOCFLAG_MDMBUF)
1725b610ccb0Srumble driverbits |= SCN_SW_MDMBUF;
1726b610ccb0Srumble
1727b610ccb0Srumble sc->sc_swflags = driverbits;
1728b610ccb0Srumble
1729b610ccb0Srumble break;
1730b610ccb0Srumble }
1731b610ccb0Srumble
1732b610ccb0Srumble default:
1733b610ccb0Srumble return (EPASSTHROUGH);
1734b610ccb0Srumble }
1735b610ccb0Srumble return (0);
1736b610ccb0Srumble }
1737b610ccb0Srumble
1738b610ccb0Srumble int
scnparam(struct tty * tp,struct termios * t)1739b610ccb0Srumble scnparam(struct tty *tp, struct termios *t)
1740b610ccb0Srumble {
1741b610ccb0Srumble int cflag = t->c_cflag;
1742b610ccb0Srumble int unit = DEV_UNIT(tp->t_dev);
1743b610ccb0Srumble char mr1, mr2;
1744b610ccb0Srumble int error;
1745b610ccb0Srumble struct scn_softc *sc = SOFTC(unit);
1746b610ccb0Srumble
1747b610ccb0Srumble /* Is this a hang up? */
1748b610ccb0Srumble if (t->c_ospeed == B0) {
1749b610ccb0Srumble SCN_OP_BIC(sc, sc->sc_op_dtr);
1750b610ccb0Srumble /* leave DTR down. see comment in scnclose() -plb */
1751b610ccb0Srumble return (0);
1752b610ccb0Srumble }
1753b610ccb0Srumble mr1 = mr2 = 0;
1754b610ccb0Srumble
1755b610ccb0Srumble /* Parity? */
1756b610ccb0Srumble if (cflag & PARENB) {
1757b610ccb0Srumble if ((cflag & PARODD) == 0)
1758b610ccb0Srumble mr1 |= MR1_PEVEN;
1759b610ccb0Srumble else
1760b610ccb0Srumble mr1 |= MR1_PODD;
1761b610ccb0Srumble } else
1762b610ccb0Srumble mr1 |= MR1_PNONE;
1763b610ccb0Srumble
1764b610ccb0Srumble /* Stop bits. */
1765b610ccb0Srumble if (cflag & CSTOPB)
1766b610ccb0Srumble mr2 |= MR2_STOP2;
1767b610ccb0Srumble else
1768b610ccb0Srumble mr2 |= MR2_STOP1;
1769b610ccb0Srumble
1770b610ccb0Srumble /* Data bits. */
1771b610ccb0Srumble switch (cflag & CSIZE) {
1772b610ccb0Srumble case CS5:
1773b610ccb0Srumble mr1 |= MR1_CS5;
1774b610ccb0Srumble break;
1775b610ccb0Srumble case CS6:
1776b610ccb0Srumble mr1 |= MR1_CS6;
1777b610ccb0Srumble break;
1778b610ccb0Srumble case CS7:
1779b610ccb0Srumble mr1 |= MR1_CS7;
1780b610ccb0Srumble break;
1781b610ccb0Srumble case CS8:
1782b610ccb0Srumble default:
1783b610ccb0Srumble mr1 |= MR1_CS8;
1784b610ccb0Srumble break;
1785b610ccb0Srumble }
1786b610ccb0Srumble
1787b610ccb0Srumble if (cflag & CCTS_OFLOW)
1788b610ccb0Srumble mr2 |= MR2_TXCTS;
1789b610ccb0Srumble
1790b610ccb0Srumble if (cflag & CRTS_IFLOW) {
1791b610ccb0Srumble mr1 |= MR1_RXRTS;
1792b610ccb0Srumble sc->sc_rbhiwat = SCN_RING_HIWAT;
1793b610ccb0Srumble } else {
1794b610ccb0Srumble sc->sc_rbhiwat = 0;
1795b610ccb0Srumble }
1796b610ccb0Srumble
1797b610ccb0Srumble error = scn_config(unit, sc->sc_channel, t->c_ispeed,
1798b610ccb0Srumble t->c_ospeed, mr1, mr2);
1799b610ccb0Srumble
1800b610ccb0Srumble /* If successful, copy to tty */
1801b610ccb0Srumble if (!error) {
1802b610ccb0Srumble tp->t_ispeed = t->c_ispeed;
1803b610ccb0Srumble tp->t_ospeed = t->c_ospeed;
1804b610ccb0Srumble tp->t_cflag = cflag;
1805b610ccb0Srumble }
1806b610ccb0Srumble return (error);
1807b610ccb0Srumble }
1808b610ccb0Srumble
1809b610ccb0Srumble /*
1810b610ccb0Srumble * Start or restart a transmission.
1811b610ccb0Srumble */
1812b610ccb0Srumble void
scnstart(struct tty * tp)1813b610ccb0Srumble scnstart(struct tty *tp)
1814b610ccb0Srumble {
1815b610ccb0Srumble int s, c;
1816b610ccb0Srumble int unit = DEV_UNIT(tp->t_dev);
1817b610ccb0Srumble struct scn_softc *sc = SOFTC(unit);
1818b610ccb0Srumble
1819b610ccb0Srumble s = spltty();
1820b610ccb0Srumble if (tp->t_state & (TS_BUSY | TS_TIMEOUT | TS_TTSTOP))
1821b610ccb0Srumble goto out;
1822b610ccb0Srumble if (!ttypull(tp))
1823b610ccb0Srumble goto out;
1824b610ccb0Srumble
1825b610ccb0Srumble tp->t_state |= TS_BUSY;
1826b610ccb0Srumble
1827b610ccb0Srumble while (sc->sc_chbase[CH_SR] & SR_TX_RDY) {
1828b610ccb0Srumble if ((c = getc(&tp->t_outq)) == -1)
1829b610ccb0Srumble break;
1830b610ccb0Srumble sc->sc_chbase[CH_DAT] = c;
1831b610ccb0Srumble }
1832b610ccb0Srumble sc->sc_duart->imr |= (sc->sc_tx_int | sc->sc_rx_int);
1833b610ccb0Srumble sc->sc_duart->base[DU_IMR] = sc->sc_duart->imr;
1834b610ccb0Srumble
1835b610ccb0Srumble out:
1836b610ccb0Srumble splx(s);
1837b610ccb0Srumble }
1838b610ccb0Srumble
1839b610ccb0Srumble /*
1840b610ccb0Srumble * Stop output on a line.
1841b610ccb0Srumble */
1842b610ccb0Srumble /*ARGSUSED*/
1843b610ccb0Srumble void
scnstop(struct tty * tp,int flags)1844b610ccb0Srumble scnstop(struct tty *tp, int flags)
1845b610ccb0Srumble {
1846b610ccb0Srumble int s;
1847b610ccb0Srumble
1848b610ccb0Srumble s = spltty();
1849b610ccb0Srumble if (tp->t_state & TS_BUSY) {
1850b610ccb0Srumble if ((tp->t_state & TS_TTSTOP) == 0)
1851b610ccb0Srumble tp->t_state |= TS_FLUSH;
1852b610ccb0Srumble }
1853b610ccb0Srumble splx(s);
1854b610ccb0Srumble }
1855b610ccb0Srumble
1856b610ccb0Srumble /*
1857b610ccb0Srumble * Following are all routines needed for SCN to act as console.
1858b610ccb0Srumble */
1859b610ccb0Srumble
1860b610ccb0Srumble void
scncnprobe(struct consdev * cn)1861b610ccb0Srumble scncnprobe(struct consdev *cn)
1862b610ccb0Srumble {
1863b610ccb0Srumble }
1864b610ccb0Srumble
1865b610ccb0Srumble void
scncnreinit(void * v)1866b610ccb0Srumble scncnreinit(void *v)
1867b610ccb0Srumble {
1868b610ccb0Srumble volatile u_char *du_base =
1869b610ccb0Srumble (volatile u_char *)MIPS_PHYS_TO_KSEG1(0x1fb80004);
1870b610ccb0Srumble
1871b610ccb0Srumble du_base[DU_OPSET] =
1872b610ccb0Srumble SCN_CONSCHAN ? (OP_RTSB | OP_DTRB) : (OP_RTSA | OP_DTRA);
1873b610ccb0Srumble }
1874b610ccb0Srumble
1875b610ccb0Srumble void
scncninit(struct consdev * cn)1876b610ccb0Srumble scncninit(struct consdev *cn)
1877b610ccb0Srumble {
1878b610ccb0Srumble devmajor_t major;
1879b610ccb0Srumble
1880b610ccb0Srumble /* initialize required fields */
1881b610ccb0Srumble major = cdevsw_lookup_major(&scn_cdevsw);
1882b610ccb0Srumble KASSERT(major != NODEV);
1883b610ccb0Srumble cn->cn_dev = makedev(major, SCN_CONSOLE);
1884b610ccb0Srumble cn->cn_pri = CN_REMOTE;
1885b610ccb0Srumble
1886b610ccb0Srumble scninit(cn->cn_dev, scnconsrate);
1887b610ccb0Srumble }
1888b610ccb0Srumble
1889b610ccb0Srumble /* Used by scncninit and kgdb startup. */
1890b610ccb0Srumble int
scninit(dev_t dev,int rate)1891b610ccb0Srumble scninit(dev_t dev, int rate)
1892b610ccb0Srumble {
1893b610ccb0Srumble /* XXX - maintain PROM's settings */
1894b610ccb0Srumble #if 0
1895b610ccb0Srumble volatile u_char *du_base =
1896b610ccb0Srumble (volatile u_char *)MIPS_PHYS_TO_KSEG1(0x1fb80004);
1897b610ccb0Srumble int unit = DEV_UNIT(dev);
1898b610ccb0Srumble
1899b610ccb0Srumble du_base[DU_OPSET] =
1900b610ccb0Srumble SCN_CONSCHAN ? (OP_RTSB | OP_DTRB) : (OP_RTSA | OP_DTRA);
1901b610ccb0Srumble scn_config(unit, SCN_CONSCHAN, rate, rate,
1902b610ccb0Srumble MR1_PNONE | MR1_CS8, MR2_STOP1);
1903b610ccb0Srumble #endif
1904b610ccb0Srumble return (0);
1905b610ccb0Srumble }
1906b610ccb0Srumble
1907b610ccb0Srumble /*
1908b610ccb0Srumble * Console kernel input character routine.
1909b610ccb0Srumble */
1910b610ccb0Srumble int
scncngetc(dev_t dev)1911b610ccb0Srumble scncngetc(dev_t dev)
1912b610ccb0Srumble {
1913b610ccb0Srumble volatile u_char *ch_base =
1914b610ccb0Srumble (volatile u_char *)MIPS_PHYS_TO_KSEG1(0x1fb80004);
1915b610ccb0Srumble char c;
1916b610ccb0Srumble int s;
1917b610ccb0Srumble
1918b610ccb0Srumble s = spltty();
1919b610ccb0Srumble
1920b610ccb0Srumble while ((ch_base[CH_SR] & SR_RX_RDY) == 0)
1921b610ccb0Srumble ;
1922b610ccb0Srumble c = ch_base[CH_DAT];
1923b610ccb0Srumble
1924b610ccb0Srumble splx(s);
1925b610ccb0Srumble return c;
1926b610ccb0Srumble }
1927b610ccb0Srumble
1928b610ccb0Srumble void
scncnpollc(dev_t dev,int on)1929b610ccb0Srumble scncnpollc(dev_t dev, int on)
1930b610ccb0Srumble {
1931b610ccb0Srumble }
1932b610ccb0Srumble
1933b610ccb0Srumble /*
1934b610ccb0Srumble * Console kernel output character routine.
1935b610ccb0Srumble */
1936b610ccb0Srumble void
scncnputc(dev_t dev,int c)1937b610ccb0Srumble scncnputc(dev_t dev, int c)
1938b610ccb0Srumble {
1939b610ccb0Srumble volatile u_char *ch_base =
1940b610ccb0Srumble (volatile u_char *)MIPS_PHYS_TO_KSEG1(0x1fb80004);
1941b610ccb0Srumble volatile u_char *du_base =
1942b610ccb0Srumble (volatile u_char *)MIPS_PHYS_TO_KSEG1(0x1fb80004);
1943b610ccb0Srumble int s;
1944b610ccb0Srumble
1945b610ccb0Srumble s = spltty();
1946b610ccb0Srumble
1947b610ccb0Srumble if (c == '\n')
1948b610ccb0Srumble scncnputc(dev, '\r');
1949b610ccb0Srumble
1950b610ccb0Srumble while ((ch_base[CH_SR] & SR_TX_RDY) == 0)
1951b610ccb0Srumble ;
1952b610ccb0Srumble ch_base[CH_DAT] = c;
1953b610ccb0Srumble while ((ch_base[CH_SR] & SR_TX_RDY) == 0)
1954b610ccb0Srumble ;
1955b610ccb0Srumble du_base[DU_ISR];
1956b610ccb0Srumble
1957b610ccb0Srumble splx(s);
1958b610ccb0Srumble }
1959