Annotation of sys/arch/sparc64/dev/sab.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: sab.c,v 1.19 2006/05/28 22:41:44 jason Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2001 Jason L. Wright (jason@thought.net)
! 5: * 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 ``AS IS'' AND ANY EXPRESS OR
! 17: * 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 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)
! 23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 24: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! 25: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 26: * POSSIBILITY OF SUCH DAMAGE.
! 27: *
! 28: * Effort sponsored in part by the Defense Advanced Research Projects
! 29: * Agency (DARPA) and Air Force Research Laboratory, Air Force
! 30: * Materiel Command, USAF, under agreement number F30602-01-2-0537.
! 31: *
! 32: */
! 33:
! 34: /*
! 35: * SAB82532 Dual UART driver
! 36: */
! 37:
! 38: #include <sys/types.h>
! 39: #include <sys/param.h>
! 40: #include <sys/systm.h>
! 41: #include <sys/device.h>
! 42: #include <sys/conf.h>
! 43: #include <sys/file.h>
! 44: #include <sys/ioctl.h>
! 45: #include <sys/kernel.h>
! 46: #include <sys/proc.h>
! 47: #include <sys/tty.h>
! 48: #include <sys/time.h>
! 49: #include <sys/syslog.h>
! 50:
! 51: #include <machine/autoconf.h>
! 52: #include <machine/openfirm.h>
! 53: #include <machine/bsd_openprom.h>
! 54: #include <machine/conf.h>
! 55: #include <machine/cpu.h>
! 56: #include <machine/eeprom.h>
! 57: #include <machine/psl.h>
! 58:
! 59: #include <dev/cons.h>
! 60: #include <ddb/db_output.h>
! 61:
! 62: #include <sparc64/dev/ebusreg.h>
! 63: #include <sparc64/dev/ebusvar.h>
! 64: #include <sparc64/dev/cons.h>
! 65: #include <sparc64/dev/sab82532reg.h>
! 66:
! 67: #define SAB_CARD(x) ((minor(x) >> 6) & 3)
! 68: #define SAB_PORT(x) (minor(x) & 7)
! 69: #define SAB_DIALOUT(x) (minor(x) & 0x10)
! 70: #define SABTTY_RBUF_SIZE 1024 /* must be divisible by 2 */
! 71:
! 72: struct sab_softc {
! 73: struct device sc_dv;
! 74: struct intrhand * sc_ih;
! 75: bus_space_tag_t sc_bt;
! 76: bus_space_handle_t sc_bh;
! 77: struct sabtty_softc * sc_child[SAB_NCHAN];
! 78: u_int sc_nchild;
! 79: void * sc_softintr;
! 80: int sc_node;
! 81: };
! 82:
! 83: struct sabtty_attach_args {
! 84: u_int sbt_portno;
! 85: };
! 86:
! 87: struct sabtty_softc {
! 88: struct device sc_dv;
! 89: struct sab_softc * sc_parent;
! 90: bus_space_tag_t sc_bt;
! 91: bus_space_handle_t sc_bh;
! 92: struct tty * sc_tty;
! 93: u_int sc_portno;
! 94: u_int8_t sc_pvr_dtr, sc_pvr_dsr;
! 95: u_int8_t sc_imr0, sc_imr1;
! 96: int sc_openflags;
! 97: u_char * sc_txp;
! 98: int sc_txc;
! 99: int sc_flags;
! 100: #define SABTTYF_STOP 0x01
! 101: #define SABTTYF_DONE 0x02
! 102: #define SABTTYF_RINGOVERFLOW 0x04
! 103: #define SABTTYF_CDCHG 0x08
! 104: #define SABTTYF_CONS_IN 0x10
! 105: #define SABTTYF_CONS_OUT 0x20
! 106: #define SABTTYF_TXDRAIN 0x40
! 107: #define SABTTYF_DONTDDB 0x80
! 108: u_int8_t sc_rbuf[SABTTY_RBUF_SIZE];
! 109: u_int8_t *sc_rend, *sc_rput, *sc_rget;
! 110: u_int8_t sc_polling, sc_pollrfc;
! 111: };
! 112:
! 113: struct sabtty_softc *sabtty_cons_input;
! 114: struct sabtty_softc *sabtty_cons_output;
! 115:
! 116: #define SAB_READ(sc,r) \
! 117: bus_space_read_1((sc)->sc_bt, (sc)->sc_bh, (r))
! 118: #define SAB_WRITE(sc,r,v) \
! 119: bus_space_write_1((sc)->sc_bt, (sc)->sc_bh, (r), (v))
! 120: #define SAB_WRITE_BLOCK(sc,r,p,c) \
! 121: bus_space_write_region_1((sc)->sc_bt, (sc)->sc_bh, (r), (p), (c))
! 122:
! 123: int sab_match(struct device *, void *, void *);
! 124: void sab_attach(struct device *, struct device *, void *);
! 125: int sab_print(void *, const char *);
! 126: int sab_intr(void *);
! 127: void sab_softintr(void *);
! 128: void sab_cnputc(dev_t, int);
! 129: int sab_cngetc(dev_t);
! 130: void sab_cnpollc(dev_t, int);
! 131:
! 132: int sabtty_match(struct device *, void *, void *);
! 133: void sabtty_attach(struct device *, struct device *, void *);
! 134: void sabtty_start(struct tty *);
! 135: int sabtty_param(struct tty *, struct termios *);
! 136: int sabtty_intr(struct sabtty_softc *, int *);
! 137: void sabtty_softintr(struct sabtty_softc *);
! 138: int sabtty_mdmctrl(struct sabtty_softc *, int, int);
! 139: int sabtty_cec_wait(struct sabtty_softc *);
! 140: int sabtty_tec_wait(struct sabtty_softc *);
! 141: void sabtty_reset(struct sabtty_softc *);
! 142: void sabtty_flush(struct sabtty_softc *);
! 143: int sabtty_speed(int);
! 144: void sabtty_console_flags(struct sabtty_softc *);
! 145: void sabtty_cnpollc(struct sabtty_softc *, int);
! 146: void sabtty_shutdown(void *);
! 147: int sabttyparam(struct sabtty_softc *, struct tty *, struct termios *);
! 148:
! 149: int sabttyopen(dev_t, int, int, struct proc *);
! 150: int sabttyclose(dev_t, int, int, struct proc *);
! 151: int sabttyread(dev_t, struct uio *, int);
! 152: int sabttywrite(dev_t, struct uio *, int);
! 153: int sabttyioctl(dev_t, u_long, caddr_t, int, struct proc *);
! 154: int sabttystop(struct tty *, int);
! 155: struct tty *sabttytty(dev_t);
! 156: void sabtty_cnputc(struct sabtty_softc *, int);
! 157: int sabtty_cngetc(struct sabtty_softc *);
! 158: void sabtty_abort(struct sabtty_softc *);
! 159:
! 160: struct cfattach sab_ca = {
! 161: sizeof(struct sab_softc), sab_match, sab_attach
! 162: };
! 163:
! 164: struct cfdriver sab_cd = {
! 165: NULL, "sab", DV_DULL
! 166: };
! 167:
! 168: struct cfattach sabtty_ca = {
! 169: sizeof(struct sabtty_softc), sabtty_match, sabtty_attach
! 170: };
! 171:
! 172: struct cfdriver sabtty_cd = {
! 173: NULL, "sabtty", DV_TTY
! 174: };
! 175:
! 176: struct sabtty_rate {
! 177: int baud;
! 178: int n, m;
! 179: };
! 180:
! 181: struct sabtty_rate sabtty_baudtable[] = {
! 182: { 50, 35, 10 },
! 183: { 75, 47, 9 },
! 184: { 110, 32, 9 },
! 185: { 134, 53, 8 },
! 186: { 150, 47, 8 },
! 187: { 200, 35, 8 },
! 188: { 300, 47, 7 },
! 189: { 600, 47, 6 },
! 190: { 1200, 47, 5 },
! 191: { 1800, 31, 5 },
! 192: { 2400, 47, 4 },
! 193: { 4800, 47, 3 },
! 194: { 9600, 47, 2 },
! 195: { 19200, 47, 1 },
! 196: { 38400, 23, 1 },
! 197: { 57600, 15, 1 },
! 198: { 115200, 7, 1 },
! 199: { 230400, 3, 1 },
! 200: { 460800, 1, 1 },
! 201: { 76800, 11, 1 },
! 202: { 153600, 5, 1 },
! 203: { 307200, 3, 1 },
! 204: { 614400, 3, 0 },
! 205: { 921600, 0, 1 },
! 206: };
! 207:
! 208: int
! 209: sab_match(parent, match, aux)
! 210: struct device *parent;
! 211: void *match, *aux;
! 212: {
! 213: struct ebus_attach_args *ea = aux;
! 214: char *compat;
! 215:
! 216: if (strcmp(ea->ea_name, "se") == 0)
! 217: return (1);
! 218: compat = getpropstring(ea->ea_node, "compatible");
! 219: if (compat != NULL && !strcmp(compat, "sab82532"))
! 220: return (1);
! 221: return (0);
! 222: }
! 223:
! 224: void
! 225: sab_attach(parent, self, aux)
! 226: struct device *parent;
! 227: struct device *self;
! 228: void *aux;
! 229: {
! 230: struct sab_softc *sc = (struct sab_softc *)self;
! 231: struct ebus_attach_args *ea = aux;
! 232: u_int8_t r;
! 233: u_int i;
! 234:
! 235: sc->sc_bt = ea->ea_memtag;
! 236: sc->sc_node = ea->ea_node;
! 237:
! 238: /* Use prom mapping, if available. */
! 239: if (ea->ea_nvaddrs) {
! 240: if (bus_space_map(sc->sc_bt, ea->ea_vaddrs[0],
! 241: 0, BUS_SPACE_MAP_PROMADDRESS, &sc->sc_bh) != 0) {
! 242: printf(": can't map register space\n");
! 243: return;
! 244: }
! 245: } else if (ebus_bus_map(sc->sc_bt, 0,
! 246: EBUS_PADDR_FROM_REG(&ea->ea_regs[0]), ea->ea_regs[0].size, 0, 0,
! 247: &sc->sc_bh) != 0) {
! 248: printf(": can't map register space\n");
! 249: return;
! 250: }
! 251:
! 252: BUS_SPACE_SET_FLAGS(sc->sc_bt, sc->sc_bh, BSHDB_NO_ACCESS);
! 253:
! 254: sc->sc_ih = bus_intr_establish(sc->sc_bt, ea->ea_intrs[0],
! 255: IPL_TTY, 0, sab_intr, sc, self->dv_xname);
! 256: if (sc->sc_ih == NULL) {
! 257: printf(": can't map interrupt\n");
! 258: return;
! 259: }
! 260:
! 261: sc->sc_softintr = softintr_establish(IPL_TTY, sab_softintr, sc);
! 262: if (sc->sc_softintr == NULL) {
! 263: printf(": can't get soft intr\n");
! 264: return;
! 265: }
! 266:
! 267: printf(": rev ");
! 268: r = SAB_READ(sc, SAB_VSTR) & SAB_VSTR_VMASK;
! 269: switch (r) {
! 270: case SAB_VSTR_V_1:
! 271: printf("1");
! 272: break;
! 273: case SAB_VSTR_V_2:
! 274: printf("2");
! 275: break;
! 276: case SAB_VSTR_V_32:
! 277: printf("3.2");
! 278: break;
! 279: default:
! 280: printf("unknown(0x%x)", r);
! 281: break;
! 282: }
! 283: printf("\n");
! 284:
! 285: /* Let current output drain */
! 286: DELAY(100000);
! 287:
! 288: /* Set all pins, except DTR pins to be inputs */
! 289: SAB_WRITE(sc, SAB_PCR, ~(SAB_PVR_DTR_A | SAB_PVR_DTR_B));
! 290: /* Disable port interrupts */
! 291: SAB_WRITE(sc, SAB_PIM, 0xff);
! 292: SAB_WRITE(sc, SAB_PVR, SAB_PVR_DTR_A | SAB_PVR_DTR_B | SAB_PVR_MAGIC);
! 293: SAB_WRITE(sc, SAB_IPC, SAB_IPC_ICPL);
! 294:
! 295: for (i = 0; i < SAB_NCHAN; i++) {
! 296: struct sabtty_attach_args sta;
! 297:
! 298: sta.sbt_portno = i;
! 299: sc->sc_child[i] = (struct sabtty_softc *)config_found_sm(self,
! 300: &sta, sab_print, sabtty_match);
! 301: if (sc->sc_child[i] != NULL)
! 302: sc->sc_nchild++;
! 303: }
! 304: }
! 305:
! 306: int
! 307: sab_print(args, name)
! 308: void *args;
! 309: const char *name;
! 310: {
! 311: struct sabtty_attach_args *sa = args;
! 312:
! 313: if (name)
! 314: printf("sabtty at %s", name);
! 315: printf(" port %d", sa->sbt_portno);
! 316: return (UNCONF);
! 317: }
! 318:
! 319: int
! 320: sab_intr(vsc)
! 321: void *vsc;
! 322: {
! 323: struct sab_softc *sc = vsc;
! 324: int r = 0, needsoft = 0;
! 325: u_int8_t gis;
! 326:
! 327: gis = SAB_READ(sc, SAB_GIS);
! 328:
! 329: /* channel A */
! 330: if ((gis & (SAB_GIS_ISA1 | SAB_GIS_ISA0)) && sc->sc_child[0] &&
! 331: sc->sc_child[0]->sc_tty)
! 332: r |= sabtty_intr(sc->sc_child[0], &needsoft);
! 333:
! 334: /* channel B */
! 335: if ((gis & (SAB_GIS_ISB1 | SAB_GIS_ISB0)) && sc->sc_child[1] &&
! 336: sc->sc_child[1]->sc_tty)
! 337: r |= sabtty_intr(sc->sc_child[1], &needsoft);
! 338:
! 339: if (needsoft)
! 340: softintr_schedule(sc->sc_softintr);
! 341:
! 342: return (r);
! 343: }
! 344:
! 345: void
! 346: sab_softintr(vsc)
! 347: void *vsc;
! 348: {
! 349: struct sab_softc *sc = vsc;
! 350:
! 351: if (sc->sc_child[0] && sc->sc_child[0]->sc_tty)
! 352: sabtty_softintr(sc->sc_child[0]);
! 353: if (sc->sc_child[1] && sc->sc_child[1]->sc_tty)
! 354: sabtty_softintr(sc->sc_child[1]);
! 355: }
! 356:
! 357: int
! 358: sabtty_match(parent, match, aux)
! 359: struct device *parent;
! 360: void *match, *aux;
! 361: {
! 362: struct sabtty_attach_args *sa = aux;
! 363:
! 364: if (sa->sbt_portno < SAB_NCHAN)
! 365: return (1);
! 366: return (0);
! 367: }
! 368:
! 369: void
! 370: sabtty_attach(parent, self, aux)
! 371: struct device *parent;
! 372: struct device *self;
! 373: void *aux;
! 374: {
! 375: struct sabtty_softc *sc = (struct sabtty_softc *)self;
! 376: struct sabtty_attach_args *sa = aux;
! 377: int r;
! 378:
! 379: sc->sc_tty = ttymalloc();
! 380: sc->sc_tty->t_oproc = sabtty_start;
! 381: sc->sc_tty->t_param = sabtty_param;
! 382:
! 383: sc->sc_parent = (struct sab_softc *)parent;
! 384: sc->sc_bt = sc->sc_parent->sc_bt;
! 385: sc->sc_portno = sa->sbt_portno;
! 386: sc->sc_rend = sc->sc_rbuf + SABTTY_RBUF_SIZE;
! 387:
! 388: switch (sa->sbt_portno) {
! 389: case 0: /* port A */
! 390: sc->sc_pvr_dtr = SAB_PVR_DTR_A;
! 391: sc->sc_pvr_dsr = SAB_PVR_DSR_A;
! 392: r = bus_space_subregion(sc->sc_bt, sc->sc_parent->sc_bh,
! 393: SAB_CHAN_A, SAB_CHANLEN, &sc->sc_bh);
! 394: break;
! 395: case 1: /* port B */
! 396: sc->sc_pvr_dtr = SAB_PVR_DTR_B;
! 397: sc->sc_pvr_dsr = SAB_PVR_DSR_B;
! 398: r = bus_space_subregion(sc->sc_bt, sc->sc_parent->sc_bh,
! 399: SAB_CHAN_B, SAB_CHANLEN, &sc->sc_bh);
! 400: break;
! 401: default:
! 402: printf(": invalid channel: %u\n", sa->sbt_portno);
! 403: return;
! 404: }
! 405: if (r != 0) {
! 406: printf(": failed to allocate register subregion\n");
! 407: return;
! 408: }
! 409:
! 410: sabtty_console_flags(sc);
! 411:
! 412: if (sc->sc_flags & (SABTTYF_CONS_IN | SABTTYF_CONS_OUT)) {
! 413: struct termios t;
! 414: char *acc;
! 415:
! 416: switch (sc->sc_flags & (SABTTYF_CONS_IN | SABTTYF_CONS_OUT)) {
! 417: case SABTTYF_CONS_IN:
! 418: acc = "input";
! 419: break;
! 420: case SABTTYF_CONS_OUT:
! 421: acc = "output";
! 422: break;
! 423: case SABTTYF_CONS_IN|SABTTYF_CONS_OUT:
! 424: default:
! 425: acc = "i/o";
! 426: break;
! 427: }
! 428:
! 429: if (sc->sc_flags & SABTTYF_CONS_OUT) {
! 430: /* Let current output drain */
! 431: DELAY(100000);
! 432: }
! 433:
! 434: t.c_ispeed = 0;
! 435: t.c_ospeed = 9600;
! 436: t.c_cflag = CREAD | CS8 | HUPCL;
! 437: sc->sc_tty->t_ospeed = 0;
! 438: sabttyparam(sc, sc->sc_tty, &t);
! 439:
! 440: if (sc->sc_flags & SABTTYF_CONS_IN) {
! 441: sabtty_cons_input = sc;
! 442: cn_tab->cn_pollc = sab_cnpollc;
! 443: cn_tab->cn_getc = sab_cngetc;
! 444: cn_tab->cn_dev = makedev(77/*XXX*/, self->dv_unit);
! 445: shutdownhook_establish(sabtty_shutdown, sc);
! 446: }
! 447:
! 448: if (sc->sc_flags & SABTTYF_CONS_OUT) {
! 449: sabtty_cons_output = sc;
! 450: cn_tab->cn_putc = sab_cnputc;
! 451: cn_tab->cn_dev = makedev(77/*XXX*/, self->dv_unit);
! 452: }
! 453: printf(": console %s", acc);
! 454: } else {
! 455: /* Not a console... */
! 456: sabtty_reset(sc);
! 457: }
! 458:
! 459: printf("\n");
! 460: }
! 461:
! 462: int
! 463: sabtty_intr(sc, needsoftp)
! 464: struct sabtty_softc *sc;
! 465: int *needsoftp;
! 466: {
! 467: u_int8_t isr0, isr1;
! 468: int i, len = 0, needsoft = 0, r = 0, clearfifo = 0;
! 469:
! 470: isr0 = SAB_READ(sc, SAB_ISR0);
! 471: isr1 = SAB_READ(sc, SAB_ISR1);
! 472:
! 473: if (isr0 || isr1)
! 474: r = 1;
! 475:
! 476: if (isr0 & SAB_ISR0_RPF) {
! 477: len = 32;
! 478: clearfifo = 1;
! 479: }
! 480: if (isr0 & SAB_ISR0_TCD) {
! 481: len = (32 - 1) & SAB_READ(sc, SAB_RBCL);
! 482: clearfifo = 1;
! 483: }
! 484: if (isr0 & SAB_ISR0_TIME) {
! 485: sabtty_cec_wait(sc);
! 486: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_RFRD);
! 487: }
! 488: if (isr0 & SAB_ISR0_RFO) {
! 489: sc->sc_flags |= SABTTYF_RINGOVERFLOW;
! 490: clearfifo = 1;
! 491: }
! 492: if (len != 0) {
! 493: u_int8_t *ptr;
! 494:
! 495: ptr = sc->sc_rput;
! 496: for (i = 0; i < len; i++) {
! 497: *ptr++ = SAB_READ(sc, SAB_RFIFO);
! 498: if (ptr == sc->sc_rend)
! 499: ptr = sc->sc_rbuf;
! 500: if (ptr == sc->sc_rget) {
! 501: if (ptr == sc->sc_rbuf)
! 502: ptr = sc->sc_rend;
! 503: ptr--;
! 504: sc->sc_flags |= SABTTYF_RINGOVERFLOW;
! 505: }
! 506: }
! 507: sc->sc_rput = ptr;
! 508: needsoft = 1;
! 509: }
! 510:
! 511: if (clearfifo) {
! 512: sabtty_cec_wait(sc);
! 513: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_RMC);
! 514: }
! 515:
! 516: if (isr0 & SAB_ISR0_CDSC) {
! 517: sc->sc_flags |= SABTTYF_CDCHG;
! 518: needsoft = 1;
! 519: }
! 520:
! 521: if (isr1 & SAB_ISR1_BRKT)
! 522: sabtty_abort(sc);
! 523:
! 524: if (isr1 & (SAB_ISR1_XPR | SAB_ISR1_ALLS)) {
! 525: if ((SAB_READ(sc, SAB_STAR) & SAB_STAR_XFW) &&
! 526: (sc->sc_flags & SABTTYF_STOP) == 0) {
! 527: if (sc->sc_txc < 32)
! 528: len = sc->sc_txc;
! 529: else
! 530: len = 32;
! 531:
! 532: if (len > 0) {
! 533: SAB_WRITE_BLOCK(sc, SAB_XFIFO, sc->sc_txp, len);
! 534: sc->sc_txp += len;
! 535: sc->sc_txc -= len;
! 536:
! 537: sabtty_cec_wait(sc);
! 538: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_XF);
! 539:
! 540: /*
! 541: * Prevent the false end of xmit from
! 542: * confusing things below.
! 543: */
! 544: isr1 &= ~SAB_ISR1_ALLS;
! 545: }
! 546: }
! 547:
! 548: if ((sc->sc_txc == 0) || (sc->sc_flags & SABTTYF_STOP)) {
! 549: if ((sc->sc_imr1 & SAB_IMR1_XPR) == 0) {
! 550: sc->sc_imr1 |= SAB_IMR1_XPR;
! 551: sc->sc_imr1 &= ~SAB_IMR1_ALLS;
! 552: SAB_WRITE(sc, SAB_IMR1, sc->sc_imr1);
! 553: }
! 554: }
! 555: }
! 556:
! 557: if ((isr1 & SAB_ISR1_ALLS) && ((sc->sc_txc == 0) ||
! 558: (sc->sc_flags & SABTTYF_STOP))) {
! 559: if (sc->sc_flags & SABTTYF_TXDRAIN)
! 560: wakeup(sc);
! 561: sc->sc_flags &= ~SABTTYF_STOP;
! 562: sc->sc_flags |= SABTTYF_DONE;
! 563: sc->sc_imr1 |= SAB_IMR1_ALLS;
! 564: SAB_WRITE(sc, SAB_IMR1, sc->sc_imr1);
! 565: needsoft = 1;
! 566: }
! 567:
! 568: if (needsoft)
! 569: *needsoftp = needsoft;
! 570: return (r);
! 571: }
! 572:
! 573: void
! 574: sabtty_softintr(sc)
! 575: struct sabtty_softc *sc;
! 576: {
! 577: struct tty *tp = sc->sc_tty;
! 578: int s, flags;
! 579: u_int8_t r;
! 580:
! 581: if (tp == NULL)
! 582: return;
! 583:
! 584: if ((tp->t_state & TS_ISOPEN) == 0)
! 585: return;
! 586:
! 587: while (sc->sc_rget != sc->sc_rput) {
! 588: int data;
! 589: u_int8_t stat;
! 590:
! 591: data = sc->sc_rget[0];
! 592: stat = sc->sc_rget[1];
! 593: sc->sc_rget += 2;
! 594: if (stat & SAB_RSTAT_PE)
! 595: data |= TTY_PE;
! 596: if (stat & SAB_RSTAT_FE)
! 597: data |= TTY_FE;
! 598: if (sc->sc_rget == sc->sc_rend)
! 599: sc->sc_rget = sc->sc_rbuf;
! 600:
! 601: (*linesw[tp->t_line].l_rint)(data, tp);
! 602: }
! 603:
! 604: s = splhigh();
! 605: flags = sc->sc_flags;
! 606: sc->sc_flags &= ~(SABTTYF_DONE|SABTTYF_CDCHG|SABTTYF_RINGOVERFLOW);
! 607: splx(s);
! 608:
! 609: if (flags & SABTTYF_CDCHG) {
! 610: s = spltty();
! 611: r = SAB_READ(sc, SAB_VSTR) & SAB_VSTR_CD;
! 612: splx(s);
! 613:
! 614: (*linesw[tp->t_line].l_modem)(tp, r);
! 615: }
! 616:
! 617: if (flags & SABTTYF_RINGOVERFLOW)
! 618: log(LOG_WARNING, "%s: ring overflow\n", sc->sc_dv.dv_xname);
! 619:
! 620: if (flags & SABTTYF_DONE) {
! 621: ndflush(&tp->t_outq, sc->sc_txp - tp->t_outq.c_cf);
! 622: tp->t_state &= ~TS_BUSY;
! 623: (*linesw[tp->t_line].l_start)(tp);
! 624: }
! 625: }
! 626:
! 627: int
! 628: sabttyopen(dev, flags, mode, p)
! 629: dev_t dev;
! 630: int flags, mode;
! 631: struct proc *p;
! 632: {
! 633: struct sab_softc *bc;
! 634: struct sabtty_softc *sc;
! 635: struct tty *tp;
! 636: int card = SAB_CARD(dev), port = SAB_PORT(dev), s, s1;
! 637:
! 638: if (card >= sab_cd.cd_ndevs)
! 639: return (ENXIO);
! 640: bc = sab_cd.cd_devs[card];
! 641: if (bc == NULL)
! 642: return (ENXIO);
! 643:
! 644: if (port >= bc->sc_nchild)
! 645: return (ENXIO);
! 646: sc = bc->sc_child[port];
! 647: if (sc == NULL)
! 648: return (ENXIO);
! 649:
! 650: tp = sc->sc_tty;
! 651: tp->t_dev = dev;
! 652:
! 653: if ((tp->t_state & TS_ISOPEN) == 0) {
! 654: tp->t_state |= TS_WOPEN;
! 655:
! 656: ttychars(tp);
! 657: tp->t_iflag = TTYDEF_IFLAG;
! 658: tp->t_oflag = TTYDEF_OFLAG;
! 659: tp->t_cflag = TTYDEF_CFLAG;
! 660: if (sc->sc_openflags & TIOCFLAG_CLOCAL)
! 661: tp->t_cflag |= CLOCAL;
! 662: if (sc->sc_openflags & TIOCFLAG_CRTSCTS)
! 663: tp->t_cflag |= CRTSCTS;
! 664: if (sc->sc_openflags & TIOCFLAG_MDMBUF)
! 665: tp->t_cflag |= MDMBUF;
! 666: tp->t_lflag = TTYDEF_LFLAG;
! 667: tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
! 668:
! 669: sc->sc_rput = sc->sc_rget = sc->sc_rbuf;
! 670:
! 671: s = spltty();
! 672:
! 673: ttsetwater(tp);
! 674:
! 675: s1 = splhigh();
! 676: sabtty_reset(sc);
! 677: sabtty_param(tp, &tp->t_termios);
! 678: sc->sc_imr0 = SAB_IMR0_PERR | SAB_IMR0_FERR | SAB_IMR0_PLLA;
! 679: SAB_WRITE(sc, SAB_IMR0, sc->sc_imr0);
! 680: sc->sc_imr1 = SAB_IMR1_BRK | SAB_IMR1_ALLS | SAB_IMR1_XDU |
! 681: SAB_IMR1_TIN | SAB_IMR1_CSC | SAB_IMR1_XMR | SAB_IMR1_XPR;
! 682: SAB_WRITE(sc, SAB_IMR1, sc->sc_imr1);
! 683: SAB_WRITE(sc, SAB_CCR0, SAB_READ(sc, SAB_CCR0) | SAB_CCR0_PU);
! 684: sabtty_cec_wait(sc);
! 685: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_XRES);
! 686: sabtty_cec_wait(sc);
! 687: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_RRES);
! 688: sabtty_cec_wait(sc);
! 689: splx(s1);
! 690:
! 691: sabtty_flush(sc);
! 692:
! 693: if ((sc->sc_openflags & TIOCFLAG_SOFTCAR) ||
! 694: (SAB_READ(sc, SAB_VSTR) & SAB_VSTR_CD))
! 695: tp->t_state |= TS_CARR_ON;
! 696: else
! 697: tp->t_state &= ~TS_CARR_ON;
! 698: } else if ((tp->t_state & TS_XCLUDE) &&
! 699: (!suser(p, 0))) {
! 700: return (EBUSY);
! 701: } else {
! 702: s = spltty();
! 703: }
! 704:
! 705: if ((flags & O_NONBLOCK) == 0) {
! 706: while ((tp->t_cflag & CLOCAL) == 0 &&
! 707: (tp->t_state & TS_CARR_ON) == 0) {
! 708: int error;
! 709:
! 710: tp->t_state |= TS_WOPEN;
! 711: error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH,
! 712: "sabttycd", 0);
! 713: if (error != 0) {
! 714: splx(s);
! 715: tp->t_state &= ~TS_WOPEN;
! 716: return (error);
! 717: }
! 718: }
! 719: }
! 720:
! 721: splx(s);
! 722:
! 723: s = (*linesw[tp->t_line].l_open)(dev, tp);
! 724: if (s != 0) {
! 725: if (tp->t_state & TS_ISOPEN)
! 726: return (s);
! 727:
! 728: if (tp->t_cflag & HUPCL) {
! 729: sabtty_mdmctrl(sc, 0, DMSET);
! 730: (void)tsleep(sc, TTIPRI, ttclos, hz);
! 731: }
! 732:
! 733: if ((sc->sc_flags & (SABTTYF_CONS_IN | SABTTYF_CONS_OUT)) == 0) {
! 734: /* Flush and power down if we're not the console */
! 735: sabtty_flush(sc);
! 736: sabtty_reset(sc);
! 737: }
! 738: }
! 739: return (s);
! 740: }
! 741:
! 742: int
! 743: sabttyclose(dev, flags, mode, p)
! 744: dev_t dev;
! 745: int flags, mode;
! 746: struct proc *p;
! 747: {
! 748: struct sab_softc *bc = sab_cd.cd_devs[SAB_CARD(dev)];
! 749: struct sabtty_softc *sc = bc->sc_child[SAB_PORT(dev)];
! 750: struct tty *tp = sc->sc_tty;
! 751: int s;
! 752:
! 753: (*linesw[tp->t_line].l_close)(tp, flags);
! 754:
! 755: s = spltty();
! 756:
! 757: if ((tp->t_state & TS_ISOPEN) == 0) {
! 758: /* Wait for output drain */
! 759: sc->sc_imr1 &= ~SAB_IMR1_ALLS;
! 760: SAB_WRITE(sc, SAB_IMR1, sc->sc_imr1);
! 761: sc->sc_flags |= SABTTYF_TXDRAIN;
! 762: (void)tsleep(sc, TTIPRI, ttclos, 5 * hz);
! 763: sc->sc_imr1 |= SAB_IMR1_ALLS;
! 764: SAB_WRITE(sc, SAB_IMR1, sc->sc_imr1);
! 765: sc->sc_flags &= ~SABTTYF_TXDRAIN;
! 766:
! 767: if (tp->t_cflag & HUPCL) {
! 768: sabtty_mdmctrl(sc, 0, DMSET);
! 769: (void)tsleep(bc, TTIPRI, ttclos, hz);
! 770: }
! 771:
! 772: if ((sc->sc_flags & (SABTTYF_CONS_IN | SABTTYF_CONS_OUT)) == 0) {
! 773: /* Flush and power down if we're not the console */
! 774: sabtty_flush(sc);
! 775: sabtty_reset(sc);
! 776: }
! 777: }
! 778:
! 779: ttyclose(tp);
! 780: splx(s);
! 781:
! 782: return (0);
! 783: }
! 784:
! 785: int
! 786: sabttyread(dev, uio, flags)
! 787: dev_t dev;
! 788: struct uio *uio;
! 789: int flags;
! 790: {
! 791: struct sab_softc *bc = sab_cd.cd_devs[SAB_CARD(dev)];
! 792: struct sabtty_softc *sc = bc->sc_child[SAB_PORT(dev)];
! 793: struct tty *tp = sc->sc_tty;
! 794:
! 795: return ((*linesw[tp->t_line].l_read)(tp, uio, flags));
! 796: }
! 797:
! 798: int
! 799: sabttywrite(dev, uio, flags)
! 800: dev_t dev;
! 801: struct uio *uio;
! 802: int flags;
! 803: {
! 804: struct sab_softc *bc = sab_cd.cd_devs[SAB_CARD(dev)];
! 805: struct sabtty_softc *sc = bc->sc_child[SAB_PORT(dev)];
! 806: struct tty *tp = sc->sc_tty;
! 807:
! 808: return ((*linesw[tp->t_line].l_write)(tp, uio, flags));
! 809: }
! 810:
! 811: int
! 812: sabttyioctl(dev, cmd, data, flags, p)
! 813: dev_t dev;
! 814: u_long cmd;
! 815: caddr_t data;
! 816: int flags;
! 817: struct proc *p;
! 818: {
! 819: struct sab_softc *bc = sab_cd.cd_devs[SAB_CARD(dev)];
! 820: struct sabtty_softc *sc = bc->sc_child[SAB_PORT(dev)];
! 821: struct tty *tp = sc->sc_tty;
! 822: int error;
! 823:
! 824: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flags, p);
! 825: if (error >= 0)
! 826: return (error);
! 827:
! 828: error = ttioctl(tp, cmd, data, flags, p);
! 829: if (error >= 0)
! 830: return (error);
! 831:
! 832: error = 0;
! 833:
! 834: switch (cmd) {
! 835: case TIOCSBRK:
! 836: SAB_WRITE(sc, SAB_DAFO,
! 837: SAB_READ(sc, SAB_DAFO) | SAB_DAFO_XBRK);
! 838: break;
! 839: case TIOCCBRK:
! 840: SAB_WRITE(sc, SAB_DAFO,
! 841: SAB_READ(sc, SAB_DAFO) & ~SAB_DAFO_XBRK);
! 842: break;
! 843: case TIOCSDTR:
! 844: sabtty_mdmctrl(sc, TIOCM_DTR, DMBIS);
! 845: break;
! 846: case TIOCCDTR:
! 847: sabtty_mdmctrl(sc, TIOCM_DTR, DMBIC);
! 848: break;
! 849: case TIOCMBIS:
! 850: sabtty_mdmctrl(sc, *((int *)data), DMBIS);
! 851: break;
! 852: case TIOCMBIC:
! 853: sabtty_mdmctrl(sc, *((int *)data), DMBIC);
! 854: break;
! 855: case TIOCMGET:
! 856: *((int *)data) = sabtty_mdmctrl(sc, 0, DMGET);
! 857: break;
! 858: case TIOCMSET:
! 859: sabtty_mdmctrl(sc, *((int *)data), DMSET);
! 860: break;
! 861: case TIOCGFLAGS:
! 862: *((int *)data) = sc->sc_openflags;
! 863: break;
! 864: case TIOCSFLAGS:
! 865: if (suser(p, 0))
! 866: error = EPERM;
! 867: else
! 868: sc->sc_openflags = *((int *)data) &
! 869: (TIOCFLAG_SOFTCAR | TIOCFLAG_CLOCAL |
! 870: TIOCFLAG_CRTSCTS | TIOCFLAG_MDMBUF);
! 871: break;
! 872: default:
! 873: error = ENOTTY;
! 874: }
! 875:
! 876: return (error);
! 877: }
! 878:
! 879: struct tty *
! 880: sabttytty(dev)
! 881: dev_t dev;
! 882: {
! 883: struct sab_softc *bc = sab_cd.cd_devs[SAB_CARD(dev)];
! 884: struct sabtty_softc *sc = bc->sc_child[SAB_PORT(dev)];
! 885:
! 886: return (sc->sc_tty);
! 887: }
! 888:
! 889: int
! 890: sabttystop(tp, flags)
! 891: struct tty *tp;
! 892: int flags;
! 893: {
! 894: struct sab_softc *bc = sab_cd.cd_devs[SAB_CARD(tp->t_dev)];
! 895: struct sabtty_softc *sc = bc->sc_child[SAB_PORT(tp->t_dev)];
! 896: int s;
! 897:
! 898: s = spltty();
! 899: if (tp->t_state & TS_BUSY) {
! 900: if ((tp->t_state & TS_TTSTOP) == 0)
! 901: tp->t_state |= TS_FLUSH;
! 902: sc->sc_flags |= SABTTYF_STOP;
! 903: sc->sc_imr1 &= ~SAB_IMR1_ALLS;
! 904: SAB_WRITE(sc, SAB_IMR1, sc->sc_imr1);
! 905: }
! 906: splx(s);
! 907: return (0);
! 908: }
! 909:
! 910: int
! 911: sabtty_mdmctrl(sc, bits, how)
! 912: struct sabtty_softc *sc;
! 913: int bits, how;
! 914: {
! 915: u_int8_t r;
! 916: int s;
! 917:
! 918: s = spltty();
! 919: switch (how) {
! 920: case DMGET:
! 921: bits = 0;
! 922: if (SAB_READ(sc, SAB_STAR) & SAB_STAR_CTS)
! 923: bits |= TIOCM_CTS;
! 924: if ((SAB_READ(sc, SAB_VSTR) & SAB_VSTR_CD) == 0)
! 925: bits |= TIOCM_CD;
! 926:
! 927: r = SAB_READ(sc, SAB_PVR);
! 928: if ((r & sc->sc_pvr_dtr) == 0)
! 929: bits |= TIOCM_DTR;
! 930: if ((r & sc->sc_pvr_dsr) == 0)
! 931: bits |= TIOCM_DSR;
! 932:
! 933: r = SAB_READ(sc, SAB_MODE);
! 934: if ((r & (SAB_MODE_RTS|SAB_MODE_FRTS)) == SAB_MODE_RTS)
! 935: bits |= TIOCM_RTS;
! 936: break;
! 937: case DMSET:
! 938: r = SAB_READ(sc, SAB_MODE);
! 939: if (bits & TIOCM_RTS) {
! 940: r &= ~SAB_MODE_FRTS;
! 941: r |= SAB_MODE_RTS;
! 942: } else
! 943: r |= SAB_MODE_FRTS | SAB_MODE_RTS;
! 944: SAB_WRITE(sc, SAB_MODE, r);
! 945:
! 946: r = SAB_READ(sc, SAB_PVR);
! 947: if (bits & TIOCM_DTR)
! 948: r &= ~sc->sc_pvr_dtr;
! 949: else
! 950: r |= sc->sc_pvr_dtr;
! 951: SAB_WRITE(sc, SAB_PVR, r);
! 952: break;
! 953: case DMBIS:
! 954: if (bits & TIOCM_RTS) {
! 955: r = SAB_READ(sc, SAB_MODE);
! 956: r &= ~SAB_MODE_FRTS;
! 957: r |= SAB_MODE_RTS;
! 958: SAB_WRITE(sc, SAB_MODE, r);
! 959: }
! 960: if (bits & TIOCM_DTR) {
! 961: r = SAB_READ(sc, SAB_PVR);
! 962: r &= ~sc->sc_pvr_dtr;
! 963: SAB_WRITE(sc, SAB_PVR, r);
! 964: }
! 965: break;
! 966: case DMBIC:
! 967: if (bits & TIOCM_RTS) {
! 968: r = SAB_READ(sc, SAB_MODE);
! 969: r |= SAB_MODE_FRTS | SAB_MODE_RTS;
! 970: SAB_WRITE(sc, SAB_MODE, r);
! 971: }
! 972: if (bits & TIOCM_DTR) {
! 973: r = SAB_READ(sc, SAB_PVR);
! 974: r |= sc->sc_pvr_dtr;
! 975: SAB_WRITE(sc, SAB_PVR, r);
! 976: }
! 977: break;
! 978: }
! 979: splx(s);
! 980: return (bits);
! 981: }
! 982:
! 983: int
! 984: sabttyparam(sc, tp, t)
! 985: struct sabtty_softc *sc;
! 986: struct tty *tp;
! 987: struct termios *t;
! 988: {
! 989: int s, ospeed;
! 990: tcflag_t cflag;
! 991: u_int8_t dafo, r;
! 992:
! 993: ospeed = sabtty_speed(t->c_ospeed);
! 994: if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed))
! 995: return (EINVAL);
! 996:
! 997: s = spltty();
! 998:
! 999: /* hang up line if ospeed is zero, otherwise raise dtr */
! 1000: sabtty_mdmctrl(sc, TIOCM_DTR,
! 1001: (t->c_ospeed == 0) ? DMBIC : DMBIS);
! 1002:
! 1003: dafo = SAB_READ(sc, SAB_DAFO);
! 1004:
! 1005: cflag = t->c_cflag;
! 1006:
! 1007: if (sc->sc_flags & (SABTTYF_CONS_IN | SABTTYF_CONS_OUT)) {
! 1008: cflag |= CLOCAL;
! 1009: cflag &= ~HUPCL;
! 1010: }
! 1011:
! 1012: if (cflag & CSTOPB)
! 1013: dafo |= SAB_DAFO_STOP;
! 1014: else
! 1015: dafo &= ~SAB_DAFO_STOP;
! 1016:
! 1017: dafo &= ~SAB_DAFO_CHL_CSIZE;
! 1018: switch (cflag & CSIZE) {
! 1019: case CS5:
! 1020: dafo |= SAB_DAFO_CHL_CS5;
! 1021: break;
! 1022: case CS6:
! 1023: dafo |= SAB_DAFO_CHL_CS6;
! 1024: break;
! 1025: case CS7:
! 1026: dafo |= SAB_DAFO_CHL_CS7;
! 1027: break;
! 1028: default:
! 1029: dafo |= SAB_DAFO_CHL_CS8;
! 1030: break;
! 1031: }
! 1032:
! 1033: dafo &= ~SAB_DAFO_PARMASK;
! 1034: if (cflag & PARENB) {
! 1035: if (cflag & PARODD)
! 1036: dafo |= SAB_DAFO_PAR_ODD;
! 1037: else
! 1038: dafo |= SAB_DAFO_PAR_EVEN;
! 1039: } else
! 1040: dafo |= SAB_DAFO_PAR_NONE;
! 1041:
! 1042: if (ospeed != 0) {
! 1043: SAB_WRITE(sc, SAB_BGR, ospeed & 0xff);
! 1044: r = SAB_READ(sc, SAB_CCR2);
! 1045: r &= ~(SAB_CCR2_BR9 | SAB_CCR2_BR8);
! 1046: r |= (ospeed >> 2) & (SAB_CCR2_BR9 | SAB_CCR2_BR8);
! 1047: SAB_WRITE(sc, SAB_CCR2, r);
! 1048: }
! 1049:
! 1050: r = SAB_READ(sc, SAB_MODE);
! 1051: r |= SAB_MODE_RAC;
! 1052: if (cflag & CRTSCTS) {
! 1053: r &= ~(SAB_MODE_RTS | SAB_MODE_FCTS);
! 1054: r |= SAB_MODE_FRTS;
! 1055: sc->sc_imr1 &= ~SAB_IMR1_CSC;
! 1056: } else {
! 1057: r |= SAB_MODE_RTS | SAB_MODE_FCTS;
! 1058: r &= ~SAB_MODE_FRTS;
! 1059: sc->sc_imr1 |= SAB_IMR1_CSC;
! 1060: }
! 1061: SAB_WRITE(sc, SAB_MODE, r);
! 1062: SAB_WRITE(sc, SAB_IMR1, sc->sc_imr1);
! 1063:
! 1064: tp->t_cflag = cflag;
! 1065:
! 1066: splx(s);
! 1067: return (0);
! 1068: }
! 1069:
! 1070: int
! 1071: sabtty_param(tp, t)
! 1072: struct tty *tp;
! 1073: struct termios *t;
! 1074: {
! 1075: struct sab_softc *bc = sab_cd.cd_devs[SAB_CARD(tp->t_dev)];
! 1076: struct sabtty_softc *sc = bc->sc_child[SAB_PORT(tp->t_dev)];
! 1077:
! 1078: return (sabttyparam(sc, tp, t));
! 1079: }
! 1080:
! 1081: void
! 1082: sabtty_start(tp)
! 1083: struct tty *tp;
! 1084: {
! 1085: struct sab_softc *bc = sab_cd.cd_devs[SAB_CARD(tp->t_dev)];
! 1086: struct sabtty_softc *sc = bc->sc_child[SAB_PORT(tp->t_dev)];
! 1087: int s;
! 1088:
! 1089: s = spltty();
! 1090: if ((tp->t_state & (TS_TTSTOP | TS_TIMEOUT | TS_BUSY)) == 0) {
! 1091: if (tp->t_outq.c_cc <= tp->t_lowat) {
! 1092: if (tp->t_state & TS_ASLEEP) {
! 1093: tp->t_state &= ~TS_ASLEEP;
! 1094: wakeup(&tp->t_outq);
! 1095: }
! 1096: selwakeup(&tp->t_wsel);
! 1097: }
! 1098: if (tp->t_outq.c_cc) {
! 1099: sc->sc_txc = ndqb(&tp->t_outq, 0);
! 1100: sc->sc_txp = tp->t_outq.c_cf;
! 1101: tp->t_state |= TS_BUSY;
! 1102: sc->sc_imr1 &= ~(SAB_ISR1_XPR | SAB_ISR1_ALLS);
! 1103: SAB_WRITE(sc, SAB_IMR1, sc->sc_imr1);
! 1104: }
! 1105: }
! 1106: splx(s);
! 1107: }
! 1108:
! 1109: int
! 1110: sabtty_cec_wait(struct sabtty_softc *sc)
! 1111: {
! 1112: int i = 50000;
! 1113:
! 1114: for (;;) {
! 1115: if ((SAB_READ(sc, SAB_STAR) & SAB_STAR_CEC) == 0)
! 1116: return (0);
! 1117: if (--i == 0)
! 1118: return (1);
! 1119: DELAY(1);
! 1120: }
! 1121: }
! 1122:
! 1123: int
! 1124: sabtty_tec_wait(struct sabtty_softc *sc)
! 1125: {
! 1126: int i = 200000;
! 1127:
! 1128: for (;;) {
! 1129: if ((SAB_READ(sc, SAB_STAR) & SAB_STAR_TEC) == 0)
! 1130: return (0);
! 1131: if (--i == 0)
! 1132: return (1);
! 1133: DELAY(1);
! 1134: }
! 1135: }
! 1136:
! 1137: void
! 1138: sabtty_reset(sc)
! 1139: struct sabtty_softc *sc;
! 1140: {
! 1141: /* power down */
! 1142: SAB_WRITE(sc, SAB_CCR0, 0);
! 1143:
! 1144: /* set basic configuration */
! 1145: SAB_WRITE(sc, SAB_CCR0,
! 1146: SAB_CCR0_MCE | SAB_CCR0_SC_NRZ | SAB_CCR0_SM_ASYNC);
! 1147: SAB_WRITE(sc, SAB_CCR1, SAB_CCR1_ODS | SAB_CCR1_BCR | SAB_CCR1_CM_7);
! 1148: SAB_WRITE(sc, SAB_CCR2, SAB_CCR2_BDF | SAB_CCR2_SSEL | SAB_CCR2_TOE);
! 1149: SAB_WRITE(sc, SAB_CCR3, 0);
! 1150: SAB_WRITE(sc, SAB_CCR4, SAB_CCR4_MCK4 | SAB_CCR4_EBRG);
! 1151: SAB_WRITE(sc, SAB_MODE, SAB_MODE_RTS | SAB_MODE_FCTS | SAB_MODE_RAC);
! 1152: SAB_WRITE(sc, SAB_RFC,
! 1153: SAB_RFC_DPS | SAB_RFC_RFDF | SAB_RFC_RFTH_32CHAR);
! 1154:
! 1155: /* clear interrupts */
! 1156: sc->sc_imr0 = sc->sc_imr1 = 0xff;
! 1157: SAB_WRITE(sc, SAB_IMR0, sc->sc_imr0);
! 1158: SAB_WRITE(sc, SAB_IMR1, sc->sc_imr1);
! 1159: SAB_READ(sc, SAB_ISR0);
! 1160: SAB_READ(sc, SAB_ISR1);
! 1161: }
! 1162:
! 1163: void
! 1164: sabtty_flush(sc)
! 1165: struct sabtty_softc *sc;
! 1166: {
! 1167: /* clear rx fifo */
! 1168: sabtty_cec_wait(sc);
! 1169: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_RRES);
! 1170:
! 1171: /* clear tx fifo */
! 1172: sabtty_cec_wait(sc);
! 1173: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_XRES);
! 1174: }
! 1175:
! 1176: int
! 1177: sabtty_speed(rate)
! 1178: int rate;
! 1179: {
! 1180: int i, len, r;
! 1181:
! 1182: if (rate == 0)
! 1183: return (0);
! 1184: len = sizeof(sabtty_baudtable)/sizeof(sabtty_baudtable[0]);
! 1185: for (i = 0; i < len; i++) {
! 1186: if (rate == sabtty_baudtable[i].baud) {
! 1187: r = sabtty_baudtable[i].n |
! 1188: (sabtty_baudtable[i].m << 6);
! 1189: return (r);
! 1190: }
! 1191: }
! 1192: return (-1);
! 1193: }
! 1194:
! 1195: void
! 1196: sabtty_cnputc(sc, c)
! 1197: struct sabtty_softc *sc;
! 1198: int c;
! 1199: {
! 1200: sabtty_tec_wait(sc);
! 1201: SAB_WRITE(sc, SAB_TIC, c);
! 1202: sabtty_tec_wait(sc);
! 1203: }
! 1204:
! 1205: int
! 1206: sabtty_cngetc(sc)
! 1207: struct sabtty_softc *sc;
! 1208: {
! 1209: u_int8_t r, len, ipc;
! 1210:
! 1211: ipc = SAB_READ(sc, SAB_IPC);
! 1212: SAB_WRITE(sc, SAB_IPC, ipc | SAB_IPC_VIS);
! 1213:
! 1214: again:
! 1215: do {
! 1216: r = SAB_READ(sc, SAB_STAR);
! 1217: } while ((r & SAB_STAR_RFNE) == 0);
! 1218:
! 1219: /*
! 1220: * Ok, at least one byte in RFIFO, ask for permission to access RFIFO
! 1221: * (I hate this chip... hate hate hate).
! 1222: */
! 1223: sabtty_cec_wait(sc);
! 1224: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_RFRD);
! 1225:
! 1226: /* Wait for RFIFO to come ready */
! 1227: do {
! 1228: r = SAB_READ(sc, SAB_ISR0);
! 1229: } while ((r & SAB_ISR0_TCD) == 0);
! 1230:
! 1231: len = SAB_READ(sc, SAB_RBCL) & (32 - 1);
! 1232: if (len == 0)
! 1233: goto again; /* Shouldn't happen... */
! 1234:
! 1235: r = SAB_READ(sc, SAB_RFIFO);
! 1236:
! 1237: /*
! 1238: * Blow away everything left in the FIFO...
! 1239: */
! 1240: sabtty_cec_wait(sc);
! 1241: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_RMC);
! 1242: SAB_WRITE(sc, SAB_IPC, ipc);
! 1243: return (r);
! 1244: }
! 1245:
! 1246: void
! 1247: sabtty_cnpollc(sc, on)
! 1248: struct sabtty_softc *sc;
! 1249: int on;
! 1250: {
! 1251: u_int8_t r;
! 1252:
! 1253: if (on) {
! 1254: if (sc->sc_polling)
! 1255: return;
! 1256: SAB_WRITE(sc, SAB_IPC, SAB_READ(sc, SAB_IPC) | SAB_IPC_VIS);
! 1257: r = sc->sc_pollrfc = SAB_READ(sc, SAB_RFC);
! 1258: r &= ~(SAB_RFC_RFDF);
! 1259: SAB_WRITE(sc, SAB_RFC, r);
! 1260: sabtty_cec_wait(sc);
! 1261: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_RRES);
! 1262: sc->sc_polling = 1;
! 1263: } else {
! 1264: if (!sc->sc_polling)
! 1265: return;
! 1266: SAB_WRITE(sc, SAB_IPC, SAB_READ(sc, SAB_IPC) & ~SAB_IPC_VIS);
! 1267: SAB_WRITE(sc, SAB_RFC, sc->sc_pollrfc);
! 1268: sabtty_cec_wait(sc);
! 1269: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_RRES);
! 1270: sc->sc_polling = 0;
! 1271: }
! 1272: }
! 1273:
! 1274: void
! 1275: sab_cnputc(dev, c)
! 1276: dev_t dev;
! 1277: int c;
! 1278: {
! 1279: struct sabtty_softc *sc = sabtty_cons_output;
! 1280:
! 1281: if (sc == NULL)
! 1282: return;
! 1283: sabtty_cnputc(sc, c);
! 1284: }
! 1285:
! 1286: void
! 1287: sab_cnpollc(dev, on)
! 1288: dev_t dev;
! 1289: int on;
! 1290: {
! 1291: struct sabtty_softc *sc = sabtty_cons_input;
! 1292:
! 1293: sabtty_cnpollc(sc, on);
! 1294: }
! 1295:
! 1296: int
! 1297: sab_cngetc(dev)
! 1298: dev_t dev;
! 1299: {
! 1300: struct sabtty_softc *sc = sabtty_cons_input;
! 1301:
! 1302: if (sc == NULL)
! 1303: return (-1);
! 1304: return (sabtty_cngetc(sc));
! 1305: }
! 1306:
! 1307: void
! 1308: sabtty_console_flags(sc)
! 1309: struct sabtty_softc *sc;
! 1310: {
! 1311: int node, channel, cookie;
! 1312: u_int options;
! 1313: char buf[255];
! 1314:
! 1315: node = sc->sc_parent->sc_node;
! 1316: channel = sc->sc_portno;
! 1317:
! 1318: options = OF_finddevice("/options");
! 1319:
! 1320: /* Default to channel 0 if there are no explicit prom args */
! 1321: cookie = 0;
! 1322:
! 1323: if (node == OF_instance_to_package(OF_stdin())) {
! 1324: if (OF_getprop(options, "input-device", buf,
! 1325: sizeof(buf)) != -1) {
! 1326: if (strncmp("ttyb", buf, strlen("ttyb")) == 0)
! 1327: cookie = 1;
! 1328: }
! 1329:
! 1330: if (channel == cookie)
! 1331: sc->sc_flags |= SABTTYF_CONS_IN;
! 1332: }
! 1333:
! 1334: /* Default to same channel if there are no explicit prom args */
! 1335:
! 1336: if (node == OF_instance_to_package(OF_stdout())) {
! 1337: if (OF_getprop(options, "output-device", buf,
! 1338: sizeof(buf)) != -1) {
! 1339: if (strncmp("ttyb", buf, strlen("ttyb")) == 0)
! 1340: cookie = 1;
! 1341: }
! 1342:
! 1343: if (channel == cookie)
! 1344: sc->sc_flags |= SABTTYF_CONS_OUT;
! 1345: }
! 1346: }
! 1347:
! 1348: void
! 1349: sabtty_abort(sc)
! 1350: struct sabtty_softc *sc;
! 1351: {
! 1352:
! 1353: if (sc->sc_flags & SABTTYF_CONS_IN) {
! 1354: #ifdef DDB
! 1355: extern int db_active, db_console;
! 1356:
! 1357: if (db_console == 0)
! 1358: return;
! 1359: if (db_active == 0)
! 1360: Debugger();
! 1361: else
! 1362: callrom();
! 1363: #else
! 1364: callrom();
! 1365: #endif
! 1366: }
! 1367: }
! 1368:
! 1369: void
! 1370: sabtty_shutdown(vsc)
! 1371: void *vsc;
! 1372: {
! 1373: struct sabtty_softc *sc = vsc;
! 1374:
! 1375: /* Have to put the chip back into single char mode */
! 1376: sc->sc_flags |= SABTTYF_DONTDDB;
! 1377: SAB_WRITE(sc, SAB_RFC, SAB_READ(sc, SAB_RFC) & ~SAB_RFC_RFDF);
! 1378: sabtty_cec_wait(sc);
! 1379: SAB_WRITE(sc, SAB_CMDR, SAB_CMDR_RRES);
! 1380: sabtty_cec_wait(sc);
! 1381: SAB_WRITE(sc, SAB_IPC, SAB_READ(sc, SAB_IPC) | SAB_IPC_VIS);
! 1382: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to sab.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc64 / dev