Annotation of sys/arch/hp300/dev/dcm.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: dcm.c,v 1.28 2006/01/01 11:59:37 miod Exp $ */
! 2: /* $NetBSD: dcm.c,v 1.41 1997/05/05 20:59:16 thorpej Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995, 1996, 1997 Jason R. Thorpe. All rights reserved.
! 6: * Copyright (c) 1988 University of Utah.
! 7: * Copyright (c) 1982, 1986, 1990, 1993
! 8: * The Regents of the University of California. All rights reserved.
! 9: *
! 10: * This code is derived from software contributed to Berkeley by
! 11: * the Systems Programming Group of the University of Utah Computer
! 12: * Science Department.
! 13: *
! 14: * Redistribution and use in source and binary forms, with or without
! 15: * modification, are permitted provided that the following conditions
! 16: * are met:
! 17: * 1. Redistributions of source code must retain the above copyright
! 18: * notice, this list of conditions and the following disclaimer.
! 19: * 2. Redistributions in binary form must reproduce the above copyright
! 20: * notice, this list of conditions and the following disclaimer in the
! 21: * documentation and/or other materials provided with the distribution.
! 22: * 3. Neither the name of the University nor the names of its contributors
! 23: * may be used to endorse or promote products derived from this software
! 24: * without specific prior written permission.
! 25: *
! 26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 36: * SUCH DAMAGE.
! 37: *
! 38: * from Utah: $Hdr: dcm.c 1.29 92/01/21$
! 39: *
! 40: * @(#)dcm.c 8.4 (Berkeley) 1/12/94
! 41: */
! 42:
! 43: /*
! 44: * TODO:
! 45: * Timeouts
! 46: * Test console support.
! 47: */
! 48:
! 49: /*
! 50: * 98642/MUX
! 51: */
! 52: #include <sys/param.h>
! 53: #include <sys/systm.h>
! 54: #include <sys/ioctl.h>
! 55: #include <sys/proc.h>
! 56: #include <sys/tty.h>
! 57: #include <sys/conf.h>
! 58: #include <sys/file.h>
! 59: #include <sys/uio.h>
! 60: #include <sys/kernel.h>
! 61: #include <sys/syslog.h>
! 62: #include <sys/time.h>
! 63: #include <sys/device.h>
! 64:
! 65: #include <machine/autoconf.h>
! 66: #include <machine/bus.h>
! 67: #include <machine/cpu.h>
! 68: #include <machine/intr.h>
! 69:
! 70: #include <dev/cons.h>
! 71:
! 72: #include <hp300/dev/dioreg.h>
! 73: #include <hp300/dev/diovar.h>
! 74: #include <hp300/dev/diodevs.h>
! 75: #include <hp300/dev/dcmreg.h>
! 76:
! 77: #ifndef DEFAULT_BAUD_RATE
! 78: #define DEFAULT_BAUD_RATE 9600
! 79: #endif
! 80:
! 81: const struct speedtab dcmspeedtab[] = {
! 82: { 0, BR_0 },
! 83: { 50, BR_50 },
! 84: { 75, BR_75 },
! 85: { 110, BR_110 },
! 86: { 134, BR_134 },
! 87: { 150, BR_150 },
! 88: { 300, BR_300 },
! 89: { 600, BR_600 },
! 90: { 1200, BR_1200 },
! 91: { 1800, BR_1800 },
! 92: { 2400, BR_2400 },
! 93: { 4800, BR_4800 },
! 94: { 9600, BR_9600 },
! 95: { 19200, BR_19200 },
! 96: { 38400, BR_38400 },
! 97: { -1, -1 },
! 98: };
! 99:
! 100: /* u-sec per character based on baudrate (assumes 1 start/8 data/1 stop bit) */
! 101: #define DCM_USPERCH(s) (10000000 / (s))
! 102:
! 103: /*
! 104: * Per board interrupt scheme. 16.7ms is the polling interrupt rate
! 105: * (16.7ms is about 550 baud, 38.4k is 72 chars in 16.7ms).
! 106: */
! 107: #define DIS_TIMER 0
! 108: #define DIS_PERCHAR 1
! 109: #define DIS_RESET 2
! 110:
! 111: int dcmistype = -1; /* -1 == dynamic, 0 == timer, 1 == perchar */
! 112: int dcminterval = 5; /* interval (secs) between checks */
! 113: struct dcmischeme {
! 114: int dis_perchar; /* non-zero if interrupting per char */
! 115: long dis_time; /* last time examined */
! 116: int dis_intr; /* recv interrupts during last interval */
! 117: int dis_char; /* characters read during last interval */
! 118: };
! 119:
! 120: /*
! 121: * Stuff for DCM console support. This could probably be done a little
! 122: * better.
! 123: */
! 124: static struct dcmdevice *dcm_cn = NULL; /* pointer to hardware */
! 125: static int dcmconsinit; /* has been initialized */
! 126:
! 127: int dcmdefaultrate = DEFAULT_BAUD_RATE;
! 128: int dcmconbrdbusy = 0;
! 129: int dcmmajor;
! 130:
! 131: #ifdef KGDB
! 132: /*
! 133: * Kernel GDB support
! 134: */
! 135: #include <machine/remote-sl.h>
! 136:
! 137: extern dev_t kgdb_dev;
! 138: extern int kgdb_rate;
! 139: extern int kgdb_debug_init;
! 140: #endif
! 141:
! 142: /* #define DCMSTATS */
! 143:
! 144: #ifdef DEBUG
! 145: int dcmdebug = 0x0;
! 146: #define DDB_SIOERR 0x01
! 147: #define DDB_PARAM 0x02
! 148: #define DDB_INPUT 0x04
! 149: #define DDB_OUTPUT 0x08
! 150: #define DDB_INTR 0x10
! 151: #define DDB_IOCTL 0x20
! 152: #define DDB_INTSCHM 0x40
! 153: #define DDB_MODEM 0x80
! 154: #define DDB_OPENCLOSE 0x100
! 155: #endif
! 156:
! 157: #ifdef DCMSTATS
! 158: #define DCMRBSIZE 94
! 159: #define DCMXBSIZE 24
! 160:
! 161: struct dcmstats {
! 162: long xints; /* # of xmit ints */
! 163: long xchars; /* # of xmit chars */
! 164: long xempty; /* times outq is empty in dcmstart */
! 165: long xrestarts; /* times completed while xmitting */
! 166: long rints; /* # of recv ints */
! 167: long rchars; /* # of recv chars */
! 168: long xsilo[DCMXBSIZE+2]; /* times this many chars xmit on one int */
! 169: long rsilo[DCMRBSIZE+2]; /* times this many chars read on one int */
! 170: };
! 171: #endif
! 172:
! 173: #define DCMUNIT(x) (minor(x) & 0x7f)
! 174: #define DCMCUA(x) (minor(x) & 0x80)
! 175: #define DCMBOARD(x) (((x) >> 2) & 0x3f)
! 176: #define DCMPORT(x) ((x) & 3)
! 177:
! 178: /*
! 179: * Conversion from "HP DCE" to almost-normal DCE: on the 638 8-port mux,
! 180: * the distribution panel uses "HP DCE" conventions. If requested via
! 181: * the device flags, we swap the inputs to something closer to normal DCE,
! 182: * allowing a straight-through cable to a DTE or a reversed cable
! 183: * to a DCE (reversing 2-3, 4-5, 8-20 and leaving 6 unconnected;
! 184: * this gets "DCD" on pin 20 and "CTS" on 4, but doesn't connect
! 185: * DSR or make RTS work, though). The following gives the full
! 186: * details of a cable from this mux panel to a modem:
! 187: *
! 188: * HP modem
! 189: * name pin pin name
! 190: * HP inputs:
! 191: * "Rx" 2 3 Tx
! 192: * CTS 4 5 CTS (only needed for CCTS_OFLOW)
! 193: * DCD 20 8 DCD
! 194: * "DSR" 9 6 DSR (unneeded)
! 195: * RI 22 22 RI (unneeded)
! 196: *
! 197: * HP outputs:
! 198: * "Tx" 3 2 Rx
! 199: * "DTR" 6 not connected
! 200: * "RTS" 8 20 DTR
! 201: * "SR" 23 4 RTS (often not needed)
! 202: */
! 203: #define hp2dce_in(ibits) (iconv[(ibits) & 0xf])
! 204: static char iconv[16] = {
! 205: 0, MI_DM, MI_CTS, MI_CTS|MI_DM,
! 206: MI_CD, MI_CD|MI_DM, MI_CD|MI_CTS, MI_CD|MI_CTS|MI_DM,
! 207: MI_RI, MI_RI|MI_DM, MI_RI|MI_CTS, MI_RI|MI_CTS|MI_DM,
! 208: MI_RI|MI_CD, MI_RI|MI_CD|MI_DM, MI_RI|MI_CD|MI_CTS,
! 209: MI_RI|MI_CD|MI_CTS|MI_DM
! 210: };
! 211:
! 212: /*
! 213: * Note that 8-port boards appear as 2 4-port boards at consecutive
! 214: * select codes.
! 215: */
! 216: #define NDCMPORT 4
! 217:
! 218: struct dcm_softc {
! 219: struct device sc_dev; /* generic device glue */
! 220: struct isr sc_isr;
! 221: struct dcmdevice *sc_dcm; /* pointer to hardware */
! 222: struct tty *sc_tty[NDCMPORT]; /* our tty instances */
! 223: struct modemreg *sc_modem[NDCMPORT]; /* modem control */
! 224: char sc_mcndlast[NDCMPORT]; /* XXX last modem status for port */
! 225: short sc_softCAR; /* mask of ports with soft-carrier */
! 226: struct dcmischeme sc_scheme; /* interrupt scheme for board */
! 227: u_char sc_cua; /* callout mode */
! 228:
! 229: /*
! 230: * Mask of soft-carrier bits in config flags.
! 231: */
! 232: #define DCM_SOFTCAR 0x0000000f
! 233:
! 234: int sc_flags; /* misc. configuration info */
! 235:
! 236: /*
! 237: * Bits for sc_flags
! 238: */
! 239: #define DCM_ACTIVE 0x00000001 /* indicates board is alive */
! 240: #define DCM_ISCONSOLE 0x00000002 /* indicates board is console */
! 241: #define DCM_STDDCE 0x00000010 /* re-map DCE to standard */
! 242: #define DCM_FLAGMASK (DCM_STDDCE) /* mask of valid bits in config flags */
! 243:
! 244: #ifdef DCMSTATS
! 245: struct dcmstats sc_stats; /* metrics gathering */
! 246: #endif
! 247: };
! 248:
! 249: cdev_decl(dcm);
! 250:
! 251: int dcmintr(void *);
! 252: void dcmpint(struct dcm_softc *, int, int);
! 253: void dcmrint(struct dcm_softc *);
! 254: void dcmreadbuf(struct dcm_softc *, int);
! 255: void dcmxint(struct dcm_softc *, int);
! 256: void dcmmint(struct dcm_softc *, int, int);
! 257:
! 258: int dcmparam(struct tty *, struct termios *);
! 259: void dcmstart(struct tty *);
! 260: int dcmstop(struct tty *, int);
! 261: int dcmmctl(dev_t, int, int);
! 262: void dcmsetischeme(int, int);
! 263: void dcminit(struct dcmdevice *, int, int);
! 264:
! 265: int dcmselftest(struct dcm_softc *);
! 266:
! 267: int dcm_console_scan(int, caddr_t, void *);
! 268: cons_decl(dcm);
! 269:
! 270: int dcmmatch(struct device *, void *, void *);
! 271: void dcmattach(struct device *, struct device *, void *);
! 272:
! 273: struct cfattach dcm_ca = {
! 274: sizeof(struct dcm_softc), dcmmatch, dcmattach
! 275: };
! 276:
! 277: struct cfdriver dcm_cd = {
! 278: NULL, "dcm", DV_TTY
! 279: };
! 280:
! 281: int
! 282: dcmmatch(parent, match, aux)
! 283: struct device *parent;
! 284: void *match, *aux;
! 285: {
! 286: struct dio_attach_args *da = aux;
! 287:
! 288: switch (da->da_id) {
! 289: case DIO_DEVICE_ID_DCM:
! 290: case DIO_DEVICE_ID_DCMREM:
! 291: return (1);
! 292: }
! 293:
! 294: return (0);
! 295: }
! 296:
! 297: void
! 298: dcmattach(parent, self, aux)
! 299: struct device *parent, *self;
! 300: void *aux;
! 301: {
! 302: struct dcm_softc *sc = (struct dcm_softc *)self;
! 303: struct dio_attach_args *da = aux;
! 304: struct dcmdevice *dcm;
! 305: int brd = self->dv_unit;
! 306: int scode = da->da_scode;
! 307: int i, mbits, code, ipl;
! 308:
! 309: sc->sc_flags = 0;
! 310:
! 311: if (scode == conscode) {
! 312: dcm = (struct dcmdevice *)conaddr;
! 313: sc->sc_flags |= DCM_ISCONSOLE;
! 314:
! 315: /*
! 316: * We didn't know which unit this would be during
! 317: * the console probe, so we have to fixup cn_dev here.
! 318: * Note that we always assume port 1 on the board.
! 319: */
! 320: cn_tab->cn_dev = makedev(dcmmajor, (brd << 2) | DCMCONSPORT);
! 321: } else {
! 322: dcm = (struct dcmdevice *)iomap(dio_scodetopa(da->da_scode),
! 323: da->da_size);
! 324: if (dcm == NULL) {
! 325: printf("\n%s: can't map registers\n",
! 326: sc->sc_dev.dv_xname);
! 327: return;
! 328: }
! 329: }
! 330:
! 331: sc->sc_dcm = dcm;
! 332:
! 333: ipl = DIO_IPL(dcm);
! 334: printf(" ipl %d", ipl);
! 335:
! 336: /*
! 337: * XXX someone _should_ fix this; the self test screws
! 338: * autoconfig messages.
! 339: */
! 340: if ((sc->sc_flags & DCM_ISCONSOLE) && dcmselftest(sc)) {
! 341: printf("\n%s: self-test failed\n", sc->sc_dev.dv_xname);
! 342: return;
! 343: }
! 344:
! 345: /* Extract configuration info from flags. */
! 346: sc->sc_softCAR = self->dv_cfdata->cf_flags & DCM_SOFTCAR;
! 347: sc->sc_flags |= self->dv_cfdata->cf_flags & DCM_FLAGMASK;
! 348:
! 349: /* Mark our unit as configured. */
! 350: sc->sc_flags |= DCM_ACTIVE;
! 351:
! 352: /* Establish the interrupt handler. */
! 353: sc->sc_isr.isr_func = dcmintr;
! 354: sc->sc_isr.isr_arg = sc;
! 355: sc->sc_isr.isr_ipl = ipl;
! 356: sc->sc_isr.isr_priority = IPL_TTY;
! 357: dio_intr_establish(&sc->sc_isr, self->dv_xname);
! 358:
! 359: if (dcmistype == DIS_TIMER)
! 360: dcmsetischeme(brd, DIS_RESET|DIS_TIMER);
! 361: else
! 362: dcmsetischeme(brd, DIS_RESET|DIS_PERCHAR);
! 363:
! 364: /* load pointers to modem control */
! 365: sc->sc_modem[0] = &dcm->dcm_modem0;
! 366: sc->sc_modem[1] = &dcm->dcm_modem1;
! 367: sc->sc_modem[2] = &dcm->dcm_modem2;
! 368: sc->sc_modem[3] = &dcm->dcm_modem3;
! 369:
! 370: /* set DCD (modem) and CTS (flow control) on all ports */
! 371: if (sc->sc_flags & DCM_STDDCE)
! 372: mbits = hp2dce_in(MI_CD|MI_CTS);
! 373: else
! 374: mbits = MI_CD|MI_CTS;
! 375:
! 376: for (i = 0; i < NDCMPORT; i++)
! 377: sc->sc_modem[i]->mdmmsk = mbits;
! 378:
! 379: /*
! 380: * Get current state of mdmin register on all ports, so that
! 381: * deltas will work properly.
! 382: */
! 383: for (i = 0; i < NDCMPORT; i++) {
! 384: code = sc->sc_modem[i]->mdmin;
! 385: if (sc->sc_flags & DCM_STDDCE)
! 386: code = hp2dce_in(code);
! 387: sc->sc_mcndlast[i] = code;
! 388: }
! 389:
! 390: dcm->dcm_ic = IC_IE; /* turn all interrupts on */
! 391:
! 392: /*
! 393: * Need to reset baud rate, etc. of next print so reset dcmconsinit.
! 394: * Also make sure console is always "hardwired"
! 395: */
! 396: if (sc->sc_flags & DCM_ISCONSOLE) {
! 397: dcmconsinit = 0;
! 398: sc->sc_softCAR |= (1 << DCMCONSPORT);
! 399: printf(": console on port %d\n", DCMCONSPORT);
! 400: } else
! 401: printf("\n");
! 402:
! 403: #ifdef KGDB
! 404: if (major(kgdb_dev) == dcmmajor &&
! 405: DCMBOARD(DCMUNIT(kgdb_dev)) == brd) {
! 406: if (dcmconsole == DCMUNIT(kgdb_dev)) /* XXX fixme */
! 407: kgdb_dev = NODEV; /* can't debug over console port */
! 408: #ifndef KGDB_CHEAT
! 409: /*
! 410: * The following could potentially be replaced
! 411: * by the corresponding code in dcmcnprobe.
! 412: */
! 413: else {
! 414: dcminit(dcm, DCMPORT(DCMUNIT(kgdb_dev)),
! 415: kgdb_rate);
! 416: if (kgdb_debug_init) {
! 417: printf("%s port %d: ", sc->sc_dev.dv_xname,
! 418: DCMPORT(DCMUNIT(kgdb_dev)));
! 419: kgdb_connect(1);
! 420: } else
! 421: printf("%s port %d: kgdb enabled\n",
! 422: sc->sc_dev.dv_xname,
! 423: DCMPORT(DCMUNIT(kgdb_dev)));
! 424: }
! 425: /* end could be replaced */
! 426: #endif /* KGDB_CHEAT */
! 427: }
! 428: #endif /* KGDB */
! 429: }
! 430:
! 431: /* ARGSUSED */
! 432: int
! 433: dcmopen(dev, flag, mode, p)
! 434: dev_t dev;
! 435: int flag, mode;
! 436: struct proc *p;
! 437: {
! 438: struct dcm_softc *sc;
! 439: struct tty *tp;
! 440: int unit, brd, port;
! 441: int error = 0, mbits, s;
! 442:
! 443: unit = DCMUNIT(dev);
! 444: brd = DCMBOARD(unit);
! 445: port = DCMPORT(unit);
! 446:
! 447: if (brd >= dcm_cd.cd_ndevs || port >= NDCMPORT ||
! 448: (sc = dcm_cd.cd_devs[brd]) == NULL)
! 449: return (ENXIO);
! 450:
! 451: if ((sc->sc_flags & DCM_ACTIVE) == 0)
! 452: return (ENXIO);
! 453:
! 454: s = spltty();
! 455: if (sc->sc_tty[port] == NULL) {
! 456: tp = sc->sc_tty[port] = ttymalloc();
! 457: } else
! 458: tp = sc->sc_tty[port];
! 459: splx(s);
! 460:
! 461: tp->t_oproc = dcmstart;
! 462: tp->t_param = dcmparam;
! 463: tp->t_dev = dev;
! 464:
! 465: if ((tp->t_state & TS_ISOPEN) == 0) {
! 466: /*
! 467: * Sanity clause: reset the card on first open.
! 468: * The card might be left in an inconsistent state
! 469: * if the card memory is read inadvertently.
! 470: */
! 471: dcminit(sc->sc_dcm, port, dcmdefaultrate);
! 472:
! 473: tp->t_state |= TS_WOPEN;
! 474: ttychars(tp);
! 475: tp->t_iflag = TTYDEF_IFLAG;
! 476: tp->t_oflag = TTYDEF_OFLAG;
! 477: tp->t_cflag = TTYDEF_CFLAG;
! 478: tp->t_lflag = TTYDEF_LFLAG;
! 479: tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
! 480:
! 481: s = spltty();
! 482:
! 483: (void) dcmparam(tp, &tp->t_termios);
! 484: ttsetwater(tp);
! 485: } else if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0)
! 486: return (EBUSY);
! 487: else
! 488: s = spltty();
! 489:
! 490: /* Set modem control state. */
! 491: mbits = MO_ON;
! 492: if (sc->sc_flags & DCM_STDDCE)
! 493: mbits |= MO_SR; /* pin 23, could be used as RTS */
! 494:
! 495: (void) dcmmctl(dev, mbits, DMSET); /* enable port */
! 496:
! 497: /* Set soft-carrier if so configured. */
! 498: if ((sc->sc_softCAR & (1 << port)) || DCMCUA(dev) ||
! 499: (dcmmctl(dev, MO_OFF, DMGET) & MI_CD))
! 500: tp->t_state |= TS_CARR_ON;
! 501:
! 502: if (DCMCUA(dev)) {
! 503: if (tp->t_state & TS_ISOPEN) {
! 504: /* Ah, but someone already is dialed in... */
! 505: splx(s);
! 506: return (EBUSY);
! 507: }
! 508: sc->sc_cua = 1; /* We go into CUA mode */
! 509: }
! 510:
! 511: #ifdef DEBUG
! 512: if (dcmdebug & DDB_MODEM)
! 513: printf("%s: dcmopen port %d softcarr %c\n",
! 514: sc->sc_dev.dv_xname, port,
! 515: (tp->t_state & TS_CARR_ON) ? '1' : '0');
! 516: #endif
! 517:
! 518: /* Wait for carrier if necessary. */
! 519: if (flag & O_NONBLOCK) {
! 520: if (!DCMCUA(dev) && sc->sc_cua) {
! 521: /* Opening TTY non-blocking... but the CUA is busy */
! 522: splx(s);
! 523: return (EBUSY);
! 524: }
! 525: } else {
! 526: while (sc->sc_cua ||
! 527: ((tp->t_cflag & CLOCAL) == 0 &&
! 528: (tp->t_state & TS_CARR_ON) == 0)) {
! 529: tp->t_state |= TS_WOPEN;
! 530: error = ttysleep(tp, (caddr_t)&tp->t_rawq,
! 531: TTIPRI | PCATCH, ttopen, 0);
! 532: if (!DCMCUA(dev) && sc->sc_cua && error == EINTR)
! 533: continue;
! 534: if (error) {
! 535: if (DCMCUA(dev))
! 536: sc->sc_cua = 0;
! 537: splx(s);
! 538: return (error);
! 539: }
! 540: if (!DCMCUA(dev) && sc->sc_cua)
! 541: continue;
! 542: }
! 543: }
! 544: splx(s);
! 545:
! 546: #ifdef DEBUG
! 547: if (dcmdebug & DDB_OPENCLOSE)
! 548: printf("%s port %d: dcmopen: st %x fl %x\n",
! 549: sc->sc_dev.dv_xname, port, tp->t_state, tp->t_flags);
! 550: #endif
! 551: if (error == 0)
! 552: error = (*linesw[tp->t_line].l_open)(dev, tp);
! 553:
! 554: return (error);
! 555: }
! 556:
! 557: /*ARGSUSED*/
! 558: int
! 559: dcmclose(dev, flag, mode, p)
! 560: dev_t dev;
! 561: int flag, mode;
! 562: struct proc *p;
! 563: {
! 564: int s, unit, board, port;
! 565: struct dcm_softc *sc;
! 566: struct tty *tp;
! 567:
! 568: unit = DCMUNIT(dev);
! 569: board = DCMBOARD(unit);
! 570: port = DCMPORT(unit);
! 571:
! 572: sc = dcm_cd.cd_devs[board];
! 573: tp = sc->sc_tty[port];
! 574:
! 575: (*linesw[tp->t_line].l_close)(tp, flag);
! 576:
! 577: s = spltty();
! 578:
! 579: if (tp->t_cflag & HUPCL || tp->t_state & TS_WOPEN ||
! 580: (tp->t_state & TS_ISOPEN) == 0)
! 581: (void) dcmmctl(dev, MO_OFF, DMSET);
! 582: #ifdef DEBUG
! 583: if (dcmdebug & DDB_OPENCLOSE)
! 584: printf("%s port %d: dcmclose: st %x fl %x\n",
! 585: sc->sc_dev.dv_xname, port, tp->t_state, tp->t_flags);
! 586: #endif
! 587: sc->sc_cua = 0;
! 588: splx(s);
! 589: ttyclose(tp);
! 590: #if 0
! 591: ttyfree(tp);
! 592: sc->sc_tty[port] == NULL;
! 593: #endif
! 594: return (0);
! 595: }
! 596:
! 597: int
! 598: dcmread(dev, uio, flag)
! 599: dev_t dev;
! 600: struct uio *uio;
! 601: int flag;
! 602: {
! 603: int unit, board, port;
! 604: struct dcm_softc *sc;
! 605: struct tty *tp;
! 606:
! 607: unit = DCMUNIT(dev);
! 608: board = DCMBOARD(unit);
! 609: port = DCMPORT(unit);
! 610:
! 611: sc = dcm_cd.cd_devs[board];
! 612: tp = sc->sc_tty[port];
! 613:
! 614: return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
! 615: }
! 616:
! 617: int
! 618: dcmwrite(dev, uio, flag)
! 619: dev_t dev;
! 620: struct uio *uio;
! 621: int flag;
! 622: {
! 623: int unit, board, port;
! 624: struct dcm_softc *sc;
! 625: struct tty *tp;
! 626:
! 627: unit = DCMUNIT(dev);
! 628: board = DCMBOARD(unit);
! 629: port = DCMPORT(unit);
! 630:
! 631: sc = dcm_cd.cd_devs[board];
! 632: tp = sc->sc_tty[port];
! 633:
! 634: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
! 635: }
! 636:
! 637: struct tty *
! 638: dcmtty(dev)
! 639: dev_t dev;
! 640: {
! 641: int unit, board, port;
! 642: struct dcm_softc *sc;
! 643:
! 644: unit = DCMUNIT(dev);
! 645: board = DCMBOARD(unit);
! 646: port = DCMPORT(unit);
! 647:
! 648: sc = dcm_cd.cd_devs[board];
! 649:
! 650: return (sc->sc_tty[port]);
! 651: }
! 652:
! 653: int
! 654: dcmintr(arg)
! 655: void *arg;
! 656: {
! 657: struct dcm_softc *sc = arg;
! 658: struct dcmdevice *dcm = sc->sc_dcm;
! 659: struct dcmischeme *dis = &sc->sc_scheme;
! 660: int brd = sc->sc_dev.dv_unit;
! 661: int code, i;
! 662: int pcnd[4], mcode, mcnd[4];
! 663:
! 664: /*
! 665: * Do all guarded accesses right off to minimize
! 666: * block out of hardware.
! 667: */
! 668: SEM_LOCK(dcm);
! 669: if ((dcm->dcm_ic & IC_IR) == 0) {
! 670: SEM_UNLOCK(dcm);
! 671: return (0);
! 672: }
! 673:
! 674: for (i = 0; i < 4; i++) {
! 675: pcnd[i] = dcm->dcm_icrtab[i].dcm_data;
! 676: dcm->dcm_icrtab[i].dcm_data = 0;
! 677: code = sc->sc_modem[i]->mdmin;
! 678: if (sc->sc_flags & DCM_STDDCE)
! 679: code = hp2dce_in(code);
! 680: mcnd[i] = code;
! 681: }
! 682: code = dcm->dcm_iir & IIR_MASK;
! 683: dcm->dcm_iir = 0; /* XXX doc claims read clears interrupt?! */
! 684: mcode = dcm->dcm_modemintr;
! 685: dcm->dcm_modemintr = 0;
! 686: SEM_UNLOCK(dcm);
! 687:
! 688: #ifdef DEBUG
! 689: if (dcmdebug & DDB_INTR) {
! 690: printf("%s: dcmintr: iir %x pc %x/%x/%x/%x ",
! 691: sc->sc_dev.dv_xname, code, pcnd[0], pcnd[1],
! 692: pcnd[2], pcnd[3]);
! 693: printf("miir %x mc %x/%x/%x/%x\n",
! 694: mcode, mcnd[0], mcnd[1], mcnd[2], mcnd[3]);
! 695: }
! 696: #endif
! 697: if (code & IIR_TIMEO)
! 698: dcmrint(sc);
! 699: if (code & IIR_PORT0)
! 700: dcmpint(sc, 0, pcnd[0]);
! 701: if (code & IIR_PORT1)
! 702: dcmpint(sc, 1, pcnd[1]);
! 703: if (code & IIR_PORT2)
! 704: dcmpint(sc, 2, pcnd[2]);
! 705: if (code & IIR_PORT3)
! 706: dcmpint(sc, 3, pcnd[3]);
! 707: if (code & IIR_MODM) {
! 708: if (mcode == 0 || mcode & 0x1) /* mcode==0 -> 98642 board */
! 709: dcmmint(sc, 0, mcnd[0]);
! 710: if (mcode & 0x2)
! 711: dcmmint(sc, 1, mcnd[1]);
! 712: if (mcode & 0x4)
! 713: dcmmint(sc, 2, mcnd[2]);
! 714: if (mcode & 0x8)
! 715: dcmmint(sc, 3, mcnd[3]);
! 716: }
! 717:
! 718: /*
! 719: * Chalk up a receiver interrupt if the timer running or one of
! 720: * the ports reports a special character interrupt.
! 721: */
! 722: if ((code & IIR_TIMEO) ||
! 723: ((pcnd[0]|pcnd[1]|pcnd[2]|pcnd[3]) & IT_SPEC))
! 724: dis->dis_intr++;
! 725: /*
! 726: * See if it is time to check/change the interrupt rate.
! 727: */
! 728: if (dcmistype < 0 &&
! 729: (i = time.tv_sec - dis->dis_time) >= dcminterval) {
! 730: /*
! 731: * If currently per-character and averaged over 70 interrupts
! 732: * per-second (66 is threshold of 600 baud) in last interval,
! 733: * switch to timer mode.
! 734: *
! 735: * XXX decay counts ala load average to avoid spikes?
! 736: */
! 737: if (dis->dis_perchar && dis->dis_intr > 70 * i)
! 738: dcmsetischeme(brd, DIS_TIMER);
! 739: /*
! 740: * If currently using timer and had more interrupts than
! 741: * received characters in the last interval, switch back
! 742: * to per-character. Note that after changing to per-char
! 743: * we must process any characters already in the queue
! 744: * since they may have arrived before the bitmap was setup.
! 745: *
! 746: * XXX decay counts?
! 747: */
! 748: else if (!dis->dis_perchar && dis->dis_intr > dis->dis_char) {
! 749: dcmsetischeme(brd, DIS_PERCHAR);
! 750: dcmrint(sc);
! 751: }
! 752: dis->dis_intr = dis->dis_char = 0;
! 753: dis->dis_time = time.tv_sec;
! 754: }
! 755: return (1);
! 756: }
! 757:
! 758: /*
! 759: * Port interrupt. Can be two things:
! 760: * First, it might be a special character (exception interrupt);
! 761: * Second, it may be a buffer empty (transmit interrupt);
! 762: */
! 763: void
! 764: dcmpint(sc, port, code)
! 765: struct dcm_softc *sc;
! 766: int port, code;
! 767: {
! 768:
! 769: if (code & IT_SPEC)
! 770: dcmreadbuf(sc, port);
! 771: if (code & IT_TX)
! 772: dcmxint(sc, port);
! 773: }
! 774:
! 775: void
! 776: dcmrint(sc)
! 777: struct dcm_softc *sc;
! 778: {
! 779: int port;
! 780:
! 781: for (port = 0; port < NDCMPORT; port++)
! 782: dcmreadbuf(sc, port);
! 783: }
! 784:
! 785: void
! 786: dcmreadbuf(sc, port)
! 787: struct dcm_softc *sc;
! 788: int port;
! 789: {
! 790: struct dcmdevice *dcm = sc->sc_dcm;
! 791: struct dcmpreg *pp = dcm_preg(dcm, port);
! 792: struct dcmrfifo *fifo;
! 793: struct tty *tp;
! 794: int c, stat;
! 795: u_int head;
! 796: int nch = 0;
! 797: #ifdef DCMSTATS
! 798: struct dcmstats *dsp = &sc->sc_stats;
! 799:
! 800: dsp->rints++;
! 801: #endif
! 802: tp = sc->sc_tty[port];
! 803: if (tp == NULL)
! 804: return;
! 805:
! 806: if ((tp->t_state & TS_ISOPEN) == 0) {
! 807: #ifdef KGDB
! 808: if ((makedev(dcmmajor, minor(tp->t_dev)) == kgdb_dev) &&
! 809: (head = pp->r_head & RX_MASK) != (pp->r_tail & RX_MASK) &&
! 810: dcm->dcm_rfifos[3-port][head>>1].data_char == FRAME_START) {
! 811: pp->r_head = (head + 2) & RX_MASK;
! 812: kgdb_connect(0); /* trap into kgdb */
! 813: return;
! 814: }
! 815: #endif /* KGDB */
! 816: pp->r_head = pp->r_tail & RX_MASK;
! 817: return;
! 818: }
! 819:
! 820: head = pp->r_head & RX_MASK;
! 821: fifo = &dcm->dcm_rfifos[3-port][head>>1];
! 822: /*
! 823: * XXX upper bound on how many chars we will take in one swallow?
! 824: */
! 825: while (head != (pp->r_tail & RX_MASK)) {
! 826: /*
! 827: * Get character/status and update head pointer as fast
! 828: * as possible to make room for more characters.
! 829: */
! 830: c = fifo->data_char;
! 831: stat = fifo->data_stat;
! 832: head = (head + 2) & RX_MASK;
! 833: pp->r_head = head;
! 834: fifo = head ? fifo+1 : &dcm->dcm_rfifos[3-port][0];
! 835: nch++;
! 836:
! 837: #ifdef DEBUG
! 838: if (dcmdebug & DDB_INPUT)
! 839: printf("%s port %d: dcmreadbuf: c%x('%c') s%x f%x h%x t%x\n",
! 840: sc->sc_dev.dv_xname, port,
! 841: c&0xFF, c, stat&0xFF,
! 842: tp->t_flags, head, pp->r_tail);
! 843: #endif
! 844: /*
! 845: * Check for and handle errors
! 846: */
! 847: if (stat & RD_MASK) {
! 848: #ifdef DEBUG
! 849: if (dcmdebug & (DDB_INPUT|DDB_SIOERR))
! 850: printf("%s port %d: dcmreadbuf: err: c%x('%c') s%x\n",
! 851: sc->sc_dev.dv_xname, port,
! 852: stat, c&0xFF, c);
! 853: #endif
! 854: if (stat & (RD_BD | RD_FE))
! 855: c |= TTY_FE;
! 856: else if (stat & RD_PE)
! 857: c |= TTY_PE;
! 858: else if (stat & RD_OVF)
! 859: log(LOG_WARNING,
! 860: "%s port %d: silo overflow\n",
! 861: sc->sc_dev.dv_xname, port);
! 862: else if (stat & RD_OE)
! 863: log(LOG_WARNING,
! 864: "%s port %d: uart overflow\n",
! 865: sc->sc_dev.dv_xname, port);
! 866: }
! 867: (*linesw[tp->t_line].l_rint)(c, tp);
! 868: }
! 869: sc->sc_scheme.dis_char += nch;
! 870:
! 871: #ifdef DCMSTATS
! 872: dsp->rchars += nch;
! 873: if (nch <= DCMRBSIZE)
! 874: dsp->rsilo[nch]++;
! 875: else
! 876: dsp->rsilo[DCMRBSIZE+1]++;
! 877: #endif
! 878: }
! 879:
! 880: void
! 881: dcmxint(sc, port)
! 882: struct dcm_softc *sc;
! 883: int port;
! 884: {
! 885: struct tty *tp;
! 886:
! 887: tp = sc->sc_tty[port];
! 888: if (tp == NULL || (tp->t_state & TS_ISOPEN) == 0)
! 889: return;
! 890:
! 891: tp->t_state &= ~TS_BUSY;
! 892: if (tp->t_state & TS_FLUSH)
! 893: tp->t_state &= ~TS_FLUSH;
! 894: (*linesw[tp->t_line].l_start)(tp);
! 895: }
! 896:
! 897: void
! 898: dcmmint(sc, port, mcnd)
! 899: struct dcm_softc *sc;
! 900: int port, mcnd;
! 901: {
! 902: int delta;
! 903: struct tty *tp;
! 904: struct dcmdevice *dcm = sc->sc_dcm;
! 905:
! 906: tp = sc->sc_tty[port];
! 907: if (tp == NULL || (tp->t_state & TS_ISOPEN) == 0)
! 908: return;
! 909:
! 910: #ifdef DEBUG
! 911: if (dcmdebug & DDB_MODEM)
! 912: printf("%s port %d: dcmmint: mcnd %x mcndlast %x\n",
! 913: sc->sc_dev.dv_xname, port, mcnd, sc->sc_mcndlast[port]);
! 914: #endif
! 915: delta = mcnd ^ sc->sc_mcndlast[port];
! 916: sc->sc_mcndlast[port] = mcnd;
! 917: if ((delta & MI_CTS) && (tp->t_state & TS_ISOPEN) &&
! 918: (tp->t_flags & CCTS_OFLOW)) {
! 919: if (mcnd & MI_CTS) {
! 920: tp->t_state &= ~TS_TTSTOP;
! 921: ttstart(tp);
! 922: } else
! 923: tp->t_state |= TS_TTSTOP; /* inline dcmstop */
! 924: }
! 925: if (delta & MI_CD) {
! 926: if (mcnd & MI_CD)
! 927: (void)(*linesw[tp->t_line].l_modem)(tp, 1);
! 928: else if ((sc->sc_softCAR & (1 << port)) == 0 &&
! 929: (*linesw[tp->t_line].l_modem)(tp, 0) == 0) {
! 930: sc->sc_modem[port]->mdmout = MO_OFF;
! 931: SEM_LOCK(dcm);
! 932: dcm->dcm_modemchng |= (1 << port);
! 933: dcm->dcm_cr |= CR_MODM;
! 934: SEM_UNLOCK(dcm);
! 935: DELAY(10); /* time to change lines */
! 936: }
! 937: }
! 938: }
! 939:
! 940: int
! 941: dcmioctl(dev, cmd, data, flag, p)
! 942: dev_t dev;
! 943: u_long cmd;
! 944: caddr_t data;
! 945: int flag;
! 946: struct proc *p;
! 947: {
! 948: struct dcm_softc *sc;
! 949: struct tty *tp;
! 950: struct dcmdevice *dcm;
! 951: int board, port, unit = DCMUNIT(dev);
! 952: int error, s;
! 953:
! 954: port = DCMPORT(unit);
! 955: board = DCMBOARD(unit);
! 956:
! 957: sc = dcm_cd.cd_devs[board];
! 958: dcm = sc->sc_dcm;
! 959: tp = sc->sc_tty[port];
! 960:
! 961: #ifdef DEBUG
! 962: if (dcmdebug & DDB_IOCTL)
! 963: printf("%s port %d: dcmioctl: cmd %lx data %x flag %x\n",
! 964: sc->sc_dev.dv_xname, port, cmd, *data, flag);
! 965: #endif
! 966: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
! 967: if (error >= 0)
! 968: return (error);
! 969: error = ttioctl(tp, cmd, data, flag, p);
! 970: if (error >= 0)
! 971: return (error);
! 972:
! 973: switch (cmd) {
! 974: case TIOCSBRK:
! 975: /*
! 976: * Wait for transmitter buffer to empty
! 977: */
! 978: s = spltty();
! 979: while (dcm->dcm_thead[port].ptr != dcm->dcm_ttail[port].ptr)
! 980: DELAY(DCM_USPERCH(tp->t_ospeed));
! 981: SEM_LOCK(dcm);
! 982: dcm->dcm_cmdtab[port].dcm_data |= CT_BRK;
! 983: dcm->dcm_cr |= (1 << port); /* start break */
! 984: SEM_UNLOCK(dcm);
! 985: splx(s);
! 986: break;
! 987:
! 988: case TIOCCBRK:
! 989: SEM_LOCK(dcm);
! 990: dcm->dcm_cmdtab[port].dcm_data |= CT_BRK;
! 991: dcm->dcm_cr |= (1 << port); /* end break */
! 992: SEM_UNLOCK(dcm);
! 993: break;
! 994:
! 995: case TIOCSDTR:
! 996: (void) dcmmctl(dev, MO_ON, DMBIS);
! 997: break;
! 998:
! 999: case TIOCCDTR:
! 1000: (void) dcmmctl(dev, MO_ON, DMBIC);
! 1001: break;
! 1002:
! 1003: case TIOCMSET:
! 1004: (void) dcmmctl(dev, *(int *)data, DMSET);
! 1005: break;
! 1006:
! 1007: case TIOCMBIS:
! 1008: (void) dcmmctl(dev, *(int *)data, DMBIS);
! 1009: break;
! 1010:
! 1011: case TIOCMBIC:
! 1012: (void) dcmmctl(dev, *(int *)data, DMBIC);
! 1013: break;
! 1014:
! 1015: case TIOCMGET:
! 1016: *(int *)data = dcmmctl(dev, 0, DMGET);
! 1017: break;
! 1018:
! 1019: case TIOCGFLAGS: {
! 1020: int bits = 0;
! 1021:
! 1022: if ((sc->sc_softCAR & (1 << port)))
! 1023: bits |= TIOCFLAG_SOFTCAR;
! 1024:
! 1025: if (tp->t_cflag & CLOCAL)
! 1026: bits |= TIOCFLAG_CLOCAL;
! 1027:
! 1028: *(int *)data = bits;
! 1029: break;
! 1030: }
! 1031:
! 1032: case TIOCSFLAGS: {
! 1033: int userbits;
! 1034:
! 1035: error = suser(p, 0);
! 1036: if (error)
! 1037: return (EPERM);
! 1038:
! 1039: userbits = *(int *)data;
! 1040:
! 1041: if ((userbits & TIOCFLAG_SOFTCAR) ||
! 1042: ((sc->sc_flags & DCM_ISCONSOLE) &&
! 1043: (port == DCMCONSPORT)))
! 1044: sc->sc_softCAR |= (1 << port);
! 1045:
! 1046: if (userbits & TIOCFLAG_CLOCAL)
! 1047: tp->t_cflag |= CLOCAL;
! 1048:
! 1049: break;
! 1050: }
! 1051:
! 1052: default:
! 1053: return (ENOTTY);
! 1054: }
! 1055: return (0);
! 1056: }
! 1057:
! 1058: int
! 1059: dcmparam(tp, t)
! 1060: struct tty *tp;
! 1061: struct termios *t;
! 1062: {
! 1063: struct dcm_softc *sc;
! 1064: struct dcmdevice *dcm;
! 1065: int unit, board, port, mode, cflag = t->c_cflag;
! 1066: int ospeed = ttspeedtab(t->c_ospeed, dcmspeedtab);
! 1067:
! 1068: unit = DCMUNIT(tp->t_dev);
! 1069: board = DCMBOARD(unit);
! 1070: port = DCMPORT(unit);
! 1071:
! 1072: sc = dcm_cd.cd_devs[board];
! 1073: dcm = sc->sc_dcm;
! 1074:
! 1075: /* check requested parameters */
! 1076: if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed))
! 1077: return (EINVAL);
! 1078: /* and copy to tty */
! 1079: tp->t_ispeed = t->c_ispeed;
! 1080: tp->t_ospeed = t->c_ospeed;
! 1081: tp->t_cflag = cflag;
! 1082: if (ospeed == 0) {
! 1083: (void) dcmmctl(DCMUNIT(tp->t_dev), MO_OFF, DMSET);
! 1084: return (0);
! 1085: }
! 1086:
! 1087: mode = 0;
! 1088: switch (cflag&CSIZE) {
! 1089: case CS5:
! 1090: mode = LC_5BITS; break;
! 1091: case CS6:
! 1092: mode = LC_6BITS; break;
! 1093: case CS7:
! 1094: mode = LC_7BITS; break;
! 1095: case CS8:
! 1096: mode = LC_8BITS; break;
! 1097: }
! 1098: if (cflag&PARENB) {
! 1099: if (cflag&PARODD)
! 1100: mode |= LC_PODD;
! 1101: else
! 1102: mode |= LC_PEVEN;
! 1103: }
! 1104: if (cflag&CSTOPB)
! 1105: mode |= LC_2STOP;
! 1106: else
! 1107: mode |= LC_1STOP;
! 1108: #ifdef DEBUG
! 1109: if (dcmdebug & DDB_PARAM)
! 1110: printf("%s port %d: dcmparam: cflag %x mode %x speed %d uperch %d\n",
! 1111: sc->sc_dev.dv_xname, port, cflag, mode, tp->t_ospeed,
! 1112: DCM_USPERCH(tp->t_ospeed));
! 1113: #endif
! 1114:
! 1115: /*
! 1116: * Wait for transmitter buffer to empty.
! 1117: */
! 1118: while (dcm->dcm_thead[port].ptr != dcm->dcm_ttail[port].ptr)
! 1119: DELAY(DCM_USPERCH(tp->t_ospeed));
! 1120: /*
! 1121: * Make changes known to hardware.
! 1122: */
! 1123: dcm->dcm_data[port].dcm_baud = ospeed;
! 1124: dcm->dcm_data[port].dcm_conf = mode;
! 1125: SEM_LOCK(dcm);
! 1126: dcm->dcm_cmdtab[port].dcm_data |= CT_CON;
! 1127: dcm->dcm_cr |= (1 << port);
! 1128: SEM_UNLOCK(dcm);
! 1129: /*
! 1130: * Delay for config change to take place. Weighted by baud.
! 1131: * XXX why do we do this?
! 1132: */
! 1133: DELAY(16 * DCM_USPERCH(tp->t_ospeed));
! 1134: return (0);
! 1135: }
! 1136:
! 1137: void
! 1138: dcmstart(tp)
! 1139: struct tty *tp;
! 1140: {
! 1141: struct dcm_softc *sc;
! 1142: struct dcmdevice *dcm;
! 1143: struct dcmpreg *pp;
! 1144: struct dcmtfifo *fifo;
! 1145: char *bp;
! 1146: u_int head, tail, next;
! 1147: int unit, board, port, nch;
! 1148: char buf[16];
! 1149: int s;
! 1150: #ifdef DCMSTATS
! 1151: struct dcmstats *dsp = &sc->sc_stats;
! 1152: int tch = 0;
! 1153: #endif
! 1154:
! 1155: unit = DCMUNIT(tp->t_dev);
! 1156: board = DCMBOARD(unit);
! 1157: port = DCMPORT(unit);
! 1158:
! 1159: sc = dcm_cd.cd_devs[board];
! 1160: dcm = sc->sc_dcm;
! 1161:
! 1162: s = spltty();
! 1163: #ifdef DCMSTATS
! 1164: dsp->xints++;
! 1165: #endif
! 1166: #ifdef DEBUG
! 1167: if (dcmdebug & DDB_OUTPUT)
! 1168: printf("%s port %d: dcmstart: state %x flags %x outcc %d\n",
! 1169: sc->sc_dev.dv_xname, port, tp->t_state, tp->t_flags,
! 1170: tp->t_outq.c_cc);
! 1171: #endif
! 1172: if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))
! 1173: goto out;
! 1174: if (tp->t_outq.c_cc <= tp->t_lowat) {
! 1175: if (tp->t_state&TS_ASLEEP) {
! 1176: tp->t_state &= ~TS_ASLEEP;
! 1177: wakeup((caddr_t)&tp->t_outq);
! 1178: }
! 1179: selwakeup(&tp->t_wsel);
! 1180: }
! 1181: if (tp->t_outq.c_cc == 0) {
! 1182: #ifdef DCMSTATS
! 1183: dsp->xempty++;
! 1184: #endif
! 1185: goto out;
! 1186: }
! 1187:
! 1188: pp = dcm_preg(dcm, port);
! 1189: tail = pp->t_tail & TX_MASK;
! 1190: next = (tail + 1) & TX_MASK;
! 1191: head = pp->t_head & TX_MASK;
! 1192: if (head == next)
! 1193: goto out;
! 1194: fifo = &dcm->dcm_tfifos[3-port][tail];
! 1195: again:
! 1196: nch = q_to_b(&tp->t_outq, buf, (head - next) & TX_MASK);
! 1197: #ifdef DCMSTATS
! 1198: tch += nch;
! 1199: #endif
! 1200: #ifdef DEBUG
! 1201: if (dcmdebug & DDB_OUTPUT)
! 1202: printf("\thead %x tail %x nch %d\n", head, tail, nch);
! 1203: #endif
! 1204: /*
! 1205: * Loop transmitting all the characters we can.
! 1206: */
! 1207: for (bp = buf; --nch >= 0; bp++) {
! 1208: fifo->data_char = *bp;
! 1209: pp->t_tail = next;
! 1210: /*
! 1211: * If this is the first character,
! 1212: * get the hardware moving right now.
! 1213: */
! 1214: if (bp == buf) {
! 1215: tp->t_state |= TS_BUSY;
! 1216: SEM_LOCK(dcm);
! 1217: dcm->dcm_cmdtab[port].dcm_data |= CT_TX;
! 1218: dcm->dcm_cr |= (1 << port);
! 1219: SEM_UNLOCK(dcm);
! 1220: }
! 1221: tail = next;
! 1222: fifo = tail ? fifo+1 : &dcm->dcm_tfifos[3-port][0];
! 1223: next = (next + 1) & TX_MASK;
! 1224: }
! 1225: /*
! 1226: * Head changed while we were loading the buffer,
! 1227: * go back and load some more if we can.
! 1228: */
! 1229: if (tp->t_outq.c_cc && head != (pp->t_head & TX_MASK)) {
! 1230: #ifdef DCMSTATS
! 1231: dsp->xrestarts++;
! 1232: #endif
! 1233: head = pp->t_head & TX_MASK;
! 1234: goto again;
! 1235: }
! 1236:
! 1237: /*
! 1238: * Kick it one last time in case it finished while we were
! 1239: * loading the last bunch.
! 1240: */
! 1241: if (bp > &buf[1]) {
! 1242: tp->t_state |= TS_BUSY;
! 1243: SEM_LOCK(dcm);
! 1244: dcm->dcm_cmdtab[port].dcm_data |= CT_TX;
! 1245: dcm->dcm_cr |= (1 << port);
! 1246: SEM_UNLOCK(dcm);
! 1247: }
! 1248: #ifdef DEBUG
! 1249: if (dcmdebug & DDB_INTR)
! 1250: printf("%s port %d: dcmstart: head %x tail %x outqcc %d\n",
! 1251: sc->sc_dev.dv_xname, port, head, tail, tp->t_outq.c_cc);
! 1252: #endif
! 1253: out:
! 1254: #ifdef DCMSTATS
! 1255: dsp->xchars += tch;
! 1256: if (tch <= DCMXBSIZE)
! 1257: dsp->xsilo[tch]++;
! 1258: else
! 1259: dsp->xsilo[DCMXBSIZE+1]++;
! 1260: #endif
! 1261: splx(s);
! 1262: }
! 1263:
! 1264: /*
! 1265: * Stop output on a line.
! 1266: */
! 1267: int
! 1268: dcmstop(tp, flag)
! 1269: struct tty *tp;
! 1270: int flag;
! 1271: {
! 1272: int s;
! 1273:
! 1274: s = spltty();
! 1275: if (tp->t_state & TS_BUSY) {
! 1276: /* XXX is there some way to safely stop transmission? */
! 1277: if ((tp->t_state&TS_TTSTOP) == 0)
! 1278: tp->t_state |= TS_FLUSH;
! 1279: }
! 1280: splx(s);
! 1281: return (0);
! 1282: }
! 1283:
! 1284: /*
! 1285: * Modem control
! 1286: */
! 1287: int
! 1288: dcmmctl(dev, bits, how)
! 1289: dev_t dev;
! 1290: int bits, how;
! 1291: {
! 1292: struct dcm_softc *sc;
! 1293: struct dcmdevice *dcm;
! 1294: int s, unit, brd, port, hit = 0;
! 1295:
! 1296: unit = DCMUNIT(dev);
! 1297: brd = DCMBOARD(unit);
! 1298: port = DCMPORT(unit);
! 1299:
! 1300: sc = dcm_cd.cd_devs[brd];
! 1301: dcm = sc->sc_dcm;
! 1302:
! 1303: #ifdef DEBUG
! 1304: if (dcmdebug & DDB_MODEM)
! 1305: printf("%s port %d: dcmmctl: bits 0x%x how %x\n",
! 1306: sc->sc_dev.dv_xname, port, bits, how);
! 1307: #endif
! 1308:
! 1309: s = spltty();
! 1310:
! 1311: switch (how) {
! 1312: case DMSET:
! 1313: sc->sc_modem[port]->mdmout = bits;
! 1314: hit++;
! 1315: break;
! 1316:
! 1317: case DMBIS:
! 1318: sc->sc_modem[port]->mdmout |= bits;
! 1319: hit++;
! 1320: break;
! 1321:
! 1322: case DMBIC:
! 1323: sc->sc_modem[port]->mdmout &= ~bits;
! 1324: hit++;
! 1325: break;
! 1326:
! 1327: case DMGET:
! 1328: bits = sc->sc_modem[port]->mdmin;
! 1329: if (sc->sc_flags & DCM_STDDCE)
! 1330: bits = hp2dce_in(bits);
! 1331: break;
! 1332: }
! 1333: if (hit) {
! 1334: SEM_LOCK(dcm);
! 1335: dcm->dcm_modemchng |= 1<<(unit & 3);
! 1336: dcm->dcm_cr |= CR_MODM;
! 1337: SEM_UNLOCK(dcm);
! 1338: DELAY(10); /* delay until done */
! 1339: splx(s);
! 1340: }
! 1341: return (bits);
! 1342: }
! 1343:
! 1344: /*
! 1345: * Set board to either interrupt per-character or at a fixed interval.
! 1346: */
! 1347: void
! 1348: dcmsetischeme(brd, flags)
! 1349: int brd, flags;
! 1350: {
! 1351: struct dcm_softc *sc = dcm_cd.cd_devs[brd];
! 1352: struct dcmdevice *dcm = sc->sc_dcm;
! 1353: struct dcmischeme *dis = &sc->sc_scheme;
! 1354: int i;
! 1355: u_char mask;
! 1356: int perchar = flags & DIS_PERCHAR;
! 1357:
! 1358: #ifdef DEBUG
! 1359: if (dcmdebug & DDB_INTSCHM)
! 1360: printf("%s: dcmsetischeme(%d): cur %d, ints %d, chars %d\n",
! 1361: sc->sc_dev.dv_xname, perchar, dis->dis_perchar,
! 1362: dis->dis_intr, dis->dis_char);
! 1363: if ((flags & DIS_RESET) == 0 && perchar == dis->dis_perchar) {
! 1364: printf("%s: dcmsetischeme: redundant request %d\n",
! 1365: sc->sc_dev.dv_xname, perchar);
! 1366: return;
! 1367: }
! 1368: #endif
! 1369: /*
! 1370: * If perchar is non-zero, we enable interrupts on all characters
! 1371: * otherwise we disable perchar interrupts and use periodic
! 1372: * polling interrupts.
! 1373: */
! 1374: dis->dis_perchar = perchar;
! 1375: mask = perchar ? 0xf : 0x0;
! 1376: for (i = 0; i < 256; i++)
! 1377: dcm->dcm_bmap[i].data_data = mask;
! 1378: /*
! 1379: * Don't slow down tandem mode, interrupt on flow control
! 1380: * chars for any port on the board.
! 1381: */
! 1382: if (!perchar) {
! 1383: struct tty *tp;
! 1384: int c;
! 1385:
! 1386: for (i = 0; i < NDCMPORT; i++) {
! 1387: tp = sc->sc_tty[i];
! 1388:
! 1389: if ((c = tp->t_cc[VSTART]) != _POSIX_VDISABLE)
! 1390: dcm->dcm_bmap[c].data_data |= (1 << i);
! 1391: if ((c = tp->t_cc[VSTOP]) != _POSIX_VDISABLE)
! 1392: dcm->dcm_bmap[c].data_data |= (1 << i);
! 1393: }
! 1394: }
! 1395: /*
! 1396: * Board starts with timer disabled so if first call is to
! 1397: * set perchar mode then we don't want to toggle the timer.
! 1398: */
! 1399: if (flags == (DIS_RESET|DIS_PERCHAR))
! 1400: return;
! 1401: /*
! 1402: * Toggle card 16.7ms interrupts (we first make sure that card
! 1403: * has cleared the bit so it will see the toggle).
! 1404: */
! 1405: while (dcm->dcm_cr & CR_TIMER)
! 1406: ;
! 1407: SEM_LOCK(dcm);
! 1408: dcm->dcm_cr |= CR_TIMER;
! 1409: SEM_UNLOCK(dcm);
! 1410: }
! 1411:
! 1412: void
! 1413: dcminit(dcm, port, rate)
! 1414: struct dcmdevice *dcm;
! 1415: int port, rate;
! 1416: {
! 1417: int s, mode;
! 1418:
! 1419: mode = LC_8BITS | LC_1STOP;
! 1420:
! 1421: s = splhigh();
! 1422:
! 1423: /*
! 1424: * Wait for transmitter buffer to empty.
! 1425: */
! 1426: while (dcm->dcm_thead[port].ptr != dcm->dcm_ttail[port].ptr)
! 1427: DELAY(DCM_USPERCH(rate));
! 1428:
! 1429: /*
! 1430: * Make changes known to hardware.
! 1431: */
! 1432: dcm->dcm_data[port].dcm_baud = ttspeedtab(rate, dcmspeedtab);
! 1433: dcm->dcm_data[port].dcm_conf = mode;
! 1434: SEM_LOCK(dcm);
! 1435: dcm->dcm_cmdtab[port].dcm_data |= CT_CON;
! 1436: dcm->dcm_cr |= (1 << port);
! 1437: SEM_UNLOCK(dcm);
! 1438:
! 1439: /*
! 1440: * Delay for config change to take place. Weighted by baud.
! 1441: * XXX why do we do this?
! 1442: */
! 1443: DELAY(16 * DCM_USPERCH(rate));
! 1444: splx(s);
! 1445: }
! 1446:
! 1447: /*
! 1448: * Empirically derived self-test magic
! 1449: */
! 1450: int
! 1451: dcmselftest(sc)
! 1452: struct dcm_softc *sc;
! 1453: {
! 1454: struct dcmdevice *dcm = sc->sc_dcm;
! 1455: int timo = 0;
! 1456: int s, rv;
! 1457:
! 1458: rv = 1;
! 1459:
! 1460: s = splhigh();
! 1461: dcm->dcm_rsid = DCMRS;
! 1462: DELAY(50000); /* 5000 is not long enough */
! 1463: dcm->dcm_rsid = 0;
! 1464: dcm->dcm_ic = IC_IE;
! 1465: dcm->dcm_cr = CR_SELFT;
! 1466: while ((dcm->dcm_ic & IC_IR) == 0) {
! 1467: if (++timo == 20000)
! 1468: goto out;
! 1469: DELAY(1);
! 1470: }
! 1471: DELAY(50000); /* XXX why is this needed ???? */
! 1472: while ((dcm->dcm_iir & IIR_SELFT) == 0) {
! 1473: if (++timo == 400000)
! 1474: goto out;
! 1475: DELAY(1);
! 1476: }
! 1477: DELAY(50000); /* XXX why is this needed ???? */
! 1478: if (dcm->dcm_stcon != ST_OK) {
! 1479: #if 0
! 1480: if (hd->hp_args->hw_sc != conscode)
! 1481: printf("dcm%d: self test failed: %x\n",
! 1482: brd, dcm->dcm_stcon);
! 1483: #endif
! 1484: goto out;
! 1485: }
! 1486: dcm->dcm_ic = IC_ID;
! 1487: rv = 0;
! 1488:
! 1489: out:
! 1490: splx(s);
! 1491: return (rv);
! 1492: }
! 1493:
! 1494: /*
! 1495: * Following are all routines needed for DCM to act as console
! 1496: */
! 1497:
! 1498: int
! 1499: dcm_console_scan(scode, va, arg)
! 1500: int scode;
! 1501: caddr_t va;
! 1502: void *arg;
! 1503: {
! 1504: struct dcmdevice *dcm = (struct dcmdevice *)va;
! 1505: struct consdev *cp = arg;
! 1506: u_int pri;
! 1507:
! 1508: switch (dcm->dcm_rsid) {
! 1509: case DCMID:
! 1510: pri = CN_NORMAL;
! 1511: break;
! 1512:
! 1513: case DCMID|DCMCON:
! 1514: pri = CN_REMOTE;
! 1515: break;
! 1516:
! 1517: default:
! 1518: return (0);
! 1519: }
! 1520:
! 1521: #ifdef CONSCODE
! 1522: /*
! 1523: * Raise our priority, if appropriate.
! 1524: */
! 1525: if (scode == CONSCODE)
! 1526: pri = CN_FORCED;
! 1527: #endif
! 1528:
! 1529: /* Only raise priority. */
! 1530: if (pri > cp->cn_pri)
! 1531: cp->cn_pri = pri;
! 1532:
! 1533: /*
! 1534: * If our priority is higher than the currently-remembered
! 1535: * console, stash our priority, for the benefit of dcmcninit().
! 1536: */
! 1537: if (cn_tab == NULL || cp->cn_pri > cn_tab->cn_pri) {
! 1538: cn_tab = cp;
! 1539: conscode = scode;
! 1540: return (DIO_SIZE(scode, va));
! 1541: }
! 1542: return (0);
! 1543: }
! 1544:
! 1545: void
! 1546: dcmcnprobe(cp)
! 1547: struct consdev *cp;
! 1548: {
! 1549:
! 1550: /* locate the major number */
! 1551: for (dcmmajor = 0; dcmmajor < nchrdev; dcmmajor++)
! 1552: if (cdevsw[dcmmajor].d_open == dcmopen)
! 1553: break;
! 1554:
! 1555: /* initialize required fields */
! 1556: cp->cn_dev = makedev(dcmmajor, 0); /* XXX */
! 1557:
! 1558: console_scan(dcm_console_scan, cp);
! 1559:
! 1560: #ifdef KGDB_CHEAT
! 1561: /* XXX this needs to be fixed. */
! 1562: /*
! 1563: * This doesn't currently work, at least not with ite consoles;
! 1564: * the console hasn't been initialized yet.
! 1565: */
! 1566: if (major(kgdb_dev) == dcmmajor &&
! 1567: DCMBOARD(DCMUNIT(kgdb_dev)) == DCMBOARD(unit)) {
! 1568: dcminit(dcm_cn, DCMPORT(DCMUNIT(kgdb_dev)), kgdb_rate);
! 1569: if (kgdb_debug_init) {
! 1570: /*
! 1571: * We assume that console is ready for us...
! 1572: * this assumes that a dca or ite console
! 1573: * has been selected already and will init
! 1574: * on the first putc.
! 1575: */
! 1576: printf("dcm%d: ", DCMUNIT(kgdb_dev));
! 1577: kgdb_connect(1);
! 1578: }
! 1579: }
! 1580: #endif
! 1581: }
! 1582:
! 1583: /* ARGSUSED */
! 1584: void
! 1585: dcmcninit(cp)
! 1586: struct consdev *cp;
! 1587: {
! 1588:
! 1589: /*
! 1590: * We are not interested by the second console pass.
! 1591: */
! 1592: if (consolepass != 0)
! 1593: return;
! 1594:
! 1595: dcm_cn = (struct dcmdevice *)conaddr;
! 1596: dcminit(dcm_cn, DCMCONSPORT, dcmdefaultrate);
! 1597: dcmconsinit = 1;
! 1598: }
! 1599:
! 1600: /* ARGSUSED */
! 1601: int
! 1602: dcmcngetc(dev)
! 1603: dev_t dev;
! 1604: {
! 1605: struct dcmrfifo *fifo;
! 1606: struct dcmpreg *pp;
! 1607: u_int head;
! 1608: int s, c, stat;
! 1609:
! 1610: pp = dcm_preg(dcm_cn, DCMCONSPORT);
! 1611:
! 1612: s = splhigh();
! 1613: head = pp->r_head & RX_MASK;
! 1614: fifo = &dcm_cn->dcm_rfifos[3-DCMCONSPORT][head>>1];
! 1615: while (head == (pp->r_tail & RX_MASK))
! 1616: ;
! 1617: /*
! 1618: * If board interrupts are enabled, just let our received char
! 1619: * interrupt through in case some other port on the board was
! 1620: * busy. Otherwise we must clear the interrupt.
! 1621: */
! 1622: SEM_LOCK(dcm_cn);
! 1623: if ((dcm_cn->dcm_ic & IC_IE) == 0)
! 1624: stat = dcm_cn->dcm_iir;
! 1625: SEM_UNLOCK(dcm_cn);
! 1626: c = fifo->data_char;
! 1627: stat = fifo->data_stat;
! 1628: pp->r_head = (head + 2) & RX_MASK;
! 1629: splx(s);
! 1630: return (c);
! 1631: }
! 1632:
! 1633: /*
! 1634: * Console kernel output character routine.
! 1635: */
! 1636: /* ARGSUSED */
! 1637: void
! 1638: dcmcnputc(dev, c)
! 1639: dev_t dev;
! 1640: int c;
! 1641: {
! 1642: struct dcmpreg *pp;
! 1643: unsigned tail;
! 1644: int s, stat;
! 1645:
! 1646: pp = dcm_preg(dcm_cn, DCMCONSPORT);
! 1647:
! 1648: s = splhigh();
! 1649: #ifdef KGDB
! 1650: if (dev != kgdb_dev)
! 1651: #endif
! 1652: if (dcmconsinit == 0) {
! 1653: dcminit(dcm_cn, DCMCONSPORT, dcmdefaultrate);
! 1654: dcmconsinit = 1;
! 1655: }
! 1656: tail = pp->t_tail & TX_MASK;
! 1657: while (tail != (pp->t_head & TX_MASK))
! 1658: ;
! 1659: dcm_cn->dcm_tfifos[3-DCMCONSPORT][tail].data_char = c;
! 1660: pp->t_tail = tail = (tail + 1) & TX_MASK;
! 1661: SEM_LOCK(dcm_cn);
! 1662: dcm_cn->dcm_cmdtab[DCMCONSPORT].dcm_data |= CT_TX;
! 1663: dcm_cn->dcm_cr |= (1 << DCMCONSPORT);
! 1664: SEM_UNLOCK(dcm_cn);
! 1665: while (tail != (pp->t_head & TX_MASK))
! 1666: ;
! 1667: /*
! 1668: * If board interrupts are enabled, just let our completion
! 1669: * interrupt through in case some other port on the board
! 1670: * was busy. Otherwise we must clear the interrupt.
! 1671: */
! 1672: if ((dcm_cn->dcm_ic & IC_IE) == 0) {
! 1673: SEM_LOCK(dcm_cn);
! 1674: stat = dcm_cn->dcm_iir;
! 1675: SEM_UNLOCK(dcm_cn);
! 1676: }
! 1677: splx(s);
! 1678: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to dcm.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hp300 / dev