Annotation of sys/dev/ic/com.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: com.c,v 1.117 2007/07/15 19:25:49 kettenis Exp $ */
! 2: /* $NetBSD: com.c,v 1.82.4.1 1996/06/02 09:08:00 mrg Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1997 - 1999, Jason Downs. All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: *
! 16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS
! 17: * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
! 18: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
! 19: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT,
! 20: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 21: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 22: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
! 23: * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 24: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 25: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 26: * SUCH DAMAGE.
! 27: */
! 28: /*-
! 29: * Copyright (c) 1993, 1994, 1995, 1996
! 30: * Charles M. Hannum. All rights reserved.
! 31: * Copyright (c) 1991 The Regents of the University of California.
! 32: * All rights reserved.
! 33: *
! 34: * Redistribution and use in source and binary forms, with or without
! 35: * modification, are permitted provided that the following conditions
! 36: * are met:
! 37: * 1. Redistributions of source code must retain the above copyright
! 38: * notice, this list of conditions and the following disclaimer.
! 39: * 2. Redistributions in binary form must reproduce the above copyright
! 40: * notice, this list of conditions and the following disclaimer in the
! 41: * documentation and/or other materials provided with the distribution.
! 42: * 3. Neither the name of the University nor the names of its contributors
! 43: * may be used to endorse or promote products derived from this software
! 44: * without specific prior written permission.
! 45: *
! 46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 56: * SUCH DAMAGE.
! 57: *
! 58: * @(#)com.c 7.5 (Berkeley) 5/16/91
! 59: */
! 60:
! 61: /*
! 62: * COM driver, based on HP dca driver
! 63: * uses National Semiconductor NS16450/NS16550AF UART
! 64: */
! 65: #include <sys/param.h>
! 66: #include <sys/systm.h>
! 67: #include <sys/ioctl.h>
! 68: #include <sys/selinfo.h>
! 69: #include <sys/tty.h>
! 70: #include <sys/proc.h>
! 71: #include <sys/user.h>
! 72: #include <sys/conf.h>
! 73: #include <sys/file.h>
! 74: #include <sys/uio.h>
! 75: #include <sys/kernel.h>
! 76: #include <sys/syslog.h>
! 77: #include <sys/device.h>
! 78: #include <sys/vnode.h>
! 79: #ifdef DDB
! 80: #include <ddb/db_var.h>
! 81: #endif
! 82:
! 83: #include <machine/bus.h>
! 84: #if defined(__sparc64__) || !defined(__sparc__)
! 85: #include <machine/intr.h>
! 86: #endif
! 87:
! 88: #if !defined(__sparc__) || defined(__sparc64__)
! 89: #define COM_CONSOLE
! 90: #include <dev/cons.h>
! 91: #endif
! 92:
! 93: #include <dev/ic/comreg.h>
! 94: #include <dev/ic/comvar.h>
! 95: #include <dev/ic/ns16550reg.h>
! 96: #define com_lcr com_cfcr
! 97:
! 98: #ifdef COM_PXA2X0
! 99: #define com_isr 8
! 100: #define ISR_SEND (ISR_RXPL | ISR_XMODE | ISR_XMITIR)
! 101: #define ISR_RECV (ISR_RXPL | ISR_XMODE | ISR_RCVEIR)
! 102: #endif
! 103:
! 104: #ifdef __zaurus__
! 105: #include <arch/zaurus/dev/zaurus_scoopvar.h>
! 106: #endif
! 107:
! 108: /* XXX: These belong elsewhere */
! 109: cdev_decl(com);
! 110:
! 111: static u_char tiocm_xxx2mcr(int);
! 112:
! 113: void compwroff(struct com_softc *);
! 114: void cominit(bus_space_tag_t, bus_space_handle_t, int, int);
! 115: int com_is_console(bus_space_tag_t, bus_addr_t);
! 116:
! 117: struct cfdriver com_cd = {
! 118: NULL, "com", DV_TTY
! 119: };
! 120:
! 121: int comdefaultrate = TTYDEF_SPEED;
! 122: #ifdef COM_PXA2X0
! 123: bus_addr_t comsiraddr;
! 124: #endif
! 125: #ifdef COM_CONSOLE
! 126: int comconsfreq;
! 127: int comconsinit;
! 128: bus_addr_t comconsaddr;
! 129: int comconsattached;
! 130: bus_space_tag_t comconsiot;
! 131: bus_space_handle_t comconsioh;
! 132: tcflag_t comconscflag = TTYDEF_CFLAG;
! 133: #endif
! 134:
! 135: int commajor;
! 136:
! 137: #ifdef KGDB
! 138: #include <sys/kgdb.h>
! 139:
! 140: bus_addr_t com_kgdb_addr;
! 141: bus_space_tag_t com_kgdb_iot;
! 142: bus_space_handle_t com_kgdb_ioh;
! 143:
! 144: int com_kgdb_getc(void *);
! 145: void com_kgdb_putc(void *, int);
! 146: #endif /* KGDB */
! 147:
! 148: #define DEVUNIT(x) (minor(x) & 0x7f)
! 149: #define DEVCUA(x) (minor(x) & 0x80)
! 150:
! 151: int
! 152: comspeed(long freq, long speed)
! 153: {
! 154: #define divrnd(n, q) (((n)*2/(q)+1)/2) /* divide and round off */
! 155:
! 156: int x, err;
! 157:
! 158: if (speed == 0)
! 159: return 0;
! 160: if (speed < 0)
! 161: return -1;
! 162: x = divrnd((freq / 16), speed);
! 163: if (x <= 0)
! 164: return -1;
! 165: err = divrnd((quad_t)freq * 1000 / 16, speed * x) - 1000;
! 166: if (err < 0)
! 167: err = -err;
! 168: if (err > COM_TOLERANCE)
! 169: return -1;
! 170: return x;
! 171:
! 172: #undef divrnd
! 173: }
! 174:
! 175: #ifdef COM_CONSOLE
! 176: int
! 177: comprobe1(bus_space_tag_t iot, bus_space_handle_t ioh)
! 178: {
! 179: int i, k;
! 180:
! 181: /* force access to id reg */
! 182: bus_space_write_1(iot, ioh, com_lcr, 0);
! 183: bus_space_write_1(iot, ioh, com_iir, 0);
! 184: for (i = 0; i < 32; i++) {
! 185: k = bus_space_read_1(iot, ioh, com_iir);
! 186: if (k & 0x38) {
! 187: bus_space_read_1(iot, ioh, com_data); /* cleanup */
! 188: } else
! 189: break;
! 190: }
! 191: if (i >= 32)
! 192: return 0;
! 193:
! 194: return 1;
! 195: }
! 196: #endif
! 197:
! 198: int
! 199: com_detach(struct device *self, int flags)
! 200: {
! 201: struct com_softc *sc = (struct com_softc *)self;
! 202: int maj, mn;
! 203:
! 204: sc->sc_swflags |= COM_SW_DEAD;
! 205:
! 206: /* locate the major number */
! 207: for (maj = 0; maj < nchrdev; maj++)
! 208: if (cdevsw[maj].d_open == comopen)
! 209: break;
! 210:
! 211: /* Nuke the vnodes for any open instances. */
! 212: mn = self->dv_unit;
! 213: vdevgone(maj, mn, mn, VCHR);
! 214:
! 215: /* XXX a symbolic constant for the cua bit would be nicer. */
! 216: mn |= 0x80;
! 217: vdevgone(maj, mn, mn, VCHR);
! 218:
! 219: /* Detach and free the tty. */
! 220: if (sc->sc_tty) {
! 221: ttyfree(sc->sc_tty);
! 222: }
! 223:
! 224: timeout_del(&sc->sc_dtr_tmo);
! 225: timeout_del(&sc->sc_diag_tmo);
! 226: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
! 227: softintr_disestablish(sc->sc_si);
! 228: #else
! 229: timeout_del(&sc->sc_comsoft_tmo);
! 230: #endif
! 231:
! 232: return (0);
! 233: }
! 234:
! 235: int
! 236: com_activate(struct device *self, enum devact act)
! 237: {
! 238: struct com_softc *sc = (struct com_softc *)self;
! 239: int s, rv = 0;
! 240:
! 241: s = spltty();
! 242: switch (act) {
! 243: case DVACT_ACTIVATE:
! 244: break;
! 245:
! 246: case DVACT_DEACTIVATE:
! 247: #ifdef KGDB
! 248: if (sc->sc_hwflags & (COM_HW_CONSOLE|COM_HW_KGDB)) {
! 249: #else
! 250: if (sc->sc_hwflags & COM_HW_CONSOLE) {
! 251: #endif /* KGDB */
! 252: rv = EBUSY;
! 253: break;
! 254: }
! 255:
! 256: if (sc->disable != NULL && sc->enabled != 0) {
! 257: (*sc->disable)(sc);
! 258: sc->enabled = 0;
! 259: }
! 260: break;
! 261: }
! 262: splx(s);
! 263: return (rv);
! 264: }
! 265:
! 266: int
! 267: comopen(dev_t dev, int flag, int mode, struct proc *p)
! 268: {
! 269: int unit = DEVUNIT(dev);
! 270: struct com_softc *sc;
! 271: bus_space_tag_t iot;
! 272: bus_space_handle_t ioh;
! 273: struct tty *tp;
! 274: int s;
! 275: int error = 0;
! 276:
! 277: if (unit >= com_cd.cd_ndevs)
! 278: return ENXIO;
! 279: sc = com_cd.cd_devs[unit];
! 280: if (!sc)
! 281: return ENXIO;
! 282:
! 283: #ifdef KGDB
! 284: /*
! 285: * If this is the kgdb port, no other use is permitted.
! 286: */
! 287: if (ISSET(sc->sc_hwflags, COM_HW_KGDB))
! 288: return (EBUSY);
! 289: #endif /* KGDB */
! 290:
! 291: s = spltty();
! 292: if (!sc->sc_tty) {
! 293: tp = sc->sc_tty = ttymalloc();
! 294: } else
! 295: tp = sc->sc_tty;
! 296: splx(s);
! 297:
! 298: tp->t_oproc = comstart;
! 299: tp->t_param = comparam;
! 300: tp->t_dev = dev;
! 301: if (!ISSET(tp->t_state, TS_ISOPEN)) {
! 302: SET(tp->t_state, TS_WOPEN);
! 303: ttychars(tp);
! 304: tp->t_iflag = TTYDEF_IFLAG;
! 305: tp->t_oflag = TTYDEF_OFLAG;
! 306: #ifdef COM_CONSOLE
! 307: if (ISSET(sc->sc_hwflags, COM_HW_CONSOLE))
! 308: tp->t_cflag = comconscflag;
! 309: else
! 310: #endif
! 311: tp->t_cflag = TTYDEF_CFLAG;
! 312: if (ISSET(sc->sc_swflags, COM_SW_CLOCAL))
! 313: SET(tp->t_cflag, CLOCAL);
! 314: if (ISSET(sc->sc_swflags, COM_SW_CRTSCTS))
! 315: SET(tp->t_cflag, CRTSCTS);
! 316: if (ISSET(sc->sc_swflags, COM_SW_MDMBUF))
! 317: SET(tp->t_cflag, MDMBUF);
! 318: tp->t_lflag = TTYDEF_LFLAG;
! 319: tp->t_ispeed = tp->t_ospeed = comdefaultrate;
! 320:
! 321: s = spltty();
! 322:
! 323: sc->sc_initialize = 1;
! 324: comparam(tp, &tp->t_termios);
! 325: ttsetwater(tp);
! 326:
! 327: #ifndef __HAVE_GENERIC_SOFT_INTERRUPTS
! 328: timeout_add(&sc->sc_comsoft_tmo, 1);
! 329: #endif
! 330:
! 331: sc->sc_ibufp = sc->sc_ibuf = sc->sc_ibufs[0];
! 332: sc->sc_ibufhigh = sc->sc_ibuf + COM_IHIGHWATER;
! 333: sc->sc_ibufend = sc->sc_ibuf + COM_IBUFSIZE;
! 334:
! 335: iot = sc->sc_iot;
! 336: ioh = sc->sc_ioh;
! 337:
! 338: /*
! 339: * Wake up the sleepy heads.
! 340: */
! 341: switch (sc->sc_uarttype) {
! 342: case COM_UART_ST16650:
! 343: case COM_UART_ST16650V2:
! 344: bus_space_write_1(iot, ioh, com_lcr, LCR_EFR);
! 345: bus_space_write_1(iot, ioh, com_efr, EFR_ECB);
! 346: bus_space_write_1(iot, ioh, com_ier, 0);
! 347: bus_space_write_1(iot, ioh, com_efr, 0);
! 348: bus_space_write_1(iot, ioh, com_lcr, 0);
! 349: break;
! 350: case COM_UART_TI16750:
! 351: bus_space_write_1(iot, ioh, com_ier, 0);
! 352: break;
! 353: case COM_UART_PXA2X0:
! 354: bus_space_write_1(iot, ioh, com_ier, IER_EUART);
! 355: break;
! 356: }
! 357:
! 358: if (ISSET(sc->sc_hwflags, COM_HW_FIFO)) {
! 359: u_int8_t fifo = FIFO_ENABLE|FIFO_RCV_RST|FIFO_XMT_RST;
! 360: u_int8_t lcr;
! 361:
! 362: if (tp->t_ispeed <= 1200)
! 363: fifo |= FIFO_TRIGGER_1;
! 364: else
! 365: fifo |= FIFO_TRIGGER_8;
! 366: if (sc->sc_uarttype == COM_UART_TI16750) {
! 367: fifo |= FIFO_ENABLE_64BYTE;
! 368: lcr = bus_space_read_1(iot, ioh, com_lcr);
! 369: bus_space_write_1(iot, ioh, com_lcr,
! 370: lcr | LCR_DLAB);
! 371: }
! 372:
! 373: /*
! 374: * (Re)enable and drain FIFOs.
! 375: *
! 376: * Certain SMC chips cause problems if the FIFOs are
! 377: * enabled while input is ready. Turn off the FIFO
! 378: * if necessary to clear the input. Test the input
! 379: * ready bit after enabling the FIFOs to handle races
! 380: * between enabling and fresh input.
! 381: *
! 382: * Set the FIFO threshold based on the receive speed.
! 383: */
! 384: for (;;) {
! 385: bus_space_write_1(iot, ioh, com_fifo, 0);
! 386: delay(100);
! 387: (void) bus_space_read_1(iot, ioh, com_data);
! 388: bus_space_write_1(iot, ioh, com_fifo, fifo |
! 389: FIFO_RCV_RST | FIFO_XMT_RST);
! 390: delay(100);
! 391: if(!ISSET(bus_space_read_1(iot, ioh,
! 392: com_lsr), LSR_RXRDY))
! 393: break;
! 394: }
! 395: if (sc->sc_uarttype == COM_UART_TI16750)
! 396: bus_space_write_1(iot, ioh, com_lcr, lcr);
! 397: }
! 398:
! 399: /* flush any pending I/O */
! 400: while (ISSET(bus_space_read_1(iot, ioh, com_lsr), LSR_RXRDY))
! 401: (void) bus_space_read_1(iot, ioh, com_data);
! 402: /* you turn me on, baby */
! 403: sc->sc_mcr = MCR_DTR | MCR_RTS;
! 404: if (!ISSET(sc->sc_hwflags, COM_HW_NOIEN))
! 405: SET(sc->sc_mcr, MCR_IENABLE);
! 406: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 407: sc->sc_ier = IER_ERXRDY | IER_ERLS | IER_EMSC;
! 408: #ifdef COM_PXA2X0
! 409: if (sc->sc_uarttype == COM_UART_PXA2X0)
! 410: sc->sc_ier |= IER_EUART | IER_ERXTOUT;
! 411: #endif
! 412: bus_space_write_1(iot, ioh, com_ier, sc->sc_ier);
! 413:
! 414: sc->sc_msr = bus_space_read_1(iot, ioh, com_msr);
! 415: if (ISSET(sc->sc_swflags, COM_SW_SOFTCAR) || DEVCUA(dev) ||
! 416: ISSET(sc->sc_msr, MSR_DCD) || ISSET(tp->t_cflag, MDMBUF))
! 417: SET(tp->t_state, TS_CARR_ON);
! 418: else
! 419: CLR(tp->t_state, TS_CARR_ON);
! 420: #ifdef COM_PXA2X0
! 421: if (sc->sc_uarttype == COM_UART_PXA2X0 &&
! 422: ISSET(sc->sc_hwflags, COM_HW_SIR)) {
! 423: bus_space_write_1(iot, ioh, com_isr, ISR_RECV);
! 424: #ifdef __zaurus__
! 425: scoop_set_irled(1);
! 426: #endif
! 427: }
! 428: #endif
! 429: } else if (ISSET(tp->t_state, TS_XCLUDE) && p->p_ucred->cr_uid != 0)
! 430: return EBUSY;
! 431: else
! 432: s = spltty();
! 433:
! 434: if (DEVCUA(dev)) {
! 435: if (ISSET(tp->t_state, TS_ISOPEN)) {
! 436: /* Ah, but someone already is dialed in... */
! 437: splx(s);
! 438: return EBUSY;
! 439: }
! 440: sc->sc_cua = 1; /* We go into CUA mode */
! 441: } else {
! 442: /* tty (not cua) device; wait for carrier if necessary */
! 443: if (ISSET(flag, O_NONBLOCK)) {
! 444: if (sc->sc_cua) {
! 445: /* Opening TTY non-blocking... but the CUA is busy */
! 446: splx(s);
! 447: return EBUSY;
! 448: }
! 449: } else {
! 450: while (sc->sc_cua ||
! 451: (!ISSET(tp->t_cflag, CLOCAL) &&
! 452: !ISSET(tp->t_state, TS_CARR_ON))) {
! 453: SET(tp->t_state, TS_WOPEN);
! 454: error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH, ttopen, 0);
! 455: /*
! 456: * If TS_WOPEN has been reset, that means the cua device
! 457: * has been closed. We don't want to fail in that case,
! 458: * so just go around again.
! 459: */
! 460: if (error && ISSET(tp->t_state, TS_WOPEN)) {
! 461: CLR(tp->t_state, TS_WOPEN);
! 462: if (!sc->sc_cua && !ISSET(tp->t_state, TS_ISOPEN))
! 463: compwroff(sc);
! 464: splx(s);
! 465: return error;
! 466: }
! 467: }
! 468: }
! 469: }
! 470: splx(s);
! 471:
! 472: return (*linesw[tp->t_line].l_open)(dev, tp);
! 473: }
! 474:
! 475: int
! 476: comclose(dev_t dev, int flag, int mode, struct proc *p)
! 477: {
! 478: int unit = DEVUNIT(dev);
! 479: struct com_softc *sc = com_cd.cd_devs[unit];
! 480: bus_space_tag_t iot = sc->sc_iot;
! 481: bus_space_handle_t ioh = sc->sc_ioh;
! 482: struct tty *tp = sc->sc_tty;
! 483: int s;
! 484:
! 485: #ifdef COM_CONSOLE
! 486: /* XXX This is for cons.c. */
! 487: if (!ISSET(tp->t_state, TS_ISOPEN))
! 488: return 0;
! 489: #endif
! 490:
! 491: if(sc->sc_swflags & COM_SW_DEAD)
! 492: return 0;
! 493:
! 494: (*linesw[tp->t_line].l_close)(tp, flag);
! 495: s = spltty();
! 496: if (ISSET(tp->t_state, TS_WOPEN)) {
! 497: /* tty device is waiting for carrier; drop dtr then re-raise */
! 498: CLR(sc->sc_mcr, MCR_DTR | MCR_RTS);
! 499: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 500: timeout_add(&sc->sc_dtr_tmo, hz * 2);
! 501: } else {
! 502: /* no one else waiting; turn off the uart */
! 503: compwroff(sc);
! 504: }
! 505: CLR(tp->t_state, TS_BUSY | TS_FLUSH);
! 506: #ifndef __HAVE_GENERIC_SOFT_INTERRUPTS
! 507: timeout_del(&sc->sc_comsoft_tmo);
! 508: #endif
! 509: sc->sc_cua = 0;
! 510: splx(s);
! 511: ttyclose(tp);
! 512:
! 513: #ifdef COM_CONSOLE
! 514: #ifdef notyet /* XXXX */
! 515: if (ISSET(sc->sc_hwflags, COM_HW_CONSOLE)) {
! 516: ttyfree(tp);
! 517: sc->sc_tty = 0;
! 518: }
! 519: #endif
! 520: #endif
! 521: return 0;
! 522: }
! 523:
! 524: void
! 525: compwroff(struct com_softc *sc)
! 526: {
! 527: bus_space_tag_t iot = sc->sc_iot;
! 528: bus_space_handle_t ioh = sc->sc_ioh;
! 529: struct tty *tp = sc->sc_tty;
! 530:
! 531: CLR(sc->sc_lcr, LCR_SBREAK);
! 532: bus_space_write_1(iot, ioh, com_lcr, sc->sc_lcr);
! 533: bus_space_write_1(iot, ioh, com_ier, 0);
! 534: if (ISSET(tp->t_cflag, HUPCL) &&
! 535: !ISSET(sc->sc_swflags, COM_SW_SOFTCAR)) {
! 536: /* XXX perhaps only clear DTR */
! 537: sc->sc_mcr = 0;
! 538: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 539: }
! 540:
! 541: /*
! 542: * Turn FIFO off; enter sleep mode if possible.
! 543: */
! 544: bus_space_write_1(iot, ioh, com_fifo, 0);
! 545: delay(100);
! 546: (void) bus_space_read_1(iot, ioh, com_data);
! 547: delay(100);
! 548: bus_space_write_1(iot, ioh, com_fifo,
! 549: FIFO_RCV_RST | FIFO_XMT_RST);
! 550:
! 551: switch (sc->sc_uarttype) {
! 552: case COM_UART_ST16650:
! 553: case COM_UART_ST16650V2:
! 554: bus_space_write_1(iot, ioh, com_lcr, LCR_EFR);
! 555: bus_space_write_1(iot, ioh, com_efr, EFR_ECB);
! 556: bus_space_write_1(iot, ioh, com_ier, IER_SLEEP);
! 557: bus_space_write_1(iot, ioh, com_lcr, 0);
! 558: break;
! 559: case COM_UART_TI16750:
! 560: bus_space_write_1(iot, ioh, com_ier, IER_SLEEP);
! 561: break;
! 562: #ifdef COM_PXA2X0
! 563: case COM_UART_PXA2X0:
! 564: bus_space_write_1(iot, ioh, com_ier, 0);
! 565: #ifdef __zaurus__
! 566: if (ISSET(sc->sc_hwflags, COM_HW_SIR))
! 567: scoop_set_irled(0);
! 568: #endif
! 569: break;
! 570: #endif
! 571: }
! 572: }
! 573:
! 574: void
! 575: com_raisedtr(void *arg)
! 576: {
! 577: struct com_softc *sc = arg;
! 578:
! 579: SET(sc->sc_mcr, MCR_DTR | MCR_RTS);
! 580: bus_space_write_1(sc->sc_iot, sc->sc_ioh, com_mcr, sc->sc_mcr);
! 581: }
! 582:
! 583: int
! 584: comread(dev_t dev, struct uio *uio, int flag)
! 585: {
! 586: struct com_softc *sc = com_cd.cd_devs[DEVUNIT(dev)];
! 587: struct tty *tp = sc->sc_tty;
! 588:
! 589: return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
! 590: }
! 591:
! 592: int
! 593: comwrite(dev_t dev, struct uio *uio, int flag)
! 594: {
! 595: struct com_softc *sc = com_cd.cd_devs[DEVUNIT(dev)];
! 596: struct tty *tp = sc->sc_tty;
! 597:
! 598: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
! 599: }
! 600:
! 601: struct tty *
! 602: comtty(dev_t dev)
! 603: {
! 604: struct com_softc *sc = com_cd.cd_devs[DEVUNIT(dev)];
! 605: struct tty *tp = sc->sc_tty;
! 606:
! 607: return (tp);
! 608: }
! 609:
! 610: static u_char
! 611: tiocm_xxx2mcr(int data)
! 612: {
! 613: u_char m = 0;
! 614:
! 615: if (ISSET(data, TIOCM_DTR))
! 616: SET(m, MCR_DTR);
! 617: if (ISSET(data, TIOCM_RTS))
! 618: SET(m, MCR_RTS);
! 619: return m;
! 620: }
! 621:
! 622: int
! 623: comioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
! 624: {
! 625: int unit = DEVUNIT(dev);
! 626: struct com_softc *sc = com_cd.cd_devs[unit];
! 627: struct tty *tp = sc->sc_tty;
! 628: bus_space_tag_t iot = sc->sc_iot;
! 629: bus_space_handle_t ioh = sc->sc_ioh;
! 630: int error;
! 631:
! 632: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
! 633: if (error >= 0)
! 634: return error;
! 635: error = ttioctl(tp, cmd, data, flag, p);
! 636: if (error >= 0)
! 637: return error;
! 638:
! 639: switch (cmd) {
! 640: case TIOCSBRK:
! 641: SET(sc->sc_lcr, LCR_SBREAK);
! 642: bus_space_write_1(iot, ioh, com_lcr, sc->sc_lcr);
! 643: break;
! 644: case TIOCCBRK:
! 645: CLR(sc->sc_lcr, LCR_SBREAK);
! 646: bus_space_write_1(iot, ioh, com_lcr, sc->sc_lcr);
! 647: break;
! 648: case TIOCSDTR:
! 649: SET(sc->sc_mcr, sc->sc_dtr);
! 650: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 651: break;
! 652: case TIOCCDTR:
! 653: CLR(sc->sc_mcr, sc->sc_dtr);
! 654: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 655: break;
! 656: case TIOCMSET:
! 657: CLR(sc->sc_mcr, MCR_DTR | MCR_RTS);
! 658: case TIOCMBIS:
! 659: SET(sc->sc_mcr, tiocm_xxx2mcr(*(int *)data));
! 660: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 661: break;
! 662: case TIOCMBIC:
! 663: CLR(sc->sc_mcr, tiocm_xxx2mcr(*(int *)data));
! 664: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 665: break;
! 666: case TIOCMGET: {
! 667: u_char m;
! 668: int bits = 0;
! 669:
! 670: m = sc->sc_mcr;
! 671: if (ISSET(m, MCR_DTR))
! 672: SET(bits, TIOCM_DTR);
! 673: if (ISSET(m, MCR_RTS))
! 674: SET(bits, TIOCM_RTS);
! 675: m = sc->sc_msr;
! 676: if (ISSET(m, MSR_DCD))
! 677: SET(bits, TIOCM_CD);
! 678: if (ISSET(m, MSR_CTS))
! 679: SET(bits, TIOCM_CTS);
! 680: if (ISSET(m, MSR_DSR))
! 681: SET(bits, TIOCM_DSR);
! 682: if (ISSET(m, MSR_RI | MSR_TERI))
! 683: SET(bits, TIOCM_RI);
! 684: if (bus_space_read_1(iot, ioh, com_ier))
! 685: SET(bits, TIOCM_LE);
! 686: *(int *)data = bits;
! 687: break;
! 688: }
! 689: case TIOCGFLAGS: {
! 690: int driverbits, userbits = 0;
! 691:
! 692: driverbits = sc->sc_swflags;
! 693: if (ISSET(driverbits, COM_SW_SOFTCAR))
! 694: SET(userbits, TIOCFLAG_SOFTCAR);
! 695: if (ISSET(driverbits, COM_SW_CLOCAL))
! 696: SET(userbits, TIOCFLAG_CLOCAL);
! 697: if (ISSET(driverbits, COM_SW_CRTSCTS))
! 698: SET(userbits, TIOCFLAG_CRTSCTS);
! 699: if (ISSET(driverbits, COM_SW_MDMBUF))
! 700: SET(userbits, TIOCFLAG_MDMBUF);
! 701: if (ISSET(driverbits, COM_SW_PPS))
! 702: SET(userbits, TIOCFLAG_PPS);
! 703:
! 704: *(int *)data = userbits;
! 705: break;
! 706: }
! 707: case TIOCSFLAGS: {
! 708: int userbits, driverbits = 0;
! 709:
! 710: error = suser(p, 0);
! 711: if (error != 0)
! 712: return(EPERM);
! 713:
! 714: userbits = *(int *)data;
! 715: if (ISSET(userbits, TIOCFLAG_SOFTCAR) ||
! 716: ISSET(sc->sc_hwflags, COM_HW_CONSOLE))
! 717: SET(driverbits, COM_SW_SOFTCAR);
! 718: if (ISSET(userbits, TIOCFLAG_CLOCAL))
! 719: SET(driverbits, COM_SW_CLOCAL);
! 720: if (ISSET(userbits, TIOCFLAG_CRTSCTS))
! 721: SET(driverbits, COM_SW_CRTSCTS);
! 722: if (ISSET(userbits, TIOCFLAG_MDMBUF))
! 723: SET(driverbits, COM_SW_MDMBUF);
! 724: if (ISSET(userbits, TIOCFLAG_PPS))
! 725: SET(driverbits, COM_SW_PPS);
! 726:
! 727: sc->sc_swflags = driverbits;
! 728: break;
! 729: }
! 730: default:
! 731: return ENOTTY;
! 732: }
! 733:
! 734: return 0;
! 735: }
! 736:
! 737: /* already called at spltty */
! 738: int
! 739: comparam(struct tty *tp, struct termios *t)
! 740: {
! 741: struct com_softc *sc = com_cd.cd_devs[DEVUNIT(tp->t_dev)];
! 742: bus_space_tag_t iot = sc->sc_iot;
! 743: bus_space_handle_t ioh = sc->sc_ioh;
! 744: int ospeed = comspeed(sc->sc_frequency, t->c_ospeed);
! 745: u_char lcr;
! 746: tcflag_t oldcflag;
! 747:
! 748: /* check requested parameters */
! 749: if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed))
! 750: return EINVAL;
! 751:
! 752: lcr = ISSET(sc->sc_lcr, LCR_SBREAK);
! 753:
! 754: switch (ISSET(t->c_cflag, CSIZE)) {
! 755: case CS5:
! 756: SET(lcr, LCR_5BITS);
! 757: break;
! 758: case CS6:
! 759: SET(lcr, LCR_6BITS);
! 760: break;
! 761: case CS7:
! 762: SET(lcr, LCR_7BITS);
! 763: break;
! 764: case CS8:
! 765: SET(lcr, LCR_8BITS);
! 766: break;
! 767: }
! 768: if (ISSET(t->c_cflag, PARENB)) {
! 769: SET(lcr, LCR_PENAB);
! 770: if (!ISSET(t->c_cflag, PARODD))
! 771: SET(lcr, LCR_PEVEN);
! 772: }
! 773: if (ISSET(t->c_cflag, CSTOPB))
! 774: SET(lcr, LCR_STOPB);
! 775:
! 776: sc->sc_lcr = lcr;
! 777:
! 778: if (ospeed == 0) {
! 779: CLR(sc->sc_mcr, MCR_DTR);
! 780: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 781: }
! 782:
! 783: /*
! 784: * Set the FIFO threshold based on the receive speed, if we are
! 785: * changing it.
! 786: */
! 787: if (sc->sc_initialize || (tp->t_ispeed != t->c_ispeed)) {
! 788: sc->sc_initialize = 0;
! 789:
! 790: if (ospeed != 0) {
! 791: /*
! 792: * Make sure the transmit FIFO is empty before
! 793: * proceeding. If we don't do this, some revisions
! 794: * of the UART will hang. Interestingly enough,
! 795: * even if we do this while the last character is
! 796: * still being pushed out, they don't hang. This
! 797: * seems good enough.
! 798: */
! 799: while (ISSET(tp->t_state, TS_BUSY)) {
! 800: int error;
! 801:
! 802: ++sc->sc_halt;
! 803: error = ttysleep(tp, &tp->t_outq,
! 804: TTOPRI | PCATCH, "comprm", 0);
! 805: --sc->sc_halt;
! 806: if (error) {
! 807: comstart(tp);
! 808: return (error);
! 809: }
! 810: }
! 811:
! 812: bus_space_write_1(iot, ioh, com_lcr, lcr | LCR_DLAB);
! 813: bus_space_write_1(iot, ioh, com_dlbl, ospeed);
! 814: bus_space_write_1(iot, ioh, com_dlbh, ospeed >> 8);
! 815: bus_space_write_1(iot, ioh, com_lcr, lcr);
! 816: SET(sc->sc_mcr, MCR_DTR);
! 817: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 818: } else
! 819: bus_space_write_1(iot, ioh, com_lcr, lcr);
! 820:
! 821: if (ISSET(sc->sc_hwflags, COM_HW_FIFO)) {
! 822: if (sc->sc_uarttype == COM_UART_TI16750) {
! 823: bus_space_write_1(iot, ioh, com_lcr,
! 824: lcr | LCR_DLAB);
! 825: bus_space_write_1(iot, ioh, com_fifo,
! 826: FIFO_ENABLE | FIFO_ENABLE_64BYTE |
! 827: (t->c_ispeed <= 1200 ? FIFO_TRIGGER_1 : FIFO_TRIGGER_8));
! 828: bus_space_write_1(iot, ioh, com_lcr, lcr);
! 829: } else
! 830: bus_space_write_1(iot, ioh, com_fifo,
! 831: FIFO_ENABLE |
! 832: (t->c_ispeed <= 1200 ? FIFO_TRIGGER_1 : FIFO_TRIGGER_8));
! 833: }
! 834: } else
! 835: bus_space_write_1(iot, ioh, com_lcr, lcr);
! 836:
! 837: /* When not using CRTSCTS, RTS follows DTR. */
! 838: if (!ISSET(t->c_cflag, CRTSCTS)) {
! 839: if (ISSET(sc->sc_mcr, MCR_DTR)) {
! 840: if (!ISSET(sc->sc_mcr, MCR_RTS)) {
! 841: SET(sc->sc_mcr, MCR_RTS);
! 842: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 843: }
! 844: } else {
! 845: if (ISSET(sc->sc_mcr, MCR_RTS)) {
! 846: CLR(sc->sc_mcr, MCR_RTS);
! 847: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 848: }
! 849: }
! 850: sc->sc_dtr = MCR_DTR | MCR_RTS;
! 851: } else
! 852: sc->sc_dtr = MCR_DTR;
! 853:
! 854: /* and copy to tty */
! 855: tp->t_ispeed = t->c_ispeed;
! 856: tp->t_ospeed = t->c_ospeed;
! 857: oldcflag = tp->t_cflag;
! 858: tp->t_cflag = t->c_cflag;
! 859:
! 860: /*
! 861: * If DCD is off and MDMBUF is changed, ask the tty layer if we should
! 862: * stop the device.
! 863: */
! 864: if (!ISSET(sc->sc_msr, MSR_DCD) &&
! 865: !ISSET(sc->sc_swflags, COM_SW_SOFTCAR) &&
! 866: ISSET(oldcflag, MDMBUF) != ISSET(tp->t_cflag, MDMBUF) &&
! 867: (*linesw[tp->t_line].l_modem)(tp, 0) == 0) {
! 868: CLR(sc->sc_mcr, sc->sc_dtr);
! 869: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 870: }
! 871:
! 872: /* Just to be sure... */
! 873: comstart(tp);
! 874: return 0;
! 875: }
! 876:
! 877: void
! 878: comstart(struct tty *tp)
! 879: {
! 880: struct com_softc *sc = com_cd.cd_devs[DEVUNIT(tp->t_dev)];
! 881: bus_space_tag_t iot = sc->sc_iot;
! 882: bus_space_handle_t ioh = sc->sc_ioh;
! 883: int s;
! 884:
! 885: s = spltty();
! 886: if (ISSET(tp->t_state, TS_BUSY))
! 887: goto out;
! 888: if (ISSET(tp->t_state, TS_TIMEOUT | TS_TTSTOP) || sc->sc_halt > 0)
! 889: goto stopped;
! 890: if (ISSET(tp->t_cflag, CRTSCTS) && !ISSET(sc->sc_msr, MSR_CTS))
! 891: goto stopped;
! 892: if (tp->t_outq.c_cc <= tp->t_lowat) {
! 893: if (ISSET(tp->t_state, TS_ASLEEP)) {
! 894: CLR(tp->t_state, TS_ASLEEP);
! 895: wakeup(&tp->t_outq);
! 896: }
! 897: if (tp->t_outq.c_cc == 0)
! 898: goto stopped;
! 899: selwakeup(&tp->t_wsel);
! 900: }
! 901: SET(tp->t_state, TS_BUSY);
! 902:
! 903: #ifdef COM_PXA2X0
! 904: /* Enable transmitter slow infrared mode. */
! 905: if (sc->sc_uarttype == COM_UART_PXA2X0 &&
! 906: ISSET(sc->sc_hwflags, COM_HW_SIR))
! 907: bus_space_write_1(iot, ioh, com_isr, ISR_SEND);
! 908: #endif
! 909:
! 910: /* Enable transmit completion interrupts. */
! 911: if (!ISSET(sc->sc_ier, IER_ETXRDY)) {
! 912: SET(sc->sc_ier, IER_ETXRDY);
! 913: bus_space_write_1(iot, ioh, com_ier, sc->sc_ier);
! 914: }
! 915:
! 916: if (ISSET(sc->sc_hwflags, COM_HW_FIFO)) {
! 917: u_char buffer[64]; /* XXX: largest fifo */
! 918:
! 919: int n = q_to_b(&tp->t_outq, buffer, sc->sc_fifolen);
! 920: int i;
! 921:
! 922: for (i = 0; i < n; i++) {
! 923: bus_space_write_1(iot, ioh, com_data, buffer[i]);
! 924: }
! 925: } else if (tp->t_outq.c_cc != 0)
! 926: bus_space_write_1(iot, ioh, com_data, getc(&tp->t_outq));
! 927: out:
! 928: splx(s);
! 929: return;
! 930: stopped:
! 931: if (ISSET(sc->sc_ier, IER_ETXRDY)) {
! 932: CLR(sc->sc_ier, IER_ETXRDY);
! 933: bus_space_write_1(iot, ioh, com_ier, sc->sc_ier);
! 934: #ifdef COM_PXA2X0
! 935: if (sc->sc_uarttype == COM_UART_PXA2X0 &&
! 936: ISSET(sc->sc_hwflags, COM_HW_SIR)) {
! 937: int timo;
! 938:
! 939: /* Wait for empty transmit shift register. */
! 940: timo = 20000;
! 941: while (!ISSET(bus_space_read_1(iot, ioh, com_lsr),
! 942: LSR_TSRE) && --timo)
! 943: delay(1);
! 944:
! 945: /* Enable receiver slow infrared mode. */
! 946: bus_space_write_1(iot, ioh, com_isr, ISR_RECV);
! 947: }
! 948: #endif
! 949: }
! 950: splx(s);
! 951: }
! 952:
! 953: /*
! 954: * Stop output on a line.
! 955: */
! 956: int
! 957: comstop(struct tty *tp, int flag)
! 958: {
! 959: int s;
! 960:
! 961: s = spltty();
! 962: if (ISSET(tp->t_state, TS_BUSY))
! 963: if (!ISSET(tp->t_state, TS_TTSTOP))
! 964: SET(tp->t_state, TS_FLUSH);
! 965: splx(s);
! 966: return 0;
! 967: }
! 968:
! 969: void
! 970: comdiag(void *arg)
! 971: {
! 972: struct com_softc *sc = arg;
! 973: int overflows, floods;
! 974: int s;
! 975:
! 976: s = spltty();
! 977: sc->sc_errors = 0;
! 978: overflows = sc->sc_overflows;
! 979: sc->sc_overflows = 0;
! 980: floods = sc->sc_floods;
! 981: sc->sc_floods = 0;
! 982: splx(s);
! 983: log(LOG_WARNING, "%s: %d silo overflow%s, %d ibuf overflow%s\n",
! 984: sc->sc_dev.dv_xname,
! 985: overflows, overflows == 1 ? "" : "s",
! 986: floods, floods == 1 ? "" : "s");
! 987: }
! 988:
! 989: void
! 990: comsoft(void *arg)
! 991: {
! 992: struct com_softc *sc = (struct com_softc *)arg;
! 993: struct tty *tp;
! 994: u_char *ibufp;
! 995: u_char *ibufend;
! 996: int c;
! 997: int s;
! 998: static int lsrmap[8] = {
! 999: 0, TTY_PE,
! 1000: TTY_FE, TTY_PE|TTY_FE,
! 1001: TTY_FE, TTY_PE|TTY_FE,
! 1002: TTY_FE, TTY_PE|TTY_FE
! 1003: };
! 1004:
! 1005: if (sc == NULL || sc->sc_ibufp == sc->sc_ibuf)
! 1006: goto out;
! 1007:
! 1008: tp = sc->sc_tty;
! 1009:
! 1010: s = spltty();
! 1011:
! 1012: ibufp = sc->sc_ibuf;
! 1013: ibufend = sc->sc_ibufp;
! 1014:
! 1015: if (ibufp == ibufend) {
! 1016: splx(s);
! 1017: goto out;
! 1018: }
! 1019:
! 1020: sc->sc_ibufp = sc->sc_ibuf = (ibufp == sc->sc_ibufs[0]) ?
! 1021: sc->sc_ibufs[1] : sc->sc_ibufs[0];
! 1022: sc->sc_ibufhigh = sc->sc_ibuf + COM_IHIGHWATER;
! 1023: sc->sc_ibufend = sc->sc_ibuf + COM_IBUFSIZE;
! 1024:
! 1025: if (tp == NULL || !ISSET(tp->t_state, TS_ISOPEN)) {
! 1026: splx(s);
! 1027: goto out;
! 1028: }
! 1029:
! 1030: if (ISSET(tp->t_cflag, CRTSCTS) &&
! 1031: !ISSET(sc->sc_mcr, MCR_RTS)) {
! 1032: /* XXX */
! 1033: SET(sc->sc_mcr, MCR_RTS);
! 1034: bus_space_write_1(sc->sc_iot, sc->sc_ioh, com_mcr,
! 1035: sc->sc_mcr);
! 1036: }
! 1037:
! 1038: splx(s);
! 1039:
! 1040: while (ibufp < ibufend) {
! 1041: c = *ibufp++;
! 1042: if (ISSET(*ibufp, LSR_OE)) {
! 1043: sc->sc_overflows++;
! 1044: if (sc->sc_errors++ == 0)
! 1045: timeout_add(&sc->sc_diag_tmo, 60 * hz);
! 1046: }
! 1047: /* This is ugly, but fast. */
! 1048: c |= lsrmap[(*ibufp++ & (LSR_BI|LSR_FE|LSR_PE)) >> 2];
! 1049: (*linesw[tp->t_line].l_rint)(c, tp);
! 1050: }
! 1051:
! 1052: out:
! 1053: #ifndef __HAVE_GENERIC_SOFT_INTERRUPTS
! 1054: timeout_add(&sc->sc_comsoft_tmo, 1);
! 1055: #else
! 1056: ;
! 1057: #endif
! 1058: }
! 1059:
! 1060: #ifdef KGDB
! 1061:
! 1062: /*
! 1063: * If a line break is set, or data matches one of the characters
! 1064: * gdb uses to signal a connection, then start up kgdb. Just gobble
! 1065: * any other data. Done in a stand alone function because comintr
! 1066: * does tty stuff and we don't have one.
! 1067: */
! 1068:
! 1069: int
! 1070: kgdbintr(void *arg)
! 1071: {
! 1072: struct com_softc *sc = arg;
! 1073: bus_space_tag_t iot = sc->sc_iot;
! 1074: bus_space_handle_t ioh = sc->sc_ioh;
! 1075: u_char lsr, data, msr, delta;
! 1076:
! 1077: if (!ISSET(sc->sc_hwflags, COM_HW_KGDB))
! 1078: return(0);
! 1079:
! 1080: for (;;) {
! 1081: lsr = bus_space_read_1(iot, ioh, com_lsr);
! 1082: if (ISSET(lsr, LSR_RXRDY)) {
! 1083: do {
! 1084: data = bus_space_read_1(iot, ioh, com_data);
! 1085: if (data == 3 || data == '$' || data == '+' ||
! 1086: ISSET(lsr, LSR_BI)) {
! 1087: kgdb_connect(1);
! 1088: data = 0;
! 1089: }
! 1090: lsr = bus_space_read_1(iot, ioh, com_lsr);
! 1091: } while (ISSET(lsr, LSR_RXRDY));
! 1092:
! 1093: }
! 1094: if (ISSET(lsr, LSR_BI|LSR_FE|LSR_PE|LSR_OE))
! 1095: printf("weird lsr %02x\n", lsr);
! 1096:
! 1097: msr = bus_space_read_1(iot, ioh, com_msr);
! 1098:
! 1099: if (msr != sc->sc_msr) {
! 1100: delta = msr ^ sc->sc_msr;
! 1101: sc->sc_msr = msr;
! 1102: if (ISSET(delta, MSR_DCD)) {
! 1103: if (!ISSET(sc->sc_swflags, COM_SW_SOFTCAR)) {
! 1104: CLR(sc->sc_mcr, sc->sc_dtr);
! 1105: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 1106: }
! 1107: }
! 1108: }
! 1109: if (ISSET(bus_space_read_1(iot, ioh, com_iir), IIR_NOPEND))
! 1110: return (1);
! 1111: }
! 1112: }
! 1113: #endif /* KGDB */
! 1114:
! 1115: int
! 1116: comintr(void *arg)
! 1117: {
! 1118: struct com_softc *sc = arg;
! 1119: bus_space_tag_t iot = sc->sc_iot;
! 1120: bus_space_handle_t ioh = sc->sc_ioh;
! 1121: struct tty *tp;
! 1122: u_char lsr, data, msr, delta;
! 1123:
! 1124: if (!sc->sc_tty)
! 1125: return (0); /* can't do squat. */
! 1126:
! 1127: if (ISSET(bus_space_read_1(iot, ioh, com_iir), IIR_NOPEND))
! 1128: return (0);
! 1129:
! 1130: tp = sc->sc_tty;
! 1131:
! 1132: for (;;) {
! 1133: lsr = bus_space_read_1(iot, ioh, com_lsr);
! 1134:
! 1135: if (ISSET(lsr, LSR_RXRDY)) {
! 1136: u_char *p = sc->sc_ibufp;
! 1137:
! 1138: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
! 1139: softintr_schedule(sc->sc_si);
! 1140: #endif
! 1141: do {
! 1142: data = bus_space_read_1(iot, ioh, com_data);
! 1143: if (ISSET(lsr, LSR_BI)) {
! 1144: #if defined(COM_CONSOLE) && defined(DDB)
! 1145: if (ISSET(sc->sc_hwflags,
! 1146: COM_HW_CONSOLE)) {
! 1147: if (db_console)
! 1148: Debugger();
! 1149: goto next;
! 1150: }
! 1151: #endif
! 1152: data = 0;
! 1153: }
! 1154: if (p >= sc->sc_ibufend) {
! 1155: sc->sc_floods++;
! 1156: if (sc->sc_errors++ == 0)
! 1157: timeout_add(&sc->sc_diag_tmo, 60 * hz);
! 1158: } else {
! 1159: *p++ = data;
! 1160: *p++ = lsr;
! 1161: if (p == sc->sc_ibufhigh &&
! 1162: ISSET(tp->t_cflag, CRTSCTS)) {
! 1163: /* XXX */
! 1164: CLR(sc->sc_mcr, MCR_RTS);
! 1165: bus_space_write_1(iot, ioh, com_mcr,
! 1166: sc->sc_mcr);
! 1167: }
! 1168: }
! 1169: #if defined(COM_CONSOLE) && defined(DDB)
! 1170: next:
! 1171: #endif
! 1172: lsr = bus_space_read_1(iot, ioh, com_lsr);
! 1173: } while (ISSET(lsr, LSR_RXRDY));
! 1174:
! 1175: sc->sc_ibufp = p;
! 1176: }
! 1177: msr = bus_space_read_1(iot, ioh, com_msr);
! 1178:
! 1179: if (msr != sc->sc_msr) {
! 1180: delta = msr ^ sc->sc_msr;
! 1181:
! 1182: ttytstamp(tp, sc->sc_msr & MSR_CTS, msr & MSR_CTS,
! 1183: sc->sc_msr & MSR_DCD, msr & MSR_DCD);
! 1184:
! 1185: sc->sc_msr = msr;
! 1186: if (ISSET(delta, MSR_DCD)) {
! 1187: if (!ISSET(sc->sc_swflags, COM_SW_SOFTCAR) &&
! 1188: (*linesw[tp->t_line].l_modem)(tp, ISSET(msr, MSR_DCD)) == 0) {
! 1189: CLR(sc->sc_mcr, sc->sc_dtr);
! 1190: bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
! 1191: }
! 1192: }
! 1193: if (ISSET(delta & msr, MSR_CTS) &&
! 1194: ISSET(tp->t_cflag, CRTSCTS)) {
! 1195: /* the line is up and we want to do rts/cts flow control */
! 1196: (*linesw[tp->t_line].l_start)(tp);
! 1197: }
! 1198: }
! 1199:
! 1200: if (ISSET(lsr, LSR_TXRDY) && ISSET(tp->t_state, TS_BUSY)) {
! 1201: CLR(tp->t_state, TS_BUSY | TS_FLUSH);
! 1202: if (sc->sc_halt > 0)
! 1203: wakeup(&tp->t_outq);
! 1204: (*linesw[tp->t_line].l_start)(tp);
! 1205: }
! 1206:
! 1207: #ifdef COM_PXA2X0
! 1208: if (sc->sc_uarttype == COM_UART_PXA2X0 &&
! 1209: ISSET(sc->sc_hwflags, COM_HW_SIR) &&
! 1210: ISSET(lsr, LSR_TXRDY) && ISSET(lsr, LSR_TSRE))
! 1211: bus_space_write_1(iot, ioh, com_isr, ISR_RECV);
! 1212: #endif
! 1213:
! 1214: if (ISSET(bus_space_read_1(iot, ioh, com_iir), IIR_NOPEND))
! 1215: return (1);
! 1216: }
! 1217: }
! 1218:
! 1219: /*
! 1220: * Following are all routines needed for COM to act as console
! 1221: */
! 1222:
! 1223: #if defined(__sgi__)
! 1224: #undef CONADDR
! 1225: #undef COM_FREQ
! 1226: #include <machine/autoconf.h>
! 1227: #endif
! 1228:
! 1229: /*
! 1230: * The following functions are polled getc and putc routines, shared
! 1231: * by the console and kgdb glue.
! 1232: */
! 1233:
! 1234: int
! 1235: com_common_getc(bus_space_tag_t iot, bus_space_handle_t ioh)
! 1236: {
! 1237: int s = splhigh();
! 1238: u_char stat, c;
! 1239:
! 1240: #ifdef COM_PXA2X0
! 1241: if (com_is_console(iot, comsiraddr))
! 1242: bus_space_write_1(iot, ioh, com_isr, ISR_RECV);
! 1243: #endif
! 1244:
! 1245: /* block until a character becomes available */
! 1246: while (!ISSET(stat = bus_space_read_1(iot, ioh, com_lsr), LSR_RXRDY))
! 1247: continue;
! 1248:
! 1249: c = bus_space_read_1(iot, ioh, com_data);
! 1250: /* clear any interrupts generated by this transmission */
! 1251: stat = bus_space_read_1(iot, ioh, com_iir);
! 1252: splx(s);
! 1253: return (c);
! 1254: }
! 1255:
! 1256: void
! 1257: com_common_putc(bus_space_tag_t iot, bus_space_handle_t ioh, int c)
! 1258: {
! 1259: int s = spltty();
! 1260: int timo;
! 1261:
! 1262: printf("com_common_putc: enter\n");
! 1263:
! 1264: /* wait for any pending transmission to finish */
! 1265: timo = 2000;
! 1266: while (!ISSET(bus_space_read_1(iot, ioh, com_lsr), LSR_TXRDY) && --timo)
! 1267: delay(1);
! 1268:
! 1269: #ifdef COM_PXA2X0
! 1270: if (com_is_console(iot, comsiraddr))
! 1271: bus_space_write_1(iot, ioh, com_isr, ISR_SEND);
! 1272: #endif
! 1273: bus_space_write_1(iot, ioh, com_data, (u_int8_t)(c & 0xff));
! 1274: bus_space_barrier(iot, ioh, 0, COM_NPORTS,
! 1275: (BUS_SPACE_BARRIER_READ|BUS_SPACE_BARRIER_WRITE));
! 1276:
! 1277: printf("com_common_putc: wait for TXRDY\n");
! 1278: /* wait for this transmission to complete */
! 1279: timo = 2000;
! 1280: while (!ISSET(bus_space_read_1(iot, ioh, com_lsr), LSR_TXRDY) && --timo)
! 1281: delay(1);
! 1282:
! 1283: #ifdef COM_PXA2X0
! 1284: if (com_is_console(iot, comsiraddr)) {
! 1285: /* wait for transmit shift register to become empty */
! 1286: timo = 20000;
! 1287: while (!ISSET(bus_space_read_1(iot, ioh, com_lsr), LSR_TSRE)
! 1288: && --timo)
! 1289: delay(1);
! 1290:
! 1291: bus_space_write_1(iot, ioh, com_isr, ISR_RECV);
! 1292: }
! 1293: #endif
! 1294:
! 1295: splx(s);
! 1296: }
! 1297:
! 1298: void
! 1299: cominit(bus_space_tag_t iot, bus_space_handle_t ioh, int rate, int frequency)
! 1300: {
! 1301: int s = splhigh();
! 1302: u_char stat;
! 1303:
! 1304: bus_space_write_1(iot, ioh, com_lcr, LCR_DLAB);
! 1305: rate = comspeed(frequency, rate); /* XXX not comdefaultrate? */
! 1306: bus_space_write_1(iot, ioh, com_dlbl, rate);
! 1307: bus_space_write_1(iot, ioh, com_dlbh, rate >> 8);
! 1308: bus_space_write_1(iot, ioh, com_lcr, LCR_8BITS);
! 1309: bus_space_write_1(iot, ioh, com_mcr, MCR_DTR | MCR_RTS);
! 1310: #ifdef COM_PXA2X0
! 1311: /* XXX */
! 1312: bus_space_write_1(iot, ioh, com_ier, IER_EUART); /* Make sure they are off */
! 1313: #else
! 1314: bus_space_write_1(iot, ioh, com_ier, 0); /* Make sure they are off */
! 1315: #endif
! 1316: bus_space_write_1(iot, ioh, com_fifo,
! 1317: FIFO_ENABLE | FIFO_RCV_RST | FIFO_XMT_RST | FIFO_TRIGGER_1);
! 1318: stat = bus_space_read_1(iot, ioh, com_iir);
! 1319: splx(s);
! 1320: }
! 1321:
! 1322: #ifdef COM_CONSOLE
! 1323: void
! 1324: comcnprobe(struct consdev *cp)
! 1325: {
! 1326: /* XXX NEEDS TO BE FIXED XXX */
! 1327: #ifdef MD_ISA_IOT
! 1328: bus_space_tag_t iot = MD_ISA_IOT;
! 1329: #elif defined(__sgi__)
! 1330: bus_space_tag_t iot = sys_config.cons_iot;
! 1331: #else
! 1332: bus_space_tag_t iot = 0;
! 1333: #endif
! 1334: bus_space_handle_t ioh;
! 1335: int found;
! 1336:
! 1337: if (CONADDR == 0)
! 1338: return;
! 1339:
! 1340: comconsiot = iot;
! 1341: if (bus_space_map(iot, CONADDR, COM_NPORTS, 0, &ioh))
! 1342: return;
! 1343: found = comprobe1(iot, ioh);
! 1344: bus_space_unmap(iot, ioh, COM_NPORTS);
! 1345: if (!found)
! 1346: return;
! 1347:
! 1348: /* locate the major number */
! 1349: for (commajor = 0; commajor < nchrdev; commajor++)
! 1350: if (cdevsw[commajor].d_open == comopen)
! 1351: break;
! 1352:
! 1353: /* initialize required fields */
! 1354: cp->cn_dev = makedev(commajor, CONUNIT);
! 1355: #if defined(COMCONSOLE) || defined(PCCOMCONSOLE) || !defined(__amd64__)
! 1356: cp->cn_pri = CN_REMOTE;
! 1357: #else
! 1358: cp->cn_pri = CN_NORMAL;
! 1359: #endif
! 1360: }
! 1361:
! 1362: void
! 1363: comcninit(struct consdev *cp)
! 1364: {
! 1365: comconsaddr = CONADDR;
! 1366:
! 1367: if (bus_space_map(comconsiot, comconsaddr, COM_NPORTS, 0, &comconsioh))
! 1368: panic("comcninit: mapping failed");
! 1369:
! 1370: if (comconsfreq == 0)
! 1371: comconsfreq = COM_FREQ;
! 1372:
! 1373: cominit(comconsiot, comconsioh, comdefaultrate, comconsfreq);
! 1374: comconsinit = 0;
! 1375: }
! 1376:
! 1377:
! 1378: int
! 1379: comcnattach(bus_space_tag_t iot, bus_addr_t iobase, int rate, int frequency, tcflag_t cflag)
! 1380: {
! 1381: static struct consdev comcons = {
! 1382: NULL, NULL, comcngetc, comcnputc, comcnpollc, NULL,
! 1383: NODEV, CN_NORMAL
! 1384: };
! 1385:
! 1386: #ifndef __sparc64__
! 1387: if (bus_space_map(iot, iobase, COM_NPORTS, 0, &comconsioh))
! 1388: return ENOMEM;
! 1389: #endif
! 1390:
! 1391: cominit(iot, comconsioh, rate, frequency);
! 1392:
! 1393: cn_tab = &comcons;
! 1394:
! 1395: comconsiot = iot;
! 1396: comconsaddr = iobase;
! 1397: comconscflag = cflag;
! 1398: comconsfreq = frequency;
! 1399:
! 1400: return (0);
! 1401: }
! 1402:
! 1403: int
! 1404: comcngetc(dev_t dev)
! 1405: {
! 1406: return (com_common_getc(comconsiot, comconsioh));
! 1407: }
! 1408:
! 1409: /*
! 1410: * Console kernel output character routine.
! 1411: */
! 1412: void
! 1413: comcnputc(dev_t dev, int c)
! 1414: {
! 1415: com_common_putc(comconsiot, comconsioh, c);
! 1416: }
! 1417:
! 1418: void
! 1419: comcnpollc(dev_t dev, int on)
! 1420: {
! 1421:
! 1422: }
! 1423: #endif /* COM_CONSOLE */
! 1424:
! 1425: #ifdef KGDB
! 1426: int
! 1427: com_kgdb_attach(bus_space_tag_t iot, bus_addr_t iobase, int rate,
! 1428: int frequency,tcflag_t cflag)
! 1429: bus_space_tag_t iot;
! 1430: bus_addr_t iobase;
! 1431: int rate, frequency;
! 1432: tcflag_t cflag;
! 1433: {
! 1434: #ifdef COM_CONSOLE
! 1435: if (iot == comconsiot && iobase == comconsaddr) {
! 1436: return (EBUSY); /* cannot share with console */
! 1437: }
! 1438: #endif
! 1439:
! 1440: com_kgdb_iot = iot;
! 1441: com_kgdb_addr = iobase;
! 1442:
! 1443: if (bus_space_map(com_kgdb_iot, com_kgdb_addr, COM_NPORTS, 0,
! 1444: &com_kgdb_ioh))
! 1445: panic("com_kgdb_attach: mapping failed");
! 1446:
! 1447: /* XXX We currently don't respect KGDBMODE? */
! 1448: cominit(com_kgdb_iot, com_kgdb_ioh, rate, frequency);
! 1449:
! 1450: kgdb_attach(com_kgdb_getc, com_kgdb_putc, NULL);
! 1451: kgdb_dev = 123; /* unneeded, only to satisfy some tests */
! 1452:
! 1453: return (0);
! 1454: }
! 1455:
! 1456: /* ARGSUSED */
! 1457: int
! 1458: com_kgdb_getc(void *arg)
! 1459: {
! 1460:
! 1461: return (com_common_getc(com_kgdb_iot, com_kgdb_ioh));
! 1462: }
! 1463:
! 1464: /* ARGSUSED */
! 1465: void
! 1466: com_kgdb_putc(void *arg, int c)
! 1467: {
! 1468:
! 1469: return (com_common_putc(com_kgdb_iot, com_kgdb_ioh, c));
! 1470: }
! 1471: #endif /* KGDB */
! 1472:
! 1473: #ifdef COM_PXA2X0
! 1474: int
! 1475: com_is_console(bus_space_tag_t iot, bus_addr_t iobase)
! 1476: {
! 1477:
! 1478: if (comconsiot == iot && comconsaddr == iobase)
! 1479: return (1);
! 1480: #ifdef KGDB
! 1481: else if (com_kgdb_iot == iot && com_kgdb_addr == iobase)
! 1482: return (1);
! 1483: #endif
! 1484: return (0);
! 1485: }
! 1486: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to com.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic