1 /* $NetBSD: sbscn.c,v 1.45 2021/01/04 18:19:53 thorpej Exp $ */
2
3 /*
4 * Copyright 2000, 2001
5 * Broadcom Corporation. All rights reserved.
6 *
7 * This software is furnished under license and may be used and copied only
8 * in accordance with the following terms and conditions. Subject to these
9 * conditions, you may download, copy, install, use, modify and distribute
10 * modified or unmodified copies of this software in source and/or binary
11 * form. No title or ownership is transferred hereby.
12 *
13 * 1) Any source code used, modified or distributed must reproduce and
14 * retain this copyright notice and list of conditions as they appear in
15 * the source file.
16 *
17 * 2) No right is granted to use any trade name, trademark, or logo of
18 * Broadcom Corporation. The "Broadcom Corporation" name may not be
19 * used to endorse or promote products derived from this software
20 * without the prior written permission of Broadcom Corporation.
21 *
22 * 3) THIS SOFTWARE IS PROVIDED "AS-IS" AND ANY EXPRESS OR IMPLIED
23 * WARRANTIES, INCLUDING BUT NOT LIMITED TO, ANY IMPLIED WARRANTIES OF
24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
25 * NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL BROADCOM BE LIABLE
26 * FOR ANY DAMAGES WHATSOEVER, AND IN PARTICULAR, BROADCOM SHALL NOT BE
27 * LIABLE FOR DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
31 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
32 * OR OTHERWISE), EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 /* from: $NetBSD: com.c,v 1.172 2000/05/03 19:19:04 thorpej Exp */
36
37 /*-
38 * Copyright (c) 1998, 1999 The NetBSD Foundation, Inc.
39 * All rights reserved.
40 *
41 * This code is derived from software contributed to The NetBSD Foundation
42 * by Charles M. Hannum.
43 *
44 * Redistribution and use in source and binary forms, with or without
45 * modification, are permitted provided that the following conditions
46 * are met:
47 * 1. Redistributions of source code must retain the above copyright
48 * notice, this list of conditions and the following disclaimer.
49 * 2. Redistributions in binary form must reproduce the above copyright
50 * notice, this list of conditions and the following disclaimer in the
51 * documentation and/or other materials provided with the distribution.
52 *
53 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
54 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
55 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
56 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
57 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
58 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
59 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
60 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
61 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
62 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
63 * POSSIBILITY OF SUCH DAMAGE.
64 */
65
66 /*
67 * Copyright (c) 1991 The Regents of the University of California.
68 * All rights reserved.
69 *
70 * Redistribution and use in source and binary forms, with or without
71 * modification, are permitted provided that the following conditions
72 * are met:
73 * 1. Redistributions of source code must retain the above copyright
74 * notice, this list of conditions and the following disclaimer.
75 * 2. Redistributions in binary form must reproduce the above copyright
76 * notice, this list of conditions and the following disclaimer in the
77 * documentation and/or other materials provided with the distribution.
78 * 3. Neither the name of the University nor the names of its contributors
79 * may be used to endorse or promote products derived from this software
80 * without specific prior written permission.
81 *
82 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
83 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
84 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
85 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
86 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
87 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
88 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
89 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
90 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
91 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
92 * SUCH DAMAGE.
93 *
94 * @(#)com.c 7.5 (Berkeley) 5/16/91
95 */
96
97 /*
98 * `sbscn' driver, supports SiByte SB-1250 SOC DUART.
99 *
100 * This DUART is quite similar in programming model to the scn2681/68681
101 * DUARTs supported by the NetBSD/amiga `mfc' and NetBSD/pc532 `scn'
102 * driver, but substantial rework would have been necessary to make
103 * those drivers sane w.r.t. bus_space (which would then have been
104 * required on NetBSD/sbmips very early on), and to accommodate the
105 * different register mappings.
106 *
107 * So, another driver. Eventually there should be One True Driver,
108 * but we're not here to save the world.
109 */
110
111 #include <sys/cdefs.h>
112 __KERNEL_RCSID(0, "$NetBSD: sbscn.c,v 1.45 2021/01/04 18:19:53 thorpej Exp $");
113
114 #define SBSCN_DEBUG
115
116 #include "opt_ddb.h"
117 #include "ioconf.h"
118
119 #ifdef RND_SBSCN
120 #include <sys/rndsource.h>
121 #endif
122
123 #include <sys/param.h>
124 #include <sys/systm.h>
125 #include <sys/ioctl.h>
126 #include <sys/select.h>
127 #include <sys/tty.h>
128 #include <sys/proc.h>
129 #include <sys/conf.h>
130 #include <sys/file.h>
131 #include <sys/uio.h>
132 #include <sys/kernel.h>
133 #include <sys/syslog.h>
134 #include <sys/types.h>
135 #include <sys/device.h>
136 #include <sys/kmem.h>
137 #include <sys/vnode.h>
138 #include <sys/kauth.h>
139 #include <sys/intr.h>
140
141 #include <mips/sibyte/dev/sbobiovar.h>
142 #if 0
143 #include <mips/sibyte/dev/sbscnreg.h>
144 #endif
145 #include <mips/sibyte/dev/sbscnvar.h>
146 #include <dev/cons.h>
147 #include <mips/locore.h>
148
149 #include <evbmips/sbmips/systemsw.h>
150
151 void sbscn_attach_channel(struct sbscn_softc *sc, int chan, int intr);
152 #if defined(DDB) || defined(KGDB)
153 static void sbscn_enable_debugport(struct sbscn_channel *ch);
154 #endif
155 void sbscn_config(struct sbscn_channel *ch);
156 void sbscn_shutdown(struct sbscn_channel *ch);
157 int sbscn_speed(long, long *);
158 static int cflag2modes(tcflag_t, u_char *, u_char *);
159 int sbscn_param(struct tty *, struct termios *);
160 void sbscn_start(struct tty *);
161 int sbscn_hwiflow(struct tty *, int);
162
163 void sbscn_loadchannelregs(struct sbscn_channel *);
164 void sbscn_dohwiflow(struct sbscn_channel *);
165 void sbscn_break(struct sbscn_channel *, int);
166 void sbscn_modem(struct sbscn_channel *, int);
167 void tiocm_to_sbscn(struct sbscn_channel *, int, int);
168 int sbscn_to_tiocm(struct sbscn_channel *);
169 void sbscn_iflush(struct sbscn_channel *);
170
171 int sbscn_init(u_long addr, int chan, int rate, tcflag_t cflag);
172 int sbscn_common_getc(u_long addr, int chan);
173 void sbscn_common_putc(u_long addr, int chan, int c);
174 void sbscn_intr(void *arg, uint32_t status, vaddr_t pc);
175
176 int sbscn_cngetc(dev_t dev);
177 void sbscn_cnputc(dev_t dev, int c);
178 void sbscn_cnpollc(dev_t dev, int on);
179
180 dev_type_open(sbscnopen);
181 dev_type_close(sbscnclose);
182 dev_type_read(sbscnread);
183 dev_type_write(sbscnwrite);
184 dev_type_ioctl(sbscnioctl);
185 dev_type_stop(sbscnstop);
186 dev_type_tty(sbscntty);
187 dev_type_poll(sbscnpoll);
188
189 const struct cdevsw sbscn_cdevsw = {
190 .d_open = sbscnopen,
191 .d_close = sbscnclose,
192 .d_read = sbscnread,
193 .d_write = sbscnwrite,
194 .d_ioctl = sbscnioctl,
195 .d_stop = sbscnstop,
196 .d_tty = sbscntty,
197 .d_poll = sbscnpoll,
198 .d_mmap = nommap,
199 .d_kqfilter = ttykqfilter,
200 .d_discard = nodiscard,
201 .d_flag = D_TTY
202 };
203
204 #define integrate static inline
205 void sbscn_soft(void *);
206 integrate void sbscn_rxsoft(struct sbscn_channel *, struct tty *);
207 integrate void sbscn_txsoft(struct sbscn_channel *, struct tty *);
208 integrate void sbscn_stsoft(struct sbscn_channel *, struct tty *);
209 integrate void sbscn_schedrx(struct sbscn_channel *);
210 void sbscn_diag(void *);
211
212 /*
213 * Make this an option variable one can patch.
214 * But be warned: this must be a power of 2!
215 */
216 u_int sbscn_rbuf_size = SBSCN_RING_SIZE;
217
218 /* Stop input when 3/4 of the ring is full; restart when only 1/4 is full. */
219 u_int sbscn_rbuf_hiwat = (SBSCN_RING_SIZE * 1) / 4;
220 u_int sbscn_rbuf_lowat = (SBSCN_RING_SIZE * 3) / 4;
221
222 static int sbscn_cons_present;
223 static int sbscn_cons_attached;
224 static u_long sbscn_cons_addr;
225 static int sbscn_cons_chan;
226 static int sbscn_cons_rate;
227 static tcflag_t sbscn_cons_cflag;
228
229 #ifdef KGDB
230 #include <sys/kgdb.h>
231
232 static int sbscn_kgdb_present;
233 static int sbscn_kgdb_attached;
234 static u_long sbscn_kgdb_addr;
235 static int sbscn_kgdb_chan;
236
237 int sbscn_kgdb_getc(void *);
238 void sbscn_kgdb_putc(void *, int);
239 #endif /* KGDB */
240
241 static int sbscn_match(device_t, cfdata_t, void *);
242 static void sbscn_attach(device_t, device_t, void *);
243
244 CFATTACH_DECL_NEW(sbscn, sizeof(struct sbscn_softc),
245 sbscn_match, sbscn_attach, NULL, NULL);
246
247 #define READ_REG(rp) (mips3_ld((register_t)(rp)))
248 #define WRITE_REG(rp, val) (mips3_sd((register_t)(rp), (val)))
249
250 /*
251 * input and output signals are actually the _inverse_ of the bits in the
252 * input and output port registers!
253 */
254 #define GET_INPUT_SIGNALS(ch) \
255 ((~READ_REG(MIPS_PHYS_TO_KSEG1((ch)->ch_sc->sc_addr + 0x280))) & (ch)->ch_i_mask)
256 #define SET_OUTPUT_SIGNALS(ch, val) \
257 do { \
258 int sigs_to_set, sigs_to_clr; \
259 \
260 sigs_to_set = (ch)->ch_o_mask & val; \
261 sigs_to_clr = (ch)->ch_o_mask & ~val; \
262 \
263 /* set signals by clearing op bits, and vice versa */ \
264 WRITE_REG(MIPS_PHYS_TO_KSEG1((ch)->ch_sc->sc_addr + 0x2c0), \
265 sigs_to_set); \
266 WRITE_REG(MIPS_PHYS_TO_KSEG1((ch)->ch_sc->sc_addr + 0x2b0), \
267 sigs_to_clr); \
268 } while (0)
269
270 static int
sbscn_match(device_t parent,cfdata_t match,void * aux)271 sbscn_match(device_t parent, cfdata_t match, void *aux)
272 {
273 struct sbobio_attach_args *sa = aux;
274
275 if (sa->sa_locs.sa_type != SBOBIO_DEVTYPE_DUART)
276 return (0);
277
278 return 1;
279 }
280
281 static void
sbscn_attach(device_t parent,device_t self,void * aux)282 sbscn_attach(device_t parent, device_t self, void *aux)
283 {
284 struct sbscn_softc *sc = device_private(self);
285 struct sbobio_attach_args *sa = aux;
286 int i;
287
288 sc->sc_dev = self;
289 sc->sc_addr = sa->sa_base + sa->sa_locs.sa_offset;
290
291 aprint_normal("\n");
292 for (i = 0; i < 2; i++)
293 sbscn_attach_channel(sc, i, sa->sa_locs.sa_intr[i]);
294
295 /* init duart_opcr */
296 WRITE_REG(MIPS_PHYS_TO_KSEG1(sc->sc_addr + 0x270), 0);
297 /* init duart_aux_ctrl */
298 WRITE_REG(MIPS_PHYS_TO_KSEG1(sc->sc_addr + 0x210), 0x0f); /* XXX */
299 }
300
301 void
sbscn_attach_channel(struct sbscn_softc * sc,int chan,int intr)302 sbscn_attach_channel(struct sbscn_softc *sc, int chan, int intr)
303 {
304 struct sbscn_channel *ch = &sc->sc_channels[chan];
305 u_long chan_addr;
306 struct tty *tp;
307
308 ch->ch_sc = sc;
309 ch->ch_num = chan;
310
311 chan_addr = sc->sc_addr + (0x100 * chan);
312 ch->ch_base = (void *)MIPS_PHYS_TO_KSEG1(chan_addr);
313 ch->ch_isr_base =
314 (void *)MIPS_PHYS_TO_KSEG1(sc->sc_addr + 0x220 + (0x20 * chan));
315 ch->ch_imr_base =
316 (void *)MIPS_PHYS_TO_KSEG1(sc->sc_addr + 0x230 + (0x20 * chan));
317 #ifdef XXXCGDnotyet
318 ch->ch_inchg_base =
319 (void *)MIPS_PHYS_TO_KSEG1(sc->sc_addr + 0x2d0 + (0x10 * chan));
320 #endif
321
322 ch->ch_i_dcd = ch->ch_i_dcd_pin = 0 /* XXXCGD */;
323 ch->ch_i_cts = ch->ch_i_cts_pin = 0 /* XXXCGD */;
324 ch->ch_i_dsr = ch->ch_i_dsr_pin = 0 /* XXXCGD */;
325 ch->ch_i_ri = ch->ch_i_ri_pin = 0 /* XXXCGD */;
326 ch->ch_i_mask =
327 ch->ch_i_dcd | ch->ch_i_cts | ch->ch_i_dsr | ch->ch_i_ri;
328 ch->ch_o_dtr = ch->ch_o_dtr_pin = 0 /* XXXCGD */;
329 ch->ch_o_rts = ch->ch_o_rts_pin = 0 /* XXXCGD */;
330 ch->ch_o_mask = ch->ch_o_dtr | ch->ch_o_rts;
331
332 ch->ch_intrhand = cpu_intr_establish(intr, IPL_SERIAL, sbscn_intr, ch);
333 callout_init(&ch->ch_diag_callout, 0);
334
335 /* Disable interrupts before configuring the device. */
336 ch->ch_imr = 0;
337 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
338
339 if (sbscn_cons_present &&
340 sbscn_cons_addr == chan_addr && sbscn_cons_chan == chan) {
341 sbscn_cons_attached = 1;
342
343 /* Make sure the console is always "hardwired". */
344 delay(1000); /* wait for output to finish */
345 SET(ch->ch_hwflags, SBSCN_HW_CONSOLE);
346 SET(ch->ch_swflags, TIOCFLAG_SOFTCAR);
347 }
348
349 tp = tty_alloc();
350 tp->t_oproc = sbscn_start;
351 tp->t_param = sbscn_param;
352 tp->t_hwiflow = sbscn_hwiflow;
353
354 ch->ch_tty = tp;
355 ch->ch_rbuf = kmem_alloc(sbscn_rbuf_size << 1, KM_SLEEP);
356 ch->ch_ebuf = ch->ch_rbuf + (sbscn_rbuf_size << 1);
357
358 tty_attach(tp);
359
360 if (ISSET(ch->ch_hwflags, SBSCN_HW_CONSOLE)) {
361 int maj;
362
363 /* locate the major number */
364 maj = cdevsw_lookup_major(&sbscn_cdevsw);
365
366 cn_tab->cn_dev = makedev(maj,
367 (device_unit(sc->sc_dev) << 1) + chan);
368
369 aprint_normal_dev(sc->sc_dev, "channel %d: %s\n",
370 chan, "console");
371 }
372
373 #ifdef KGDB
374 /*
375 * Allow kgdb to "take over" this port. If this is
376 * the kgdb device, it has exclusive use.
377 */
378 if (sbscn_kgdb_present &&
379 sbscn_kgdb_addr == chan_addr && sbscn_kgdb_chan == chan) {
380 sbscn_kgdb_attached = 1;
381
382 SET(sc->sc_hwflags, SBSCN_HW_KGDB);
383 aprint_normal_dev(sc->sc_dev, "channel %d: %s\n",
384 chan, "kgdb");
385 }
386 #endif
387
388 ch->ch_si = softint_establish(SOFTINT_SERIAL, sbscn_soft, ch);
389
390 #ifdef RND_SBSCN
391 rnd_attach_source(&ch->ch_rnd_source, device_xname(sc->sc_dev),
392 RND_TYPE_TTY, RND_FLAG_COLLECT_TIME|
393 RND_FLAG_ESTIMATE_TIME);
394 #endif
395
396 sbscn_config(ch);
397
398 SET(ch->ch_hwflags, SBSCN_HW_DEV_OK);
399 }
400
401 int
sbscn_speed(long speed,long * brcp)402 sbscn_speed(long speed, long *brcp)
403 {
404 #define divrnd(n, q) (((n)*2/(q)+1)/2) /* divide and round off */
405
406 int x, err;
407 int frequency = 100000000;
408
409 *brcp = divrnd(frequency / 20, speed) - 1;
410
411 if (speed <= 0)
412 return (-1);
413 x = divrnd(frequency / 20, speed);
414 if (x <= 0)
415 return (-1);
416 err = divrnd(((quad_t)frequency) * 1000 / 20, speed * x) - 1000;
417 if (err < 0)
418 err = -err;
419 if (err > SBSCN_TOLERANCE)
420 return (-1);
421 *brcp = x - 1;
422 return (0);
423
424 #undef divrnd
425 }
426
427 #ifdef SBSCN_DEBUG
428 void sbscn_status(struct sbscn_channel *, const char *);
429
430 int sbscn_debug = 0 /* XXXCGD */;
431
432 void
sbscn_status(struct sbscn_channel * ch,const char * str)433 sbscn_status(struct sbscn_channel *ch, const char *str)
434 {
435 struct sbscn_softc *sc = ch->ch_sc;
436 struct tty *tp = ch->ch_tty;
437
438 aprint_normal_dev(sc->sc_dev,
439 "chan %d: %s %sclocal %sdcd %sts_carr_on %sdtr %stx_stopped\n",
440 ch->ch_num, str,
441 ISSET(tp->t_cflag, CLOCAL) ? "+" : "-",
442 ISSET(ch->ch_iports, ch->ch_i_dcd) ? "+" : "-",
443 ISSET(tp->t_state, TS_CARR_ON) ? "+" : "-",
444 ISSET(ch->ch_oports, ch->ch_o_dtr) ? "+" : "-",
445 ch->ch_tx_stopped ? "+" : "-");
446
447 aprint_normal_dev(sc->sc_dev,
448 "chan %d: %s %scrtscts %scts %sts_ttstop %srts %xrx_flags\n",
449 ch->ch_num, str,
450 ISSET(tp->t_cflag, CRTSCTS) ? "+" : "-",
451 ISSET(ch->ch_iports, ch->ch_i_cts) ? "+" : "-",
452 ISSET(tp->t_state, TS_TTSTOP) ? "+" : "-",
453 ISSET(ch->ch_oports, ch->ch_o_rts) ? "+" : "-",
454 ch->ch_rx_flags);
455 }
456 #endif
457
458 #if defined(DDB) || defined(KGDB)
459 static void
sbscn_enable_debugport(struct sbscn_channel * ch)460 sbscn_enable_debugport(struct sbscn_channel *ch)
461 {
462 int s;
463
464 /* Turn on line break interrupt, set carrier. */
465 s = splserial();
466
467 #if 0 /* DO NOT turn on break interrupt at this time. */
468 ch->ch_imr = 0x04;
469 #else
470 ch->ch_imr = 0x00;
471 #endif
472 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
473 SET(ch->ch_oports, ch->ch_o_dtr | ch->ch_o_rts);
474 SET_OUTPUT_SIGNALS(ch, ch->ch_oports);
475
476 splx(s);
477 }
478 #endif
479
480 void
sbscn_config(struct sbscn_channel * ch)481 sbscn_config(struct sbscn_channel *ch)
482 {
483
484 /* Disable interrupts before configuring the device. */
485 ch->ch_imr = 0x00;
486 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
487
488 #ifdef DDB
489 if (ISSET(ch->ch_hwflags, SBSCN_HW_CONSOLE))
490 sbscn_enable_debugport(ch);
491 #endif
492
493 #ifdef KGDB
494 /*
495 * Allow kgdb to "take over" this port. If this is
496 * the kgdb device, it has exclusive use.
497 */
498 if (ISSET(ch->ch_hwflags, SBSCN_HW_KGDB))
499 sbscn_enable_debugport(ch);
500 #endif
501 }
502
503 void
sbscn_shutdown(struct sbscn_channel * ch)504 sbscn_shutdown(struct sbscn_channel *ch)
505 {
506 struct tty *tp = ch->ch_tty;
507 int s;
508
509 s = splserial();
510
511 /* If we were asserting flow control, then deassert it. */
512 SET(ch->ch_rx_flags, RX_IBUF_BLOCKED);
513 sbscn_dohwiflow(ch);
514
515 /* Clear any break condition set with TIOCSBRK. */
516 sbscn_break(ch, 0);
517
518 /*
519 * Hang up if necessary. Wait a bit, so the other side has time to
520 * notice even if we immediately open the port again.
521 * Avoid tsleeping above splhigh().
522 */
523 if (ISSET(tp->t_cflag, HUPCL)) {
524 sbscn_modem(ch, 0);
525 splx(s);
526 /* XXX tsleep will only timeout */
527 (void) tsleep(ch, TTIPRI, ttclos, hz);
528 s = splserial();
529 }
530
531 /* Turn off interrupts. */
532 #ifdef DDB
533 if (ISSET(ch->ch_hwflags, SBSCN_HW_CONSOLE))
534 #if 0 /* DO NOT turn on break interrupt at this time. */
535 ch->ch_imr = 0x04; /* interrupt on break */
536 #else
537 ch->ch_imr = 0x00;
538 #endif
539 else
540 #endif
541 ch->ch_imr = 0;
542 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
543
544 splx(s);
545 }
546
547 int
sbscnopen(dev_t dev,int flag,int mode,struct lwp * l)548 sbscnopen(dev_t dev, int flag, int mode, struct lwp *l)
549 {
550 int chan = SBSCN_CHAN(dev);
551 struct sbscn_softc *sc;
552 struct sbscn_channel *ch;
553 struct tty *tp;
554 int s, s2;
555 int error;
556
557 sc = device_lookup_private(&sbscn_cd, SBSCN_UNIT(dev));
558 if (sc == NULL)
559 return (ENXIO);
560 ch = &sc->sc_channels[chan];
561 if (!ISSET(ch->ch_hwflags, SBSCN_HW_DEV_OK) || ch->ch_rbuf == NULL)
562 return (ENXIO);
563
564 #ifdef KGDB
565 /*
566 * If this is the kgdb port, no other use is permitted.
567 */
568 if (ISSET(ch->ch_hwflags, SBSCN_HW_KGDB))
569 return (EBUSY);
570 #endif
571
572 tp = ch->ch_tty;
573
574 if (kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_OPEN, tp))
575 return (EBUSY);
576
577 s = spltty();
578
579 /*
580 * Do the following iff this is a first open.
581 */
582 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
583 struct termios t;
584
585 tp->t_dev = dev;
586
587 s2 = splserial();
588
589 /* Turn on receive, break, and status change interrupts. */
590 #if 0 /* DO NOT turn on break or status change interrupt at this time. */
591 ch->ch_imr = 0xe;
592 #else
593 ch->ch_imr = 0x2;
594 #endif
595 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
596
597 /* Fetch the current modem control status, needed later. */
598 ch->ch_iports = GET_INPUT_SIGNALS(ch);
599 ch->ch_iports_delta = 0;
600 splx(s2);
601
602 /*
603 * Initialize the termios status to the defaults. Add in the
604 * sticky bits from TIOCSFLAGS.
605 */
606 t.c_ispeed = 0;
607 if (ISSET(ch->ch_hwflags, SBSCN_HW_CONSOLE)) {
608 t.c_ospeed = sbscn_cons_rate;
609 t.c_cflag = sbscn_cons_cflag;
610 } else {
611 t.c_ospeed = TTYDEF_SPEED;
612 t.c_cflag = TTYDEF_CFLAG;
613 }
614 if (ISSET(ch->ch_swflags, TIOCFLAG_CLOCAL))
615 SET(t.c_cflag, CLOCAL);
616 if (ISSET(ch->ch_swflags, TIOCFLAG_CRTSCTS))
617 SET(t.c_cflag, CRTSCTS);
618 if (ISSET(ch->ch_swflags, TIOCFLAG_MDMBUF))
619 SET(t.c_cflag, MDMBUF);
620 /* Make sure sbscn_param() will do something. */
621 tp->t_ospeed = 0;
622 (void) sbscn_param(tp, &t);
623 tp->t_iflag = TTYDEF_IFLAG;
624 tp->t_oflag = TTYDEF_OFLAG;
625 tp->t_lflag = TTYDEF_LFLAG;
626 ttychars(tp);
627 ttsetwater(tp);
628
629 s2 = splserial();
630
631 /*
632 * Turn on DTR. We must always do this, even if carrier is not
633 * present, because otherwise we'd have to use TIOCSDTR
634 * immediately after setting CLOCAL, which applications do not
635 * expect. We always assert DTR while the device is open
636 * unless explicitly requested to deassert it.
637 */
638 sbscn_modem(ch, 1);
639
640 /* Clear the input ring, and unblock. */
641 ch->ch_rbput = ch->ch_rbget = ch->ch_rbuf;
642 ch->ch_rbavail = sbscn_rbuf_size;
643 sbscn_iflush(ch);
644 CLR(ch->ch_rx_flags, RX_ANY_BLOCK);
645 sbscn_dohwiflow(ch);
646
647 #ifdef SBSCN_DEBUG
648 if (sbscn_debug)
649 sbscn_status(ch, "sbscnopen ");
650 #endif
651
652 splx(s2);
653 }
654
655 splx(s);
656
657 error = ttyopen(tp, SBSCN_DIALOUT(dev), ISSET(flag, O_NONBLOCK));
658 if (error)
659 goto bad;
660
661 error = (*tp->t_linesw->l_open)(dev, tp);
662 if (error)
663 goto bad;
664
665 return (0);
666
667 bad:
668 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
669 /*
670 * We failed to open the device, and nobody else had it opened.
671 * Clean up the state as appropriate.
672 */
673 sbscn_shutdown(ch);
674 }
675
676 return (error);
677 }
678
679 int
sbscnclose(dev_t dev,int flag,int mode,struct lwp * l)680 sbscnclose(dev_t dev, int flag, int mode, struct lwp *l)
681 {
682 struct sbscn_softc *sc = device_lookup_private(&sbscn_cd, SBSCN_UNIT(dev));
683 struct sbscn_channel *ch = &sc->sc_channels[SBSCN_CHAN(dev)];
684 struct tty *tp = ch->ch_tty;
685
686 /* XXX This is for cons.c. */
687 if (!ISSET(tp->t_state, TS_ISOPEN))
688 return (0);
689
690 (*tp->t_linesw->l_close)(tp, flag);
691 ttyclose(tp);
692
693 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
694 /*
695 * Although we got a last close, the device may still be in
696 * use; e.g. if this was the dialout node, and there are still
697 * processes waiting for carrier on the non-dialout node.
698 */
699 sbscn_shutdown(ch);
700 }
701
702 return (0);
703 }
704
705 int
sbscnread(dev_t dev,struct uio * uio,int flag)706 sbscnread(dev_t dev, struct uio *uio, int flag)
707 {
708 struct sbscn_softc *sc = device_lookup_private(&sbscn_cd, SBSCN_UNIT(dev));
709 struct sbscn_channel *ch = &sc->sc_channels[SBSCN_CHAN(dev)];
710 struct tty *tp = ch->ch_tty;
711
712 return ((*tp->t_linesw->l_read)(tp, uio, flag));
713 }
714
715 int
sbscnwrite(dev_t dev,struct uio * uio,int flag)716 sbscnwrite(dev_t dev, struct uio *uio, int flag)
717 {
718 struct sbscn_softc *sc = device_lookup_private(&sbscn_cd, SBSCN_UNIT(dev));
719 struct sbscn_channel *ch = &sc->sc_channels[SBSCN_CHAN(dev)];
720 struct tty *tp = ch->ch_tty;
721
722 return ((*tp->t_linesw->l_write)(tp, uio, flag));
723 }
724
725 int
sbscnpoll(dev_t dev,int events,struct lwp * l)726 sbscnpoll(dev_t dev, int events, struct lwp *l)
727 {
728 struct sbscn_softc *sc = device_lookup_private(&sbscn_cd, SBSCN_UNIT(dev));
729 struct sbscn_channel *ch = &sc->sc_channels[SBSCN_CHAN(dev)];
730 struct tty *tp = ch->ch_tty;
731
732 return ((*tp->t_linesw->l_poll)(tp, events, l));
733 }
734
735 struct tty *
sbscntty(dev_t dev)736 sbscntty(dev_t dev)
737 {
738 struct sbscn_softc *sc = device_lookup_private(&sbscn_cd, SBSCN_UNIT(dev));
739 struct sbscn_channel *ch = &sc->sc_channels[SBSCN_CHAN(dev)];
740 struct tty *tp = ch->ch_tty;
741
742 return (tp);
743 }
744
745 int
sbscnioctl(dev_t dev,u_long cmd,void * data,int flag,struct lwp * l)746 sbscnioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
747 {
748 struct sbscn_softc *sc = device_lookup_private(&sbscn_cd, SBSCN_UNIT(dev));
749 struct sbscn_channel *ch = &sc->sc_channels[SBSCN_CHAN(dev)];
750 struct tty *tp = ch->ch_tty;
751 int error;
752 int s;
753
754 error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
755 if (error != EPASSTHROUGH)
756 return (error);
757
758 error = ttioctl(tp, cmd, data, flag, l);
759 if (error != EPASSTHROUGH)
760 return (error);
761
762 error = 0;
763
764 s = splserial();
765
766 switch (cmd) {
767 case TIOCSBRK:
768 sbscn_break(ch, 1);
769 break;
770
771 case TIOCCBRK:
772 sbscn_break(ch, 0);
773 break;
774
775 case TIOCSDTR:
776 sbscn_modem(ch, 1);
777 break;
778
779 case TIOCCDTR:
780 sbscn_modem(ch, 0);
781 break;
782
783 case TIOCGFLAGS:
784 *(int *)data = ch->ch_swflags;
785 break;
786
787 case TIOCSFLAGS:
788 error = kauth_authorize_device_tty(l->l_cred,
789 KAUTH_DEVICE_TTY_PRIVSET, tp);
790 if (error)
791 break;
792 ch->ch_swflags = *(int *)data;
793 break;
794
795 case TIOCMSET:
796 case TIOCMBIS:
797 case TIOCMBIC:
798 tiocm_to_sbscn(ch, cmd, *(int *)data);
799 break;
800
801 case TIOCMGET:
802 *(int *)data = sbscn_to_tiocm(ch);
803 break;
804
805 default:
806 error = EPASSTHROUGH;
807 break;
808 }
809
810 splx(s);
811
812 #ifdef SBSCN_DEBUG
813 if (sbscn_debug)
814 sbscn_status(ch, "sbscn_ioctl ");
815 #endif
816
817 return (error);
818 }
819
820 integrate void
sbscn_schedrx(struct sbscn_channel * ch)821 sbscn_schedrx(struct sbscn_channel *ch)
822 {
823
824 ch->ch_rx_ready = 1;
825
826 /* Wake up the poller. */
827 softint_schedule(ch->ch_si);
828 }
829
830 void
sbscn_break(struct sbscn_channel * ch,int onoff)831 sbscn_break(struct sbscn_channel *ch, int onoff)
832 {
833
834 /* XXXCGD delay break until not busy */
835 if (onoff)
836 WRITE_REG(ch->ch_base + 0x50, 0x60);
837 else
838 WRITE_REG(ch->ch_base + 0x50, 0x70);
839
840 #if 0
841 if (!ch->ch_heldchange) {
842 if (ch->ch_tx_busy) {
843 ch->ch_heldtbc = ch->ch_tbc;
844 ch->ch_tbc = 0;
845 ch->ch_heldchange = 1;
846 } else
847 sbscn_loadchannelregs(ch);
848 }
849 #endif
850 }
851
852 void
sbscn_modem(struct sbscn_channel * ch,int onoff)853 sbscn_modem(struct sbscn_channel *ch, int onoff)
854 {
855
856 if (ch->ch_o_dtr == 0)
857 return;
858
859 if (onoff)
860 SET(ch->ch_oports, ch->ch_o_dtr);
861 else
862 CLR(ch->ch_oports, ch->ch_o_dtr);
863
864 if (!ch->ch_heldchange) {
865 if (ch->ch_tx_busy) {
866 ch->ch_heldtbc = ch->ch_tbc;
867 ch->ch_tbc = 0;
868 ch->ch_heldchange = 1;
869 } else
870 sbscn_loadchannelregs(ch);
871 }
872 }
873
874 void
tiocm_to_sbscn(struct sbscn_channel * ch,int how,int ttybits)875 tiocm_to_sbscn(struct sbscn_channel *ch, int how, int ttybits)
876 {
877 u_char bits;
878
879 bits = 0;
880 if (ISSET(ttybits, TIOCM_DTR))
881 SET(bits, ch->ch_o_dtr);
882 if (ISSET(ttybits, TIOCM_RTS))
883 SET(bits, ch->ch_o_rts);
884
885 switch (how) {
886 case TIOCMBIC:
887 CLR(ch->ch_oports, bits);
888 break;
889
890 case TIOCMBIS:
891 SET(ch->ch_oports, bits);
892 break;
893
894 case TIOCMSET:
895 ch->ch_oports = bits;
896 break;
897 }
898
899 if (!ch->ch_heldchange) {
900 if (ch->ch_tx_busy) {
901 ch->ch_heldtbc = ch->ch_tbc;
902 ch->ch_tbc = 0;
903 ch->ch_heldchange = 1;
904 } else
905 sbscn_loadchannelregs(ch);
906 }
907 }
908
909 int
sbscn_to_tiocm(struct sbscn_channel * ch)910 sbscn_to_tiocm(struct sbscn_channel *ch)
911 {
912 u_char hwbits;
913 int ttybits = 0;
914
915 hwbits = ch->ch_oports;
916 if (ISSET(hwbits, ch->ch_o_dtr))
917 SET(ttybits, TIOCM_DTR);
918 if (ISSET(hwbits, ch->ch_o_rts))
919 SET(ttybits, TIOCM_RTS);
920
921 hwbits = ch->ch_iports;
922 if (ISSET(hwbits, ch->ch_i_dcd))
923 SET(ttybits, TIOCM_CD);
924 if (ISSET(hwbits, ch->ch_i_cts))
925 SET(ttybits, TIOCM_CTS);
926 if (ISSET(hwbits, ch->ch_i_dsr))
927 SET(ttybits, TIOCM_DSR);
928 if (ISSET(hwbits, ch->ch_i_ri))
929 SET(ttybits, TIOCM_RI);
930
931 if (ch->ch_imr != 0)
932 SET(ttybits, TIOCM_LE);
933
934 return (ttybits);
935 }
936
937 static int
cflag2modes(tcflag_t cflag,u_char * mode1p,u_char * mode2p)938 cflag2modes(tcflag_t cflag, u_char *mode1p, u_char *mode2p)
939 {
940 u_char mode1;
941 u_char mode2;
942 int err = 0;
943
944 mode1 = mode2 = 0;
945
946 switch (ISSET(cflag, CSIZE)) {
947 case CS7:
948 mode1 |= 2; /* XXX */
949 break;
950 default:
951 err = -1;
952 /* FALLTHRU for sanity */
953 case CS8:
954 mode1 |= 3; /* XXX */
955 break;
956 }
957 if (!ISSET(cflag, PARENB))
958 mode1 |= 2 << 3;
959 else {
960 mode1 |= 0 << 3;
961 if (ISSET(cflag, PARODD))
962 mode1 |= 1 << 2;
963 }
964
965 if (ISSET(cflag, CSTOPB))
966 mode2 |= 1 << 3; /* two stop bits XXX not std */
967
968 if (ISSET(cflag, CRTSCTS)) {
969 mode1 |= 1 << 7;
970 mode2 |= 1 << 4;
971 }
972
973 *mode1p = mode1;
974 *mode2p = mode2;
975 return (err);
976 }
977
978 int
sbscn_param(struct tty * tp,struct termios * t)979 sbscn_param(struct tty *tp, struct termios *t)
980 {
981 struct sbscn_softc *sc = device_lookup_private(&sbscn_cd, SBSCN_UNIT(tp->t_dev));
982 struct sbscn_channel *ch = &sc->sc_channels[SBSCN_CHAN(tp->t_dev)];
983 long brc;
984 u_char mode1, mode2;
985 int s;
986
987 /* XXX reset to console parameters if console? */
988 #if 0
989 XXX disable, enable.
990 #endif
991
992 /* Check requested parameters. */
993 if (sbscn_speed(t->c_ospeed, &brc) < 0)
994 return (EINVAL);
995 if (t->c_ispeed && t->c_ispeed != t->c_ospeed)
996 return (EINVAL);
997
998 /*
999 * For the console, always force CLOCAL and !HUPCL, so that the port
1000 * is always active.
1001 */
1002 if (ISSET(ch->ch_swflags, TIOCFLAG_SOFTCAR) ||
1003 ISSET(ch->ch_hwflags, SBSCN_HW_CONSOLE)) {
1004 SET(t->c_cflag, CLOCAL);
1005 CLR(t->c_cflag, HUPCL);
1006 }
1007
1008 /*
1009 * If there were no changes, don't do anything. This avoids dropping
1010 * input and improves performance when all we did was frob things like
1011 * VMIN and VTIME.
1012 */
1013 if (tp->t_ospeed == t->c_ospeed &&
1014 tp->t_cflag == t->c_cflag)
1015 return (0);
1016
1017 if (cflag2modes(t->c_cflag, &mode1, &mode2) < 0)
1018 return (EINVAL);
1019
1020 s = splserial();
1021
1022 ch->ch_mode1 = mode1;
1023 ch->ch_mode2 = mode2;
1024
1025 /*
1026 * If we're not in a mode that assumes a connection is present, then
1027 * ignore carrier changes.
1028 */
1029 if (ISSET(t->c_cflag, CLOCAL | MDMBUF))
1030 ch->ch_i_dcd = 0;
1031 else
1032 ch->ch_i_dcd = ch->ch_i_dcd_pin;
1033 /*
1034 * Set the flow control pins depending on the current flow control
1035 * mode.
1036 */
1037 if (ISSET(t->c_cflag, CRTSCTS)) {
1038 ch->ch_o_dtr = ch->ch_o_dtr_pin;
1039 ch->ch_o_rts = ch->ch_o_rts_pin;
1040 ch->ch_i_cts = ch->ch_i_cts_pin;
1041 /* hw controle enable bits in mod regs set by cflag2modes */
1042 } else if (ISSET(t->c_cflag, MDMBUF)) {
1043 /*
1044 * For DTR/DCD flow control, make sure we don't toggle DTR for
1045 * carrier detection.
1046 */
1047 ch->ch_o_dtr = 0;
1048 ch->ch_o_rts = ch->ch_o_dtr_pin;
1049 ch->ch_i_cts = ch->ch_i_dcd_pin;
1050 } else {
1051 /*
1052 * If no flow control, then always set RTS. This will make
1053 * the other side happy if it mistakenly thinks we're doing
1054 * RTS/CTS flow control.
1055 */
1056 ch->ch_o_dtr = ch->ch_o_dtr_pin | ch->ch_o_rts_pin;
1057 ch->ch_o_rts = 0;
1058 ch->ch_i_cts = 0;
1059 if (ISSET(ch->ch_oports, ch->ch_o_dtr_pin))
1060 SET(ch->ch_oports, ch->ch_o_rts_pin);
1061 else
1062 CLR(ch->ch_oports, ch->ch_o_rts_pin);
1063 }
1064 /* XXX maybe mask the ports which generate intrs? */
1065
1066 ch->ch_brc = brc;
1067
1068 /* XXX maybe set fifo-full receive mode if RTSCTS and high speed? */
1069
1070 /* And copy to tty. */
1071 tp->t_ispeed = 0;
1072 tp->t_ospeed = t->c_ospeed;
1073 tp->t_cflag = t->c_cflag;
1074
1075 if (!ch->ch_heldchange) {
1076 if (ch->ch_tx_busy) {
1077 ch->ch_heldtbc = ch->ch_tbc;
1078 ch->ch_tbc = 0;
1079 ch->ch_heldchange = 1;
1080 } else
1081 sbscn_loadchannelregs(ch);
1082 }
1083
1084 if (!ISSET(t->c_cflag, CHWFLOW)) {
1085 /* Disable the high water mark. */
1086 ch->ch_r_hiwat = 0;
1087 ch->ch_r_lowat = 0;
1088 if (ISSET(ch->ch_rx_flags, RX_TTY_OVERFLOWED)) {
1089 CLR(ch->ch_rx_flags, RX_TTY_OVERFLOWED);
1090 sbscn_schedrx(ch);
1091 }
1092 if (ISSET(ch->ch_rx_flags, RX_TTY_BLOCKED|RX_IBUF_BLOCKED)) {
1093 CLR(ch->ch_rx_flags, RX_TTY_BLOCKED|RX_IBUF_BLOCKED);
1094 sbscn_dohwiflow(ch);
1095 }
1096 } else {
1097 ch->ch_r_hiwat = sbscn_rbuf_hiwat;
1098 ch->ch_r_lowat = sbscn_rbuf_lowat;
1099 }
1100
1101 splx(s);
1102
1103 /*
1104 * Update the tty layer's idea of the carrier bit, in case we changed
1105 * CLOCAL or MDMBUF. We don't hang up here; we only do that by
1106 * explicit request.
1107 */
1108 (void) (*tp->t_linesw->l_modem)(tp,
1109 ISSET(ch->ch_iports, ch->ch_i_dcd));
1110
1111 #ifdef SBSCN_DEBUG
1112 if (sbscn_debug)
1113 sbscn_status(ch, "sbscnparam ");
1114 #endif
1115
1116 if (!ISSET(t->c_cflag, CHWFLOW)) {
1117 if (ch->ch_tx_stopped) {
1118 ch->ch_tx_stopped = 0;
1119 sbscn_start(tp);
1120 }
1121 }
1122
1123 return (0);
1124 }
1125
1126 void
sbscn_iflush(struct sbscn_channel * ch)1127 sbscn_iflush(struct sbscn_channel *ch)
1128 {
1129 #ifdef DIAGNOSTIC
1130 int reg;
1131 #endif
1132 int timo;
1133
1134 #ifdef DIAGNOSTIC
1135 reg = 0xffff;
1136 #endif
1137 timo = 50000;
1138 /* flush any pending I/O */
1139 while (ISSET(READ_REG(ch->ch_base + 0x20), 0x01)
1140 && --timo)
1141 #ifdef DIAGNOSTIC
1142 reg =
1143 #else
1144 (void)
1145 #endif
1146 READ_REG(ch->ch_base + 0x60);
1147 #ifdef DIAGNOSTIC
1148 if (!timo)
1149 aprint_debug_dev(ch->ch_sc->sc_dev,
1150 "sbscn_iflush timeout %02x\n", reg & 0xff);
1151 #endif
1152 }
1153
1154 void
sbscn_loadchannelregs(struct sbscn_channel * ch)1155 sbscn_loadchannelregs(struct sbscn_channel *ch)
1156 {
1157
1158 /* XXXXX necessary? */
1159 sbscn_iflush(ch);
1160
1161 WRITE_REG(ch->ch_imr_base, 0);
1162
1163 // XXX disable?
1164 WRITE_REG(ch->ch_base + 0x00, ch->ch_mode1);
1165 WRITE_REG(ch->ch_base + 0x10, ch->ch_mode2);
1166 WRITE_REG(ch->ch_base + 0x30, ch->ch_brc);
1167
1168 ch->ch_oports_active = ch->ch_oports;
1169 SET_OUTPUT_SIGNALS(ch, ch->ch_oports_active);
1170
1171 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
1172 }
1173
1174 int
sbscn_hwiflow(struct tty * tp,int block)1175 sbscn_hwiflow(struct tty *tp, int block)
1176 {
1177 struct sbscn_softc *sc = device_lookup_private(&sbscn_cd, SBSCN_UNIT(tp->t_dev));
1178 struct sbscn_channel *ch = &sc->sc_channels[SBSCN_CHAN(tp->t_dev)];
1179 int s;
1180
1181 if (ch->ch_o_rts == 0)
1182 return (0);
1183
1184 s = splserial();
1185 if (block) {
1186 if (!ISSET(ch->ch_rx_flags, RX_TTY_BLOCKED)) {
1187 SET(ch->ch_rx_flags, RX_TTY_BLOCKED);
1188 sbscn_dohwiflow(ch);
1189 }
1190 } else {
1191 if (ISSET(ch->ch_rx_flags, RX_TTY_OVERFLOWED)) {
1192 CLR(ch->ch_rx_flags, RX_TTY_OVERFLOWED);
1193 sbscn_schedrx(ch);
1194 }
1195 if (ISSET(ch->ch_rx_flags, RX_TTY_BLOCKED)) {
1196 CLR(ch->ch_rx_flags, RX_TTY_BLOCKED);
1197 sbscn_dohwiflow(ch);
1198 }
1199 }
1200 splx(s);
1201 return (1);
1202 }
1203
1204 /*
1205 * (un)block input via hw flowcontrol
1206 */
1207 void
sbscn_dohwiflow(struct sbscn_channel * ch)1208 sbscn_dohwiflow(struct sbscn_channel *ch)
1209 {
1210
1211 if (ch->ch_o_rts == 0)
1212 return;
1213
1214 if (ISSET(ch->ch_rx_flags, RX_ANY_BLOCK)) {
1215 CLR(ch->ch_oports, ch->ch_o_rts);
1216 CLR(ch->ch_oports_active, ch->ch_o_rts);
1217 } else {
1218 SET(ch->ch_oports, ch->ch_o_rts);
1219 SET(ch->ch_oports_active, ch->ch_o_rts);
1220 }
1221 SET_OUTPUT_SIGNALS(ch, ch->ch_oports_active);
1222 }
1223
1224 void
sbscn_start(struct tty * tp)1225 sbscn_start(struct tty *tp)
1226 {
1227 struct sbscn_softc *sc = device_lookup_private(&sbscn_cd, SBSCN_UNIT(tp->t_dev));
1228 struct sbscn_channel *ch = &sc->sc_channels[SBSCN_CHAN(tp->t_dev)];
1229 int s;
1230
1231 s = spltty();
1232 if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP))
1233 goto out;
1234 if (ch->ch_tx_stopped)
1235 goto out;
1236 if (!ttypull(tp))
1237 goto out;
1238
1239 /* Grab the first contiguous region of buffer space. */
1240 {
1241 u_char *tba;
1242 int tbc;
1243
1244 tba = tp->t_outq.c_cf;
1245 tbc = ndqb(&tp->t_outq, 0);
1246
1247 (void)splserial();
1248
1249 ch->ch_tba = tba;
1250 ch->ch_tbc = tbc;
1251 }
1252
1253 SET(tp->t_state, TS_BUSY);
1254 ch->ch_tx_busy = 1;
1255
1256 /* Enable transmit completion interrupts if necessary. */
1257 if (!ISSET(ch->ch_imr, 0x1)) {
1258 SET(ch->ch_imr, 0x1);
1259 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
1260 }
1261
1262 /* Output the first chunk of the contiguous buffer. */
1263 {
1264 u_char c;
1265
1266 while (ch->ch_tbc && READ_REG(ch->ch_base + 0x20) & 0x04) {
1267 c = *ch->ch_tba++;
1268 ch->ch_tbc--;
1269 WRITE_REG(ch->ch_base + 0x70, c);
1270 }
1271 }
1272 out:
1273 splx(s);
1274 return;
1275 }
1276
1277 /*
1278 * Stop output on a line.
1279 */
1280 void
sbscnstop(struct tty * tp,int flag)1281 sbscnstop(struct tty *tp, int flag)
1282 {
1283 struct sbscn_softc *sc = device_lookup_private(&sbscn_cd, SBSCN_UNIT(tp->t_dev));
1284 struct sbscn_channel *ch = &sc->sc_channels[SBSCN_CHAN(tp->t_dev)];
1285 int s;
1286
1287 s = splserial();
1288 if (ISSET(tp->t_state, TS_BUSY)) {
1289 /* Stop transmitting at the next chunk. */
1290 ch->ch_tbc = 0;
1291 ch->ch_heldtbc = 0;
1292 if (!ISSET(tp->t_state, TS_TTSTOP))
1293 SET(tp->t_state, TS_FLUSH);
1294 }
1295 splx(s);
1296 }
1297
1298 void
sbscn_diag(void * arg)1299 sbscn_diag(void *arg)
1300 {
1301 struct sbscn_channel *ch = arg;
1302 struct sbscn_softc *sc = ch->ch_sc;
1303 int overflows, floods;
1304 int s;
1305
1306 s = splserial();
1307 overflows = ch->ch_overflows;
1308 ch->ch_overflows = 0;
1309 floods = ch->ch_floods;
1310 ch->ch_floods = 0;
1311 ch->ch_errors = 0;
1312 splx(s);
1313
1314 log(LOG_WARNING, "%s: channel %d: %d fifo overflow%s, %d ibuf flood%s\n",
1315 device_xname(sc->sc_dev), ch->ch_num,
1316 overflows, overflows == 1 ? "" : "s",
1317 floods, floods == 1 ? "" : "s");
1318 }
1319
1320 integrate void
sbscn_rxsoft(struct sbscn_channel * ch,struct tty * tp)1321 sbscn_rxsoft(struct sbscn_channel *ch, struct tty *tp)
1322 {
1323 int (*rint)(int, struct tty *) = tp->t_linesw->l_rint;
1324 u_char *get, *end;
1325 u_int cc, scc;
1326 u_char sr;
1327 int code;
1328 int s;
1329
1330 end = ch->ch_ebuf;
1331 get = ch->ch_rbget;
1332 scc = cc = sbscn_rbuf_size - ch->ch_rbavail;
1333
1334 if (cc == sbscn_rbuf_size) {
1335 ch->ch_floods++;
1336 if (ch->ch_errors++ == 0)
1337 callout_reset(&ch->ch_diag_callout, 60 * hz,
1338 sbscn_diag, ch);
1339 }
1340
1341 while (cc) {
1342 code = get[0];
1343 sr = get[1];
1344 if (ISSET(sr, 0xf0)) {
1345 if (ISSET(sr, 0x10)) {
1346 ch->ch_overflows++;
1347 if (ch->ch_errors++ == 0)
1348 callout_reset(&ch->ch_diag_callout,
1349 60 * hz, sbscn_diag, ch);
1350 }
1351 if (ISSET(sr, 0xc0))
1352 SET(code, TTY_FE);
1353 if (ISSET(sr, 0x20))
1354 SET(code, TTY_PE);
1355 }
1356 if ((*rint)(code, tp) == -1) {
1357 /*
1358 * The line discipline's buffer is out of space.
1359 */
1360 if (!ISSET(ch->ch_rx_flags, RX_TTY_BLOCKED)) {
1361 /*
1362 * We're either not using flow control, or the
1363 * line discipline didn't tell us to block for
1364 * some reason. Either way, we have no way to
1365 * know when there's more space available, so
1366 * just drop the rest of the data.
1367 */
1368 get += cc << 1;
1369 if (get >= end)
1370 get -= sbscn_rbuf_size << 1;
1371 cc = 0;
1372 } else {
1373 /*
1374 * Don't schedule any more receive processing
1375 * until the line discipline tells us there's
1376 * space available (through comhwiflow()).
1377 * Leave the rest of the data in the input
1378 * buffer.
1379 */
1380 SET(ch->ch_rx_flags, RX_TTY_OVERFLOWED);
1381 }
1382 break;
1383 }
1384 get += 2;
1385 if (get >= end)
1386 get = ch->ch_rbuf;
1387 cc--;
1388 }
1389
1390 if (cc != scc) {
1391 ch->ch_rbget = get;
1392 s = splserial();
1393 cc = ch->ch_rbavail += scc - cc;
1394 /* Buffers should be ok again, release possible block. */
1395 if (cc >= ch->ch_r_lowat) {
1396 if (ISSET(ch->ch_rx_flags, RX_IBUF_OVERFLOWED)) {
1397 CLR(ch->ch_rx_flags, RX_IBUF_OVERFLOWED);
1398 SET(ch->ch_imr, 0x02);
1399 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
1400 }
1401 if (ISSET(ch->ch_rx_flags, RX_IBUF_BLOCKED)) {
1402 CLR(ch->ch_rx_flags, RX_IBUF_BLOCKED);
1403 sbscn_dohwiflow(ch);
1404 }
1405 }
1406 splx(s);
1407 }
1408 }
1409
1410 integrate void
sbscn_txsoft(struct sbscn_channel * ch,struct tty * tp)1411 sbscn_txsoft(struct sbscn_channel *ch, struct tty *tp)
1412 {
1413
1414 CLR(tp->t_state, TS_BUSY);
1415 if (ISSET(tp->t_state, TS_FLUSH))
1416 CLR(tp->t_state, TS_FLUSH);
1417 else
1418 ndflush(&tp->t_outq, (int)(ch->ch_tba - tp->t_outq.c_cf));
1419 (*tp->t_linesw->l_start)(tp);
1420 }
1421
1422 integrate void
sbscn_stsoft(struct sbscn_channel * ch,struct tty * tp)1423 sbscn_stsoft(struct sbscn_channel *ch, struct tty *tp)
1424 {
1425 u_char iports, delta;
1426 int s;
1427
1428 s = splserial();
1429 iports = ch->ch_iports;
1430 delta = ch->ch_iports_delta;
1431 ch->ch_iports_delta = 0;
1432 splx(s);
1433
1434 if (ISSET(delta, ch->ch_i_dcd)) {
1435 /*
1436 * Inform the tty layer that carrier detect changed.
1437 */
1438 (void) (*tp->t_linesw->l_modem)(tp,
1439 ISSET(iports, ch->ch_i_dcd));
1440 }
1441
1442 if (ISSET(delta, ch->ch_i_cts)) {
1443 /* Block or unblock output according to flow control. */
1444 if (ISSET(iports, ch->ch_i_cts)) {
1445 ch->ch_tx_stopped = 0;
1446 (*tp->t_linesw->l_start)(tp);
1447 } else {
1448 ch->ch_tx_stopped = 1;
1449 }
1450 }
1451
1452 #ifdef SBSCN_DEBUG
1453 if (sbscn_debug)
1454 sbscn_status(ch, "sbscn_stsoft");
1455 #endif
1456 }
1457
1458 void
sbscn_soft(void * arg)1459 sbscn_soft(void *arg)
1460 {
1461 struct sbscn_channel *ch = arg;
1462 struct tty *tp = ch->ch_tty;
1463
1464 if (ch->ch_rx_ready) {
1465 ch->ch_rx_ready = 0;
1466 sbscn_rxsoft(ch, tp);
1467 }
1468
1469 if (ch->ch_st_check) {
1470 ch->ch_st_check = 0;
1471 sbscn_stsoft(ch, tp);
1472 }
1473
1474 if (ch->ch_tx_done) {
1475 ch->ch_tx_done = 0;
1476 sbscn_txsoft(ch, tp);
1477 }
1478 }
1479
1480 void
sbscn_intr(void * arg,uint32_t status,vaddr_t pc)1481 sbscn_intr(void *arg, uint32_t status, vaddr_t pc)
1482 {
1483 struct sbscn_channel *ch = arg;
1484 u_char *put, *end;
1485 u_int cc;
1486 u_char isr, sr;
1487
1488 /* read ISR */
1489 isr = READ_REG(ch->ch_isr_base) & ch->ch_imr;
1490 if (isr == 0)
1491 return;
1492
1493 end = ch->ch_ebuf;
1494 put = ch->ch_rbput;
1495 cc = ch->ch_rbavail;
1496
1497 do {
1498 u_char iports, delta;
1499
1500 if (isr & 0x02) {
1501
1502 sr = READ_REG(ch->ch_base + 0x20);
1503 /* XXX sr 0x01 bit must be set at this point */
1504
1505 #if defined(DDB) || defined(KGDB)
1506 if ((sr & 0x80) == 0x80) {
1507 #ifdef DDB
1508 if (ISSET(ch->ch_hwflags, SBSCN_HW_CONSOLE)) {
1509 (void)READ_REG(ch->ch_base + 0x60);
1510 console_debugger();
1511 continue;
1512 }
1513 #endif
1514 #ifdef KGDB
1515 if (ISSET(ch->ch_hwflags, SBSCN_HW_KGDB)) {
1516 (void)READ_REG(ch->ch_base + 0x60);
1517 kgdb_connect(1);
1518 continue;
1519 }
1520 #endif
1521 }
1522 #endif /* DDB || KGDB */
1523
1524 if (!ISSET(ch->ch_rx_flags, RX_IBUF_OVERFLOWED)) {
1525 while (cc > 0) {
1526 put[0] = READ_REG(ch->ch_base + 0x60);
1527 put[1] = sr;
1528 put += 2;
1529 if (put >= end)
1530 put = ch->ch_rbuf;
1531 cc--;
1532
1533 sr = READ_REG(ch->ch_base + 0x20);
1534 if (!ISSET(sr, 0x02))
1535 break;
1536 }
1537
1538 /*
1539 * Current string of incoming characters ended
1540 * because no more data was available or we
1541 * ran out of space. Schedule a receive event
1542 * if any data was received. If we're out of
1543 * space, turn off receive interrupts.
1544 */
1545 ch->ch_rbput = put;
1546 ch->ch_rbavail = cc;
1547 if (!ISSET(ch->ch_rx_flags, RX_TTY_OVERFLOWED))
1548 ch->ch_rx_ready = 1;
1549
1550 /*
1551 * See if we are in danger of overflowing a
1552 * buffer. If so, use hardware flow control
1553 * to ease the pressure.
1554 */
1555 if (!ISSET(ch->ch_rx_flags, RX_IBUF_BLOCKED) &&
1556 cc < ch->ch_r_hiwat) {
1557 SET(ch->ch_rx_flags, RX_IBUF_BLOCKED);
1558 sbscn_dohwiflow(ch);
1559 }
1560
1561 /*
1562 * If we're out of space, disable receive
1563 * interrupts until the queue has drained
1564 * a bit.
1565 */
1566 if (!cc) {
1567 SET(ch->ch_rx_flags,
1568 RX_IBUF_OVERFLOWED);
1569 CLR(ch->ch_imr, 0x02);
1570 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
1571 }
1572 } else {
1573 /* XXX panic? */
1574 CLR(ch->ch_imr, 0x02);
1575 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
1576 continue;
1577 }
1578 }
1579
1580 if (isr & 0x01) {
1581 CLR(ch->ch_imr, 0x01);
1582 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
1583 }
1584
1585 #if 0
1586 XXX
1587 if (isr & 0x08) {
1588 clear input signal change!
1589 }
1590 #endif
1591 iports = GET_INPUT_SIGNALS(ch);
1592 delta = iports ^ ch->ch_iports;
1593 ch->ch_iports = iports;
1594
1595 /*
1596 * Process normal status changes
1597 */
1598 if (ISSET(delta, ch->ch_i_mask)) {
1599 SET(ch->ch_iports_delta, delta);
1600
1601 /*
1602 * Stop output immediately if we lose the output
1603 * flow control signal or carrier detect.
1604 */
1605 if (ISSET(~iports, ch->ch_i_mask)) {
1606 ch->ch_tbc = 0;
1607 ch->ch_heldtbc = 0;
1608 #ifdef SBSCN_DEBUG
1609 if (sbscn_debug)
1610 sbscn_status(ch, "sbscn_intr ");
1611 #endif
1612 }
1613
1614 ch->ch_st_check = 1;
1615 }
1616 } while ((isr = (READ_REG(ch->ch_isr_base) & ch->ch_imr)) != 0);
1617
1618 /*
1619 * Done handling any receive interrupts and status changes, and
1620 * clearing the tx-ready interrupt if it was set. See if data can
1621 * be transmitted as well. Schedule tx done event if no data left
1622 * and tty was marked busy.
1623 */
1624 sr = READ_REG(ch->ch_base + 0x20);
1625 if (ISSET(sr, 0x4)) {
1626
1627 /*
1628 * If we've delayed a parameter change, do it now, and restart
1629 * output.
1630 */
1631 if (ch->ch_heldchange) {
1632 sbscn_loadchannelregs(ch);
1633 ch->ch_heldchange = 0;
1634 ch->ch_tbc = ch->ch_heldtbc;
1635 ch->ch_heldtbc = 0;
1636 }
1637
1638 /* Output the next chunk of the contiguous buffer, if any. */
1639 if (ch->ch_tbc > 0) {
1640 int wrote1;
1641 u_char c;
1642
1643 wrote1 = 0;
1644 while (ch->ch_tbc &&
1645 READ_REG(ch->ch_base + 0x20) & 0x04) {
1646 wrote1 = 1;
1647 c = *ch->ch_tba++;
1648 ch->ch_tbc--;
1649 WRITE_REG(ch->ch_base + 0x70, c);
1650 }
1651 if (wrote1) {
1652 SET(ch->ch_imr, 0x01);
1653 WRITE_REG(ch->ch_imr_base, ch->ch_imr);
1654 }
1655 } else {
1656 /*
1657 * transmit completion interrupts already disabled,
1658 * mark the channel tx state as done.
1659 */
1660 if (ch->ch_tx_busy) {
1661 ch->ch_tx_busy = 0;
1662 ch->ch_tx_done = 1;
1663 }
1664 }
1665 }
1666
1667 /* Wake up the poller. */
1668 softint_schedule(ch->ch_si);
1669
1670 #ifdef RND_SBSCN
1671 rnd_add_uint32(&ch->ch_rnd_source, isr | sr);
1672 #endif
1673 }
1674
1675 /*
1676 * The following functions are polled getc and putc routines, shared
1677 * by the console and kgdb glue.
1678 */
1679
1680 int
sbscn_common_getc(u_long addr,int chan)1681 sbscn_common_getc(u_long addr, int chan)
1682 {
1683 int s = splhigh();
1684 u_long base = MIPS_PHYS_TO_KSEG1(addr + (chan * 0x100));
1685 int c;
1686
1687 /* block until a character becomes available */
1688 while ((READ_REG(base + 0x20) & 0x01) == 0)
1689 continue;
1690
1691 c = READ_REG(base + 0x60) & 0xff;
1692 splx(s);
1693 return (c);
1694 }
1695
1696 void
sbscn_common_putc(u_long addr,int chan,int c)1697 sbscn_common_putc(u_long addr, int chan, int c)
1698 {
1699 int s = splhigh();
1700 int timo;
1701 u_long base = MIPS_PHYS_TO_KSEG1(addr + (chan * 0x100));
1702
1703 /* wait for any pending transmission to finish */
1704 timo = 1500000;
1705 while ((READ_REG(base + 0x20) & 0x08) == 0 && --timo)
1706 continue;
1707
1708 WRITE_REG(base + 0x70, c);
1709
1710 /* wait for this transmission to complete */
1711 timo = 15000000;
1712 while ((READ_REG(base + 0x20) & 0x08) == 0 && --timo)
1713 continue;
1714
1715 splx(s);
1716 }
1717
1718 /*
1719 * Initialize UART for use as console or KGDB line.
1720 */
1721 int
sbscn_init(u_long addr,int chan,int rate,tcflag_t cflag)1722 sbscn_init(u_long addr, int chan, int rate, tcflag_t cflag)
1723 {
1724 #if 1
1725 u_long chanregbase = MIPS_PHYS_TO_KSEG1(addr + (chan * 0x100));
1726 u_long imaskreg = MIPS_PHYS_TO_KSEG1(addr + 0x230 + (chan * 0x20));
1727 u_char mode1, mode2;
1728 u_long brc;
1729 volatile int timo;
1730
1731 WRITE_REG(imaskreg, 0); /* disable channel intrs */
1732
1733 /* XXX should we really do the following? how about only if enabled? */
1734 /* wait for any pending transmission to finish */
1735 timo = 1500000;
1736 while ((READ_REG(chanregbase + 0x20) & 0x08) == 0 && --timo)
1737 continue;
1738
1739 /* XXX: wait a little. THIS SHOULD NOT BE NECESSARY!!! (?) */
1740 timo = 1500000;
1741 while (--timo)
1742 ;
1743
1744 WRITE_REG(chanregbase + 0x50, 2 << 4); /* reset receiver */
1745 WRITE_REG(chanregbase + 0x50, 3 << 4); /* reset transmitter */
1746
1747 /* set up the line for use */
1748 (void)cflag2modes(cflag, &mode1, &mode2);
1749 (void)sbscn_speed(rate, &brc);
1750 WRITE_REG(chanregbase + 0x00, mode1);
1751 WRITE_REG(chanregbase + 0x10, mode2);
1752 WRITE_REG(chanregbase + 0x30, brc);
1753
1754 /* enable transmit and receive */
1755 #define M_DUART_RX_EN 0x01
1756 #define M_DUART_TX_EN 0x04
1757 WRITE_REG(chanregbase + 0x50,M_DUART_RX_EN | M_DUART_TX_EN);
1758 #endif
1759
1760 /* XXX: wait a little. THIS SHOULD NOT BE NECESSARY!!! (?) */
1761 timo = 1500000;
1762 while (--timo)
1763 ;
1764
1765 #if 0 /* XXXCGD */
1766 bus_space_handle_t ioh;
1767
1768 if (bus_space_map(iot, iobase, COM_NPORTS, 0, &ioh))
1769 return (ENOMEM); /* ??? */
1770
1771 bus_space_write_1(iot, ioh, com_lcr, LCR_EERS);
1772 bus_space_write_1(iot, ioh, com_efr, 0);
1773 bus_space_write_1(iot, ioh, com_lcr, LCR_DLAB);
1774 rate = comspeed(rate, frequency);
1775 bus_space_write_1(iot, ioh, com_dlbl, rate);
1776 bus_space_write_1(iot, ioh, com_dlbh, rate >> 8);
1777 bus_space_write_1(iot, ioh, com_lcr, cflag2lcr(cflag));
1778 bus_space_write_1(iot, ioh, com_mcr, MCR_DTR | MCR_RTS);
1779 bus_space_write_1(iot, ioh, com_fifo,
1780 FIFO_ENABLE | FIFO_RCV_RST | FIFO_XMT_RST | FIFO_TRIGGER_1);
1781 bus_space_write_1(iot, ioh, com_ier, 0);
1782
1783 *iohp = ioh;
1784 return (0);
1785 #endif /* XXXCGD */
1786 /* XXXCGD */
1787 return (0);
1788 }
1789
1790 /*
1791 * Following are all routines needed for sbscn to act as console
1792 */
1793 int
sbscn_cnattach(u_long addr,int chan,int rate,tcflag_t cflag)1794 sbscn_cnattach(u_long addr, int chan, int rate, tcflag_t cflag)
1795 {
1796 int res;
1797 static struct consdev sbscn_cons = {
1798 NULL, NULL, sbscn_cngetc, sbscn_cnputc, sbscn_cnpollc, NULL,
1799 NULL, NULL, NODEV, CN_NORMAL
1800 };
1801
1802 res = sbscn_init(addr, chan, rate, cflag);
1803 if (res)
1804 return (res);
1805
1806 cn_tab = &sbscn_cons;
1807
1808 sbscn_cons_present = 1;
1809 sbscn_cons_addr = addr;
1810 sbscn_cons_chan = chan;
1811 sbscn_cons_rate = rate;
1812 sbscn_cons_cflag = cflag;
1813
1814 return (0);
1815 }
1816
1817 int
sbscn_cngetc(dev_t dev)1818 sbscn_cngetc(dev_t dev)
1819 {
1820
1821 return (sbscn_common_getc(sbscn_cons_addr, sbscn_cons_chan));
1822 }
1823
1824 /*
1825 * Console kernel output character routine.
1826 */
1827 void
sbscn_cnputc(dev_t dev,int c)1828 sbscn_cnputc(dev_t dev, int c)
1829 {
1830
1831 sbscn_common_putc(sbscn_cons_addr, sbscn_cons_chan, c);
1832 }
1833
1834 void
sbscn_cnpollc(dev_t dev,int on)1835 sbscn_cnpollc(dev_t dev, int on)
1836 {
1837
1838 }
1839
1840 #ifdef KGDB
1841 int
sbscn_kgdb_attach(u_long addr,int chan,int rate,tcflag_t cflag)1842 sbscn_kgdb_attach(u_long addr, int chan, int rate, tcflag_t cflag)
1843 {
1844 int res;
1845
1846 if (!sbscn_cons_present &&
1847 sbscn_cons_addr == addr && sbscn_cons_chan == chan)
1848 return (EBUSY); /* cannot share with console */
1849
1850 res = sbscn_init(addr, chan, rate, cflag);
1851 if (res)
1852 return (res);
1853
1854 kgdb_attach(sbscn_kgdb_getc, sbscn_kgdb_putc, NULL);
1855 kgdb_dev = 123; /* unneeded, only to satisfy some tests */
1856
1857 sbscn_kgdb_present = 1;
1858 sbscn_kgdb_addr = addr;
1859 sbscn_kgdb_chan = chan;
1860
1861 return (0);
1862 }
1863
1864 /* ARGSUSED */
1865 int
sbscn_kgdb_getc(void * arg)1866 sbscn_kgdb_getc(void *arg)
1867 {
1868
1869 return (sbscn_common_getc(sbscn_kgdb_addr, sbscn_kgdb_chan));
1870 }
1871
1872 /* ARGSUSED */
1873 void
sbscn_kgdb_putc(void * arg,int c)1874 sbscn_kgdb_putc(void *arg, int c)
1875 {
1876
1877 sbscn_common_getc(sbscn_kgdb_addr, sbscn_kgdb_chan, c);
1878 }
1879 #endif /* KGDB */
1880
1881 /*
1882 * helper function to identify the sbscn channels used by
1883 * console or KGDB (and not yet autoconf attached)
1884 */
1885 int
sbscn_is_console(u_long addr,int chan)1886 sbscn_is_console(u_long addr, int chan)
1887 {
1888
1889 if (sbscn_cons_present && !sbscn_cons_attached &&
1890 sbscn_cons_addr == addr && sbscn_cons_chan == chan)
1891 return (1);
1892 #ifdef KGDB
1893 if (sbscn_kgdb_present && !sbscn_kgdb_attached &&
1894 sbscn_kgdb_addr == addr && sbscn_kgdb_chan == chan)
1895 return (1);
1896 #endif
1897 return (0);
1898 }
1899