Annotation of sys/arch/luna88k/dev/siotty.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: siotty.c,v 1.5 2007/02/14 01:12:16 jsg Exp $ */
! 2: /* $NetBSD: siotty.c,v 1.9 2002/03/17 19:40:43 atatat Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 2000 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by Tohru Nishimura.
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. All advertising materials mentioning features or use of this software
! 20: * must display the following acknowledgement:
! 21: * This product includes software developed by the NetBSD
! 22: * Foundation, Inc. and its contributors.
! 23: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 24: * contributors may be used to endorse or promote products derived
! 25: * from this software without specific prior written permission.
! 26: *
! 27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 37: * POSSIBILITY OF SUCH DAMAGE.
! 38: */
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/systm.h>
! 42: #include <sys/device.h>
! 43: #include <sys/conf.h>
! 44: #include <sys/ioctl.h>
! 45: #include <sys/proc.h>
! 46: #include <sys/user.h>
! 47: #include <sys/tty.h>
! 48: #include <sys/uio.h>
! 49: #include <sys/fcntl.h>
! 50: #include <dev/cons.h>
! 51:
! 52: #include <machine/cpu.h>
! 53:
! 54: #include <luna88k/dev/sioreg.h>
! 55: #include <luna88k/dev/siovar.h>
! 56:
! 57: #define TIOCM_BREAK 01000 /* non standard use */
! 58:
! 59: static const u_int8_t ch0_regs[6] = {
! 60: WR0_RSTINT, /* reset E/S interrupt */
! 61: WR1_RXALLS | WR1_TXENBL, /* Rx per char, Tx */
! 62: 0, /* */
! 63: WR3_RX8BIT | WR3_RXENBL, /* Rx */
! 64: WR4_BAUD96 | WR4_STOP1, /* Tx/Rx */
! 65: WR5_TX8BIT | WR5_TXENBL | WR5_DTR | WR5_RTS, /* Tx */
! 66: };
! 67:
! 68: static const struct speedtab siospeedtab[] = {
! 69: { 2400, WR4_BAUD24, },
! 70: { 4800, WR4_BAUD48, },
! 71: { 9600, WR4_BAUD96, },
! 72: { -1, 0, },
! 73: };
! 74:
! 75: struct siotty_softc {
! 76: struct device sc_dev;
! 77: struct tty *sc_tty;
! 78: struct sioreg *sc_ctl;
! 79: u_int sc_flags;
! 80: u_int8_t sc_wr[6];
! 81: };
! 82:
! 83: cdev_decl(sio);
! 84: void siostart(struct tty *);
! 85: int sioparam(struct tty *, struct termios *);
! 86: void siottyintr(int);
! 87: int siomctl(struct siotty_softc *, int, int);
! 88:
! 89: int siotty_match(struct device *, void *, void *);
! 90: void siotty_attach(struct device *, struct device *, void *);
! 91:
! 92: const struct cfattach siotty_ca = {
! 93: sizeof(struct siotty_softc), siotty_match, siotty_attach
! 94: };
! 95:
! 96: struct cfdriver siotty_cd = {
! 97: NULL, "siotty", DV_TTY
! 98: };
! 99:
! 100: int
! 101: siotty_match(parent, cf, aux)
! 102: struct device *parent;
! 103: void *cf, *aux;
! 104: {
! 105: struct sio_attach_args *args = aux;
! 106:
! 107: if (args->channel != 0) /* XXX allow tty on Ch.B XXX */
! 108: return 0;
! 109: return 1;
! 110: }
! 111:
! 112: void
! 113: siotty_attach(parent, self, aux)
! 114: struct device *parent, *self;
! 115: void *aux;
! 116: {
! 117: struct sio_softc *scp = (void *)parent;
! 118: struct siotty_softc *sc = (void *)self;
! 119: struct sio_attach_args *args = aux;
! 120:
! 121: sc->sc_ctl = (struct sioreg *)scp->scp_ctl + args->channel;
! 122: bcopy(ch0_regs, sc->sc_wr, sizeof(ch0_regs));
! 123: scp->scp_intr[args->channel] = siottyintr;
! 124:
! 125: if (args->hwflags == 1) {
! 126: printf(" (console)");
! 127: sc->sc_flags = TIOCFLAG_SOFTCAR;
! 128: }
! 129: else {
! 130: setsioreg(sc->sc_ctl, WR0, WR0_CHANRST);
! 131: setsioreg(sc->sc_ctl, WR2A, WR2_VEC86 | WR2_INTR_1);
! 132: setsioreg(sc->sc_ctl, WR2B, 0);
! 133: setsioreg(sc->sc_ctl, WR0, sc->sc_wr[WR0]);
! 134: setsioreg(sc->sc_ctl, WR4, sc->sc_wr[WR4]);
! 135: setsioreg(sc->sc_ctl, WR3, sc->sc_wr[WR3]);
! 136: setsioreg(sc->sc_ctl, WR5, sc->sc_wr[WR5]);
! 137: setsioreg(sc->sc_ctl, WR0, sc->sc_wr[WR0]);
! 138: }
! 139: setsioreg(sc->sc_ctl, WR1, sc->sc_wr[WR1]); /* now interrupt driven */
! 140:
! 141: printf("\n");
! 142: }
! 143:
! 144: /*-------------------- low level routine --------------------*/
! 145:
! 146: void
! 147: siottyintr(chan)
! 148: int chan;
! 149: {
! 150: struct siotty_softc *sc;
! 151: struct sioreg *sio;
! 152: struct tty *tp;
! 153: unsigned int code;
! 154: int rr;
! 155:
! 156: if (chan >= siotty_cd.cd_ndevs)
! 157: return;
! 158: sc = siotty_cd.cd_devs[chan];
! 159: tp = sc->sc_tty;
! 160: sio = sc->sc_ctl;
! 161: rr = getsiocsr(sio);
! 162: if (rr & RR_RXRDY) {
! 163: do {
! 164: code = sio->sio_data;
! 165: if (rr & (RR_FRAMING | RR_OVERRUN | RR_PARITY)) {
! 166: sio->sio_cmd = WR0_ERRRST;
! 167: if (sio->sio_stat & RR_FRAMING)
! 168: code |= TTY_FE;
! 169: else if (sio->sio_stat & RR_PARITY)
! 170: code |= TTY_PE;
! 171: }
! 172: if (tp == NULL || (tp->t_state & TS_ISOPEN) == 0)
! 173: continue;
! 174: #if 0 && defined(DDB) /* ?!?! fails to resume ?!?! */
! 175: if ((rr & RR_BREAK) && tp->t_dev == cn_tab->cn_dev) {
! 176: if (db_console)
! 177: Debugger();
! 178: return;
! 179: }
! 180: #endif
! 181: /*
! 182: (*tp->t_linesw->l_rint)(code, tp);
! 183: */
! 184: (*linesw[tp->t_line].l_rint)(code, tp);
! 185: } while ((rr = getsiocsr(sio)) & RR_RXRDY);
! 186: }
! 187: if (rr & RR_TXRDY) {
! 188: sio->sio_cmd = WR0_RSTPEND;
! 189: if (tp != NULL) {
! 190: tp->t_state &= ~(TS_BUSY|TS_FLUSH);
! 191: /*
! 192: (*tp->t_linesw->l_start)(tp);
! 193: */
! 194: (*linesw[tp->t_line].l_start)(tp);
! 195: }
! 196: }
! 197: }
! 198:
! 199: void
! 200: siostart(tp)
! 201: struct tty *tp;
! 202: {
! 203: struct siotty_softc *sc = siotty_cd.cd_devs[minor(tp->t_dev)];
! 204: int s, c;
! 205:
! 206: s = spltty();
! 207: if (tp->t_state & (TS_BUSY|TS_TIMEOUT|TS_TTSTOP))
! 208: goto out;
! 209: if (tp->t_outq.c_cc <= tp->t_lowat) {
! 210: if (tp->t_state & TS_ASLEEP) {
! 211: tp->t_state &= ~TS_ASLEEP;
! 212: wakeup((caddr_t)&tp->t_outq);
! 213: }
! 214: selwakeup(&tp->t_wsel);
! 215: }
! 216: if (tp->t_outq.c_cc == 0)
! 217: goto out;
! 218:
! 219: tp->t_state |= TS_BUSY;
! 220: while (getsiocsr(sc->sc_ctl) & RR_TXRDY) {
! 221: if ((c = getc(&tp->t_outq)) == -1)
! 222: break;
! 223: sc->sc_ctl->sio_data = c;
! 224: }
! 225: out:
! 226: splx(s);
! 227: }
! 228:
! 229: int
! 230: siostop(tp, flag)
! 231: struct tty *tp;
! 232: int flag;
! 233: {
! 234: int s;
! 235:
! 236: s = spltty();
! 237: if (TS_BUSY == (tp->t_state & (TS_BUSY|TS_TTSTOP))) {
! 238: /*
! 239: * Device is transmitting; must stop it.
! 240: */
! 241: tp->t_state |= TS_FLUSH;
! 242: }
! 243: splx(s);
! 244: return (0);
! 245: }
! 246:
! 247: int
! 248: sioparam(tp, t)
! 249: struct tty *tp;
! 250: struct termios *t;
! 251: {
! 252: struct siotty_softc *sc = siotty_cd.cd_devs[minor(tp->t_dev)];
! 253: int wr4, s;
! 254:
! 255: if (t->c_ispeed && t->c_ispeed != t->c_ospeed)
! 256: return EINVAL;
! 257: wr4 = ttspeedtab(t->c_ospeed, siospeedtab);
! 258: if (wr4 < 0)
! 259: return EINVAL;
! 260:
! 261: if (sc->sc_flags & TIOCFLAG_SOFTCAR) {
! 262: t->c_cflag |= CLOCAL;
! 263: t->c_cflag &= ~HUPCL;
! 264: }
! 265: if (sc->sc_flags & TIOCFLAG_CLOCAL)
! 266: t->c_cflag |= CLOCAL;
! 267:
! 268: /*
! 269: * If there were no changes, don't do anything. This avoids dropping
! 270: * input and improves performance when all we did was frob things like
! 271: * VMIN and VTIME.
! 272: */
! 273: if (tp->t_ospeed == t->c_ospeed && tp->t_cflag == t->c_cflag)
! 274: return 0;
! 275:
! 276: tp->t_ispeed = t->c_ispeed;
! 277: tp->t_ospeed = t->c_ospeed;
! 278: tp->t_cflag = t->c_cflag;
! 279:
! 280: sc->sc_wr[WR3] &= 0x3f;
! 281: sc->sc_wr[WR5] &= 0x9f;
! 282: switch (tp->t_cflag & CSIZE) {
! 283: case CS7:
! 284: sc->sc_wr[WR3] |= WR3_RX7BIT; sc->sc_wr[WR5] |= WR5_TX7BIT;
! 285: break;
! 286: case CS8:
! 287: sc->sc_wr[WR3] |= WR3_RX8BIT; sc->sc_wr[WR5] |= WR5_TX8BIT;
! 288: break;
! 289: }
! 290: if (tp->t_cflag & PARENB) {
! 291: wr4 |= WR4_PARENAB;
! 292: if ((tp->t_cflag & PARODD) == 0)
! 293: wr4 |= WR4_EPARITY;
! 294: }
! 295: wr4 |= (tp->t_cflag & CSTOPB) ? WR4_STOP2 : WR4_STOP1;
! 296: sc->sc_wr[WR4] = wr4;
! 297:
! 298: s = spltty();
! 299: setsioreg(sc->sc_ctl, WR4, sc->sc_wr[WR4]);
! 300: setsioreg(sc->sc_ctl, WR3, sc->sc_wr[WR3]);
! 301: setsioreg(sc->sc_ctl, WR5, sc->sc_wr[WR5]);
! 302: splx(s);
! 303:
! 304: return 0;
! 305: }
! 306:
! 307: int
! 308: siomctl(sc, control, op)
! 309: struct siotty_softc *sc;
! 310: int control, op;
! 311: {
! 312: int val, s, wr5, rr;
! 313:
! 314: val = 0;
! 315: if (control & TIOCM_BREAK)
! 316: val |= WR5_BREAK;
! 317: if (control & TIOCM_DTR)
! 318: val |= WR5_DTR;
! 319: if (control & TIOCM_RTS)
! 320: val |= WR5_RTS;
! 321: s = spltty();
! 322: wr5 = sc->sc_wr[WR5];
! 323: switch (op) {
! 324: case DMSET:
! 325: wr5 &= ~(WR5_BREAK|WR5_DTR|WR5_RTS);
! 326: /* FALLTHROUGH */
! 327: case DMBIS:
! 328: wr5 |= val;
! 329: break;
! 330: case DMBIC:
! 331: wr5 &= ~val;
! 332: break;
! 333: case DMGET:
! 334: val = 0;
! 335: rr = getsiocsr(sc->sc_ctl);
! 336: if (wr5 & WR5_DTR)
! 337: val |= TIOCM_DTR;
! 338: if (wr5 & WR5_RTS)
! 339: val |= TIOCM_RTS;
! 340: if (rr & RR_CTS)
! 341: val |= TIOCM_CTS;
! 342: if (rr & RR_DCD)
! 343: val |= TIOCM_CD;
! 344: goto done;
! 345: }
! 346: sc->sc_wr[WR5] = wr5;
! 347: setsioreg(sc->sc_ctl, WR5, wr5);
! 348: val = 0;
! 349: done:
! 350: splx(s);
! 351: return val;
! 352: }
! 353:
! 354: /*-------------------- cdevsw[] interface --------------------*/
! 355:
! 356: int
! 357: sioopen(dev, flag, mode, p)
! 358: dev_t dev;
! 359: int flag, mode;
! 360: struct proc *p;
! 361: {
! 362: struct siotty_softc *sc;
! 363: struct tty *tp;
! 364: int error;
! 365:
! 366: if ((sc = siotty_cd.cd_devs[minor(dev)]) == NULL)
! 367: return ENXIO;
! 368: if ((tp = sc->sc_tty) == NULL) {
! 369: tp = sc->sc_tty = ttymalloc();
! 370: }
! 371: else if ((tp->t_state & TS_ISOPEN) && (tp->t_state & TS_XCLUDE)
! 372: && p->p_ucred->cr_uid != 0)
! 373: return EBUSY;
! 374:
! 375: tp->t_oproc = siostart;
! 376: tp->t_param = sioparam;
! 377: tp->t_hwiflow = NULL /* XXX siohwiflow XXX */;
! 378: tp->t_dev = dev;
! 379: if ((tp->t_state & TS_ISOPEN) == 0) {
! 380: struct termios t;
! 381:
! 382: t.c_ispeed = t.c_ospeed = TTYDEF_SPEED;
! 383: t.c_cflag = TTYDEF_CFLAG;
! 384: tp->t_ospeed = 0; /* force register update */
! 385: (void)sioparam(tp, &t);
! 386: tp->t_iflag = TTYDEF_IFLAG;
! 387: tp->t_oflag = TTYDEF_OFLAG;
! 388: tp->t_lflag = TTYDEF_LFLAG;
! 389: ttychars(tp);
! 390: ttsetwater(tp);
! 391: /* raise RTS and DTR here; but, DTR lead is not wired */
! 392: /* then check DCD condition; but, DCD lead is not wired */
! 393: tp->t_state |= TS_CARR_ON; /* assume detected all the time */
! 394: #if 0
! 395: if ((sc->sc_flags & TIOCFLAG_SOFTCAR)
! 396: || (tp->t_cflag & MDMBUF)
! 397: || (getsiocsr(sc->sc_ctl) & RR_DCD))
! 398: tp->t_state |= TS_CARR_ON;
! 399: else
! 400: tp->t_state &= ~TS_CARR_ON;
! 401: #endif
! 402: }
! 403:
! 404: error = ttyopen(dev, tp);
! 405: if (error > 0)
! 406: return error;
! 407: /*
! 408: return (*tp->t_linesw->l_open)(dev, tp);
! 409: */
! 410: return (*linesw[tp->t_line].l_open)(dev, tp);
! 411: }
! 412:
! 413: int
! 414: sioclose(dev, flag, mode, p)
! 415: dev_t dev;
! 416: int flag, mode;
! 417: struct proc *p;
! 418: {
! 419: struct siotty_softc *sc = siotty_cd.cd_devs[minor(dev)];
! 420: struct tty *tp = sc->sc_tty;
! 421: int s;
! 422:
! 423: /*
! 424: (*tp->t_linesw->l_close)(tp, flag);
! 425: */
! 426: (*linesw[tp->t_line].l_close)(tp, flag);
! 427:
! 428: s = spltty();
! 429: siomctl(sc, TIOCM_BREAK, DMBIC);
! 430: #if 0 /* because unable to feed DTR signal */
! 431: if ((tp->t_cflag & HUPCL)
! 432: || tp->t_wopen || (tp->t_state & TS_ISOPEN) == 0) {
! 433: siomctl(sc, TIOCM_DTR, DMBIC);
! 434: /* Yield CPU time to others for 1 second, then ... */
! 435: siomctl(sc, TIOCM_DTR, DMBIS);
! 436: }
! 437: #endif
! 438: splx(s);
! 439: return ttyclose(tp);
! 440: }
! 441:
! 442: int
! 443: sioread(dev, uio, flag)
! 444: dev_t dev;
! 445: struct uio *uio;
! 446: int flag;
! 447: {
! 448: struct siotty_softc *sc = siotty_cd.cd_devs[minor(dev)];
! 449: struct tty *tp = sc->sc_tty;
! 450:
! 451: /*
! 452: return (*tp->t_linesw->l_read)(tp, uio, flag);
! 453: */
! 454: return (*linesw[tp->t_line].l_read)(tp, uio, flag);
! 455: }
! 456:
! 457: int
! 458: siowrite(dev, uio, flag)
! 459: dev_t dev;
! 460: struct uio *uio;
! 461: int flag;
! 462: {
! 463: struct siotty_softc *sc = siotty_cd.cd_devs[minor(dev)];
! 464: struct tty *tp = sc->sc_tty;
! 465:
! 466: /*
! 467: return (*tp->t_linesw->l_write)(tp, uio, flag);
! 468: */
! 469: return (*linesw[tp->t_line].l_write)(tp, uio, flag);
! 470: }
! 471:
! 472: #if 0
! 473: int
! 474: sioselect(dev, events, p)
! 475: dev_t dev;
! 476: int events;
! 477: struct proc *p;
! 478: {
! 479: struct siotty_softc *sc = siotty_cd.cd_devs[minor(dev)];
! 480: struct tty *tp = sc->sc_tty;
! 481:
! 482: /*
! 483: return ((*tp->t_linesw->l_poll)(tp, events, p));
! 484: */
! 485: return ((*linesw[tp->t_line].l_select)(tp, events, p));
! 486:
! 487: }
! 488: #endif
! 489:
! 490: int
! 491: sioioctl(dev, cmd, data, flag, p)
! 492: dev_t dev;
! 493: u_long cmd;
! 494: caddr_t data;
! 495: int flag;
! 496: struct proc *p;
! 497: {
! 498: struct siotty_softc *sc = siotty_cd.cd_devs[minor(dev)];
! 499: struct tty *tp = sc->sc_tty;
! 500: int error;
! 501:
! 502: /*
! 503: error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, p);
! 504: */
! 505: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
! 506: if (error >= 0)
! 507: return error;
! 508:
! 509: error = ttioctl(tp, cmd, data, flag, p);
! 510: if (error >= 0)
! 511: return error;
! 512:
! 513: /* the last resort for TIOC ioctl tranversing */
! 514: switch (cmd) {
! 515: case TIOCSBRK: /* Set the hardware into BREAK condition */
! 516: siomctl(sc, TIOCM_BREAK, DMBIS);
! 517: break;
! 518: case TIOCCBRK: /* Clear the hardware BREAK condition */
! 519: siomctl(sc, TIOCM_BREAK, DMBIC);
! 520: break;
! 521: case TIOCSDTR: /* Assert DTR signal */
! 522: siomctl(sc, TIOCM_DTR|TIOCM_RTS, DMBIS);
! 523: break;
! 524: case TIOCCDTR: /* Clear DTR signal */
! 525: siomctl(sc, TIOCM_DTR|TIOCM_RTS, DMBIC);
! 526: break;
! 527: case TIOCMSET: /* Set modem state replacing current one */
! 528: siomctl(sc, *(int *)data, DMSET);
! 529: break;
! 530: case TIOCMGET: /* Return current modem state */
! 531: *(int *)data = siomctl(sc, 0, DMGET);
! 532: break;
! 533: case TIOCMBIS: /* Set individual bits of modem state */
! 534: siomctl(sc, *(int *)data, DMBIS);
! 535: break;
! 536: case TIOCMBIC: /* Clear individual bits of modem state */
! 537: siomctl(sc, *(int *)data, DMBIC);
! 538: break;
! 539: case TIOCSFLAGS: /* Instruct how serial port behaves */
! 540: error = suser(p, 0);
! 541: if (error != 0)
! 542: return EPERM;
! 543: sc->sc_flags = *(int *)data;
! 544: break;
! 545: case TIOCGFLAGS: /* Return current serial port state */
! 546: *(int *)data = sc->sc_flags;
! 547: break;
! 548: default:
! 549: /*
! 550: return EPASSTHROUGH;
! 551: */
! 552: return ENOTTY;
! 553: }
! 554: return 0;
! 555: }
! 556:
! 557: /* ARSGUSED */
! 558: struct tty *
! 559: siotty(dev)
! 560: dev_t dev;
! 561: {
! 562: struct siotty_softc *sc = siotty_cd.cd_devs[minor(dev)];
! 563:
! 564: return sc->sc_tty;
! 565: }
! 566:
! 567: /*-------------------- miscellaneous routines --------------------*/
! 568:
! 569: /* EXPORT */ void
! 570: setsioreg(sio, regno, val)
! 571: struct sioreg *sio;
! 572: int regno, val;
! 573: {
! 574: if (regno != 0)
! 575: sio->sio_cmd = regno; /* DELAY(); */
! 576: sio->sio_cmd = val; /* DELAY(); */
! 577: }
! 578:
! 579: /* EXPORT */ int
! 580: getsiocsr(sio)
! 581: struct sioreg *sio;
! 582: {
! 583: int val;
! 584:
! 585: val = sio->sio_stat << 8; /* DELAY(); */
! 586: sio->sio_cmd = 1; /* DELAY(); */
! 587: val |= sio->sio_stat; /* DELAY(); */
! 588: return val;
! 589: }
! 590:
! 591: /*--------------------- console interface ----------------------*/
! 592:
! 593: void syscnattach(int);
! 594: int syscngetc(dev_t);
! 595: void syscnputc(dev_t, int);
! 596:
! 597: struct consdev syscons = {
! 598: NULL,
! 599: NULL,
! 600: syscngetc,
! 601: syscnputc,
! 602: nullcnpollc,
! 603: NULL,
! 604: NODEV,
! 605: CN_REMOTE,
! 606: };
! 607:
! 608: /* EXPORT */ void
! 609: syscnattach(channel)
! 610: int channel;
! 611: {
! 612: /*
! 613: * Channel A is immediately initialized with 9600N1 right after cold
! 614: * boot/reset/poweron. ROM monitor emits one line message on CH.A.
! 615: */
! 616: struct sioreg *sio;
! 617: sio = (struct sioreg *)0x51000000 + channel;
! 618:
! 619: /* syscons.cn_dev = makedev(7, channel); */
! 620: syscons.cn_dev = makedev(12, channel);
! 621: cn_tab = &syscons;
! 622:
! 623: #if 0
! 624: setsioreg(sio, WR0, WR0_CHANRST);
! 625: setsioreg(sio, WR2A, WR2_VEC86 | WR2_INTR_1);
! 626: setsioreg(sio, WR2B, 0);
! 627: setsioreg(sio, WR0, ch0_regs[WR0]);
! 628: setsioreg(sio, WR4, ch0_regs[WR4]);
! 629: setsioreg(sio, WR3, ch0_regs[WR3]);
! 630: setsioreg(sio, WR5, ch0_regs[WR5]);
! 631: setsioreg(sio, WR0, ch0_regs[WR0]);
! 632: #endif
! 633: }
! 634:
! 635: /* EXPORT */ int
! 636: syscngetc(dev)
! 637: dev_t dev;
! 638: {
! 639: struct sioreg *sio;
! 640: int s, c;
! 641:
! 642: sio = (struct sioreg *)0x51000000 + ((int)dev & 0x1);
! 643: s = splhigh();
! 644: while ((getsiocsr(sio) & RR_RXRDY) == 0)
! 645: ;
! 646: c = sio->sio_data;
! 647: splx(s);
! 648:
! 649: return c;
! 650: }
! 651:
! 652: /* EXPORT */ void
! 653: syscnputc(dev, c)
! 654: dev_t dev;
! 655: int c;
! 656: {
! 657: struct sioreg *sio;
! 658: int s;
! 659:
! 660: sio = (struct sioreg *)0x51000000 + ((int)dev & 0x1);
! 661: s = splhigh();
! 662: while ((getsiocsr(sio) & RR_TXRDY) == 0)
! 663: ;
! 664: sio->sio_cmd = WR0_RSTPEND;
! 665: sio->sio_data = c;
! 666: splx(s);
! 667: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to siotty.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / luna88k / dev