Annotation of sys/arch/mvme88k/dev/vx.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: vx.c,v 1.38 2006/07/28 21:46:02 miod Exp $ */
! 2: /*
! 3: * Copyright (c) 1999 Steve Murphree, Jr.
! 4: * All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: * 3. The name of the author may not be used to endorse or promote products
! 15: * derived from this software without specific prior written permission.
! 16: *
! 17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 18: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 19: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 20: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 21: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 22: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 23: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 24: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 25: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 26: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 27: */
! 28:
! 29: /* This card lives in D16 space */
! 30: #define __BUS_SPACE_RESTRICT_D16__
! 31:
! 32: #include <sys/param.h>
! 33: #include <sys/ioctl.h>
! 34: #include <sys/proc.h>
! 35: #include <sys/tty.h>
! 36: #include <sys/uio.h>
! 37: #include <sys/systm.h>
! 38: #include <sys/time.h>
! 39: #include <sys/device.h>
! 40: #include <sys/syslog.h>
! 41:
! 42: #include <machine/autoconf.h>
! 43: #include <machine/conf.h>
! 44: #include <machine/cpu.h>
! 45: #include <machine/psl.h>
! 46:
! 47: #include <dev/cons.h>
! 48:
! 49: #include <mvme88k/dev/vme.h>
! 50: #include <mvme88k/dev/vxreg.h>
! 51:
! 52: #define splvx() spltty()
! 53:
! 54: struct vx_info {
! 55: struct tty *tty;
! 56: u_char vx_swflags;
! 57: int vx_linestatus;
! 58: int open;
! 59: int waiting;
! 60: u_char vx_speed;
! 61: u_char read_pending;
! 62: struct wring *wringp;
! 63: struct rring *rringp;
! 64: };
! 65:
! 66: struct vxsoftc {
! 67: struct device sc_dev;
! 68: struct vx_info sc_info[NVXPORTS];
! 69: struct vxreg *vx_reg;
! 70: vaddr_t board_vaddr;
! 71: struct channel *channel;
! 72: char channel_number;
! 73: struct packet sc_bppwait_pkt;
! 74: void *sc_bppwait_pktp;
! 75: struct intrhand sc_ih;
! 76: int sc_vec;
! 77: struct envelope *elist_head, *elist_tail;
! 78: struct packet *plist_head, *plist_tail;
! 79: };
! 80:
! 81: int vxmatch(struct device *, void *, void *);
! 82: void vxattach(struct device *, struct device *, void *);
! 83:
! 84: struct cfattach vx_ca = {
! 85: sizeof(struct vxsoftc), vxmatch, vxattach
! 86: };
! 87:
! 88: struct cfdriver vx_cd = {
! 89: NULL, "vx", DV_TTY
! 90: };
! 91:
! 92: int bpp_send(struct vxsoftc *, void *, int);
! 93: void ccode(struct vxsoftc *, int, char);
! 94: int create_channels(struct vxsoftc *);
! 95: void create_free_queue(struct vxsoftc *);
! 96: short dtr_ctl(struct vxsoftc *, int, int);
! 97: int env_isvalid(struct envelope *);
! 98: struct envelope *find_status_packet(struct vxsoftc *, struct packet *);
! 99: short flush_ctl(struct vxsoftc *, int, int);
! 100: struct envelope *get_cmd_tail(struct vxsoftc *);
! 101: void *get_free_envelope(struct vxsoftc *);
! 102: void *get_free_packet(struct vxsoftc *);
! 103: struct envelope *get_next_envelope(struct vxsoftc *, struct envelope *);
! 104: struct packet *get_packet(struct vxsoftc *, struct envelope *);
! 105: struct envelope *get_status_head(struct vxsoftc *);
! 106: void put_free_envelope(struct vxsoftc *, void *);
! 107: void put_free_packet(struct vxsoftc *, void *);
! 108: void read_chars(struct vxsoftc *, int);
! 109: void read_wakeup(struct vxsoftc *, int);
! 110: short rts_ctl(struct vxsoftc *, int, int);
! 111: void set_status_head(struct vxsoftc *, void *);
! 112: void vx_break(struct vxsoftc *, int);
! 113: int vx_ccparam(struct vxsoftc *, struct termios *, int);
! 114: int vx_event(struct vxsoftc *, struct packet *);
! 115: void vx_frame(struct vxsoftc *, int);
! 116: int vx_init(struct vxsoftc *);
! 117: int vx_intr(void *);
! 118: int vx_mctl(dev_t, int, int);
! 119: void vx_overflow(struct vxsoftc *, int, long *, u_char *);
! 120: int vx_param(struct tty *, struct termios *);
! 121: int vx_poll(struct vxsoftc *, struct packet *);
! 122: void vxputc(struct vxsoftc *, int, u_char);
! 123: int vx_sintr(struct vxsoftc *);
! 124: void vxstart(struct tty *tp);
! 125: u_short vxtspeed(int);
! 126: void vx_unblock(struct tty *);
! 127:
! 128: /* flags for bpp_send() */
! 129: #define NOWAIT 0
! 130: #define WAIT 1
! 131:
! 132: #define VX_UNIT(x) (minor(x) / NVXPORTS)
! 133: #define VX_PORT(x) (minor(x) % NVXPORTS)
! 134:
! 135: /*
! 136: * Convert dual-ported physical addresse to host virtual address, and the
! 137: * opposite.
! 138: */
! 139: #define VIRTUAL(addr) (((addr) & 0xffff) + sc->board_vaddr)
! 140: #define PHYSICAL(addr) \
! 141: (((addr - sc->board_vaddr) & 0xffff) | LOCAL_DPMEM_ADDRESS)
! 142:
! 143: #if 0
! 144: #define LO(x) (u_short)((unsigned long)x & 0x0000FFFF)
! 145: #define HI(x) (u_short)((unsigned long)x >> 16)
! 146: #else
! 147: #define LO(x) (u_short)(x)
! 148: #define HI(x) (LOCAL_DPMEM_ADDRESS >> 16)
! 149: #endif
! 150:
! 151: struct tty *
! 152: vxtty(dev_t dev)
! 153: {
! 154: int unit, port;
! 155: struct vxsoftc *sc;
! 156:
! 157: unit = VX_UNIT(dev);
! 158: if (unit >= vx_cd.cd_ndevs ||
! 159: (sc = (struct vxsoftc *)vx_cd.cd_devs[unit]) == NULL) {
! 160: return (NULL);
! 161: }
! 162: port = VX_PORT(dev);
! 163: return sc->sc_info[port].tty;
! 164: }
! 165:
! 166: int
! 167: vxmatch(struct device *parent, void *self, void *aux)
! 168: {
! 169: struct vxreg *vx_reg;
! 170: struct confargs *ca = aux;
! 171: bus_space_tag_t iot = ca->ca_iot;
! 172: bus_space_handle_t ioh;
! 173: int rc;
! 174:
! 175: if (bus_space_map(iot, ca->ca_paddr, 0x10000, 0, &ioh) != 0)
! 176: return 0;
! 177: vx_reg = (struct vxreg *)bus_space_vaddr(iot, ioh);
! 178: rc = badaddr((vaddr_t)&vx_reg->ipc_cr, 1);
! 179: bus_space_unmap(iot, ioh, 0x10000);
! 180:
! 181: return rc == 0;
! 182: }
! 183:
! 184: void
! 185: vxattach(struct device *parent, struct device *self, void *aux)
! 186: {
! 187: struct vxsoftc *sc = (struct vxsoftc *)self;
! 188: struct confargs *ca = aux;
! 189: bus_space_tag_t iot = ca->ca_iot;
! 190: bus_space_handle_t ioh;
! 191:
! 192: if (ca->ca_vec < 0) {
! 193: printf(": no more interrupts!\n");
! 194: return;
! 195: }
! 196: if (ca->ca_ipl < 0)
! 197: ca->ca_ipl = IPL_TTY;
! 198:
! 199: if (bus_space_map(iot, ca->ca_paddr, 0x10000, 0, &ioh) != 0) {
! 200: printf(": can't map registers!\n");
! 201: return;
! 202: }
! 203:
! 204: /* set up dual port memory and registers and init */
! 205: sc->board_vaddr = (vaddr_t)bus_space_vaddr(iot, ioh);
! 206: sc->vx_reg = (struct vxreg *)sc->board_vaddr;
! 207: sc->channel = (struct channel *)(sc->board_vaddr + 0x0100);
! 208: sc->sc_vec = ca->ca_vec;
! 209:
! 210: printf("\n");
! 211:
! 212: if (create_channels(sc) != 0) {
! 213: printf("%s: failed to create channel %d\n",
! 214: sc->sc_dev.dv_xname, sc->channel->channel_number);
! 215: return;
! 216: }
! 217: if (vx_init(sc) != 0) {
! 218: printf("%s: failed to initialize\n", sc->sc_dev.dv_xname);
! 219: return;
! 220: }
! 221:
! 222: /* enable interrupts */
! 223: sc->sc_ih.ih_fn = vx_intr;
! 224: sc->sc_ih.ih_arg = sc;
! 225: sc->sc_ih.ih_wantframe = 0;
! 226: sc->sc_ih.ih_ipl = IPL_TTY;
! 227:
! 228: vmeintr_establish(ca->ca_vec, &sc->sc_ih, self->dv_xname);
! 229: }
! 230:
! 231: short
! 232: dtr_ctl(struct vxsoftc *sc, int port, int on)
! 233: {
! 234: struct packet pkt;
! 235:
! 236: bzero(&pkt, sizeof(struct packet));
! 237: pkt.command = CMD_IOCTL;
! 238: pkt.ioctl_cmd_l = IOCTL_TCXONC;
! 239: pkt.command_pipe_number = sc->channel_number;
! 240: pkt.status_pipe_number = sc->channel_number;
! 241: pkt.device_number = port;
! 242: if (on) {
! 243: pkt.ioctl_arg_l = 6; /* assert DTR */
! 244: } else {
! 245: pkt.ioctl_arg_l = 7; /* negate DTR */
! 246: }
! 247:
! 248: return bpp_send(sc, &pkt, WAIT);
! 249: }
! 250:
! 251: short
! 252: rts_ctl(struct vxsoftc *sc, int port, int on)
! 253: {
! 254: struct packet pkt;
! 255:
! 256: bzero(&pkt, sizeof(struct packet));
! 257: pkt.command = CMD_IOCTL;
! 258: pkt.ioctl_cmd_l = IOCTL_TCXONC;
! 259: pkt.command_pipe_number = sc->channel_number;
! 260: pkt.status_pipe_number = sc->channel_number;
! 261: pkt.device_number = port;
! 262: if (on) {
! 263: pkt.ioctl_arg_l = 4; /* assert RTS */
! 264: } else {
! 265: pkt.ioctl_arg_l = 5; /* negate RTS */
! 266: }
! 267:
! 268: return bpp_send(sc, &pkt, WAIT);
! 269: }
! 270:
! 271: #if 0
! 272: short
! 273: flush_ctl(struct vxsoftc *sc, int port, int which)
! 274: {
! 275: struct packet pkt;
! 276:
! 277: bzero(&pkt, sizeof(struct packet));
! 278: pkt.command = CMD_IOCTL;
! 279: pkt.ioctl_cmd_l = IOCTL_TCFLSH;
! 280: pkt.command_pipe_number = sc->channel_number;
! 281: pkt.status_pipe_number = sc->channel_number;
! 282: pkt.device_number = port;
! 283: pkt.ioctl_arg_l = which; /* 0=input, 1=output, 2=both */
! 284:
! 285: return bpp_send(sc, &pkt, WAIT);
! 286: }
! 287: #endif
! 288:
! 289: int
! 290: vx_mctl(dev_t dev, int bits, int how)
! 291: {
! 292: int s, unit, port;
! 293: struct vxsoftc *sc;
! 294: struct vx_info *vxt;
! 295: u_char msvr;
! 296:
! 297: unit = VX_UNIT(dev);
! 298: port = VX_PORT(dev);
! 299: sc = (struct vxsoftc *)vx_cd.cd_devs[unit];
! 300: vxt = &sc->sc_info[port];
! 301:
! 302: s = splvx();
! 303: switch (how) {
! 304: case DMSET:
! 305: if (bits & TIOCM_RTS) {
! 306: rts_ctl(sc, port, 1);
! 307: vxt->vx_linestatus |= TIOCM_RTS;
! 308: } else {
! 309: rts_ctl(sc, port, 0);
! 310: vxt->vx_linestatus &= ~TIOCM_RTS;
! 311: }
! 312: if (bits & TIOCM_DTR) {
! 313: dtr_ctl(sc, port, 1);
! 314: vxt->vx_linestatus |= TIOCM_DTR;
! 315: } else {
! 316: dtr_ctl(sc, port, 0);
! 317: vxt->vx_linestatus &= ~TIOCM_DTR;
! 318: }
! 319: break;
! 320: case DMBIC:
! 321: if (bits & TIOCM_RTS) {
! 322: rts_ctl(sc, port, 0);
! 323: vxt->vx_linestatus &= ~TIOCM_RTS;
! 324: }
! 325: if (bits & TIOCM_DTR) {
! 326: dtr_ctl(sc, port, 0);
! 327: vxt->vx_linestatus &= ~TIOCM_DTR;
! 328: }
! 329: break;
! 330:
! 331: case DMBIS:
! 332: if (bits & TIOCM_RTS) {
! 333: rts_ctl(sc, port, 1);
! 334: vxt->vx_linestatus |= TIOCM_RTS;
! 335: }
! 336: if (bits & TIOCM_DTR) {
! 337: dtr_ctl(sc, port, 1);
! 338: vxt->vx_linestatus |= TIOCM_DTR;
! 339: }
! 340: break;
! 341:
! 342: case DMGET:
! 343: bits = 0;
! 344: msvr = vxt->vx_linestatus;
! 345: if (msvr & TIOCM_DSR) {
! 346: bits |= TIOCM_DSR;
! 347: }
! 348: if (msvr & TIOCM_CD) {
! 349: bits |= TIOCM_CD;
! 350: }
! 351: if (msvr & TIOCM_CTS) {
! 352: bits |= TIOCM_CTS;
! 353: }
! 354: if (msvr & TIOCM_DTR) {
! 355: bits |= TIOCM_DTR;
! 356: }
! 357: if (msvr & TIOCM_RTS) {
! 358: bits |= TIOCM_RTS;
! 359: }
! 360: break;
! 361: }
! 362:
! 363: splx(s);
! 364:
! 365: #if 0
! 366: bits = 0;
! 367: bits |= TIOCM_DTR;
! 368: bits |= TIOCM_RTS;
! 369: bits |= TIOCM_CTS;
! 370: bits |= TIOCM_CD;
! 371: bits |= TIOCM_DSR;
! 372: #endif
! 373: return (bits);
! 374: }
! 375:
! 376: int
! 377: vxopen(dev_t dev, int flag, int mode, struct proc *p)
! 378: {
! 379: int s, unit, port, error;
! 380: struct vx_info *vxt;
! 381: struct vxsoftc *sc;
! 382: struct tty *tp;
! 383: struct packet opkt;
! 384: u_short code;
! 385:
! 386: unit = VX_UNIT(dev);
! 387: port = VX_PORT(dev);
! 388: if (unit >= vx_cd.cd_ndevs ||
! 389: (sc = (struct vxsoftc *) vx_cd.cd_devs[unit]) == NULL) {
! 390: return (ENODEV);
! 391: }
! 392: vxt = &sc->sc_info[port];
! 393:
! 394: #if 0
! 395: flush_ctl(sc, port, 2);
! 396: #endif
! 397:
! 398: bzero(&opkt, sizeof(struct packet));
! 399: opkt.command_pipe_number = sc->channel_number;
! 400: opkt.status_pipe_number = sc->channel_number;
! 401: opkt.command = CMD_OPEN;
! 402: opkt.device_number = port;
! 403:
! 404: if ((error = bpp_send(sc, &opkt, WAIT)) != 0) {
! 405: #ifdef DEBUG_VXT
! 406: printf("unit %d, port %d, ", unit, port);
! 407: printf("error = %d\n", error);
! 408: #endif
! 409: return (ENXIO);
! 410: }
! 411:
! 412: code = opkt.event_code;
! 413:
! 414: s = splvx();
! 415: if (vxt->tty) {
! 416: tp = vxt->tty;
! 417: } else {
! 418: tp = vxt->tty = ttymalloc();
! 419: }
! 420:
! 421: /* set line status */
! 422: tp->t_state |= TS_CARR_ON;
! 423: if (code & E_DCD) {
! 424: tp->t_state |= TS_CARR_ON;
! 425: vxt->vx_linestatus |= TIOCM_CD;
! 426: }
! 427: if (code & E_DSR) {
! 428: vxt->vx_linestatus |= TIOCM_DSR;
! 429: }
! 430: if (code & E_CTS) {
! 431: vxt->vx_linestatus |= TIOCM_CTS;
! 432: }
! 433:
! 434: tp->t_oproc = vxstart;
! 435: tp->t_param = vx_param;
! 436: tp->t_dev = dev;
! 437:
! 438: if ((tp->t_state & TS_ISOPEN) == 0) {
! 439: tp->t_state |= TS_WOPEN;
! 440: ttychars(tp);
! 441: if (tp->t_ispeed == 0) {
! 442: /*
! 443: * only when cleared do we reset to defaults.
! 444: */
! 445: tp->t_iflag = TTYDEF_IFLAG;
! 446: tp->t_oflag = TTYDEF_OFLAG;
! 447: tp->t_lflag = TTYDEF_LFLAG;
! 448: tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
! 449: tp->t_cflag = TTYDEF_CFLAG;
! 450: }
! 451: /*
! 452: * do these all the time
! 453: */
! 454: if (vxt->vx_swflags & TIOCFLAG_CLOCAL)
! 455: tp->t_cflag |= CLOCAL;
! 456: if (vxt->vx_swflags & TIOCFLAG_CRTSCTS)
! 457: tp->t_cflag |= CRTSCTS;
! 458: if (vxt->vx_swflags & TIOCFLAG_MDMBUF)
! 459: tp->t_cflag |= MDMBUF;
! 460: vx_param(tp, &tp->t_termios);
! 461: ttsetwater(tp);
! 462:
! 463: (void)vx_mctl(dev, TIOCM_DTR | TIOCM_RTS, DMSET);
! 464:
! 465: tp->t_state |= TS_CARR_ON;
! 466: } else if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0) {
! 467: splx(s);
! 468: return (EBUSY);
! 469: }
! 470:
! 471: /*
! 472: * Reset the tty pointer, as there could have been a dialout
! 473: * use of the tty with a dialin open waiting.
! 474: */
! 475: tp->t_dev = dev;
! 476: vxt->open = 1;
! 477: splx(s);
! 478: return (*linesw[tp->t_line].l_open)(dev, tp);
! 479: }
! 480:
! 481: int
! 482: vx_param(struct tty *tp, struct termios *t)
! 483: {
! 484: int unit, port;
! 485: struct vxsoftc *sc;
! 486: dev_t dev;
! 487:
! 488: dev = tp->t_dev;
! 489: unit = VX_UNIT(dev);
! 490: if (unit >= vx_cd.cd_ndevs ||
! 491: (sc = (struct vxsoftc *) vx_cd.cd_devs[unit]) == NULL) {
! 492: return (ENODEV);
! 493: }
! 494: port = VX_PORT(dev);
! 495: tp->t_ispeed = t->c_ispeed;
! 496: tp->t_ospeed = t->c_ospeed;
! 497: tp->t_cflag = t->c_cflag;
! 498: vx_ccparam(sc, t, port);
! 499: vx_unblock(tp);
! 500: return 0;
! 501: }
! 502:
! 503: int
! 504: vxclose(dev_t dev, int flag, int mode, struct proc *p)
! 505: {
! 506: int unit, port;
! 507: struct tty *tp;
! 508: struct vx_info *vxt;
! 509: struct vxsoftc *sc;
! 510: int s;
! 511: struct packet cpkt;
! 512:
! 513: unit = VX_UNIT(dev);
! 514: if (unit >= vx_cd.cd_ndevs ||
! 515: (sc = (struct vxsoftc *) vx_cd.cd_devs[unit]) == NULL) {
! 516: return (ENODEV);
! 517: }
! 518: port = VX_PORT(dev);
! 519: vxt = &sc->sc_info[port];
! 520: #if 0
! 521: flush_ctl(sc, port, 2); /* flush both input and output */
! 522: #endif
! 523:
! 524: tp = vxt->tty;
! 525: (*linesw[tp->t_line].l_close)(tp, flag);
! 526:
! 527: s = splvx();
! 528:
! 529: if ((tp->t_cflag & HUPCL) != 0) {
! 530: rts_ctl(sc, port, 0);
! 531: dtr_ctl(sc, port, 0);
! 532: }
! 533:
! 534: bzero(&cpkt, sizeof(struct packet));
! 535: cpkt.command_pipe_number = sc->channel_number;
! 536: cpkt.status_pipe_number = sc->channel_number;
! 537: cpkt.command = CMD_CLOSE;
! 538: cpkt.device_number = port;
! 539: bpp_send(sc, &cpkt, NOWAIT);
! 540:
! 541: vxt->open = 0;
! 542: splx(s);
! 543: ttyclose(tp);
! 544:
! 545: return (0);
! 546: }
! 547:
! 548: void
! 549: read_wakeup(struct vxsoftc *sc, int port)
! 550: {
! 551: struct packet rwp;
! 552: struct vx_info *volatile vxt;
! 553:
! 554: vxt = &sc->sc_info[port];
! 555: /*
! 556: * If we already have a read_wakeup paket
! 557: * for this port, do nothing.
! 558: */
! 559: if (vxt->read_pending != 0)
! 560: return;
! 561: else
! 562: vxt->read_pending = 1;
! 563:
! 564: bzero(&rwp, sizeof(struct packet));
! 565: rwp.command_pipe_number = sc->channel_number;
! 566: rwp.status_pipe_number = sc->channel_number;
! 567: rwp.command = CMD_READW;
! 568: rwp.device_number = port;
! 569:
! 570: /*
! 571: * Do not wait. Characters will be transferred
! 572: * to (*linesw[tp->t_line].l_rint)(c, tp); by
! 573: * vx_intr() (IPC will notify via interrupt)
! 574: */
! 575: bpp_send(sc, &rwp, NOWAIT);
! 576: }
! 577:
! 578: int
! 579: vxread(dev_t dev, struct uio *uio, int flag)
! 580: {
! 581: int unit, port;
! 582: struct tty *tp;
! 583: struct vx_info *volatile vxt;
! 584: struct vxsoftc *volatile sc;
! 585:
! 586: unit = VX_UNIT(dev);
! 587: if (unit >= vx_cd.cd_ndevs ||
! 588: (sc = (struct vxsoftc *) vx_cd.cd_devs[unit]) == NULL) {
! 589: return (ENODEV);
! 590: }
! 591: port = VX_PORT(dev);
! 592: vxt = &sc->sc_info[port];
! 593: tp = vxt->tty;
! 594: if (!tp)
! 595: return ENXIO;
! 596: return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
! 597: }
! 598:
! 599: int
! 600: vxwrite(dev_t dev, struct uio *uio, int flag)
! 601: {
! 602: int unit, port;
! 603: struct tty *tp;
! 604: struct vx_info *vxt;
! 605: struct vxsoftc *sc;
! 606: struct wring *wp;
! 607: struct packet wwp;
! 608: u_short get, put;
! 609:
! 610: unit = VX_UNIT(dev);
! 611: if (unit >= vx_cd.cd_ndevs ||
! 612: (sc = (struct vxsoftc *) vx_cd.cd_devs[unit]) == NULL) {
! 613: return (ENODEV);
! 614: }
! 615: port = VX_PORT(dev);
! 616: vxt = &sc->sc_info[port];
! 617: tp = vxt->tty;
! 618: if (!tp)
! 619: return ENXIO;
! 620:
! 621: wp = sc->sc_info[port].wringp;
! 622: get = wp->get;
! 623: put = wp->put;
! 624: if ((put + 1) == get) {
! 625: bzero(&wwp, sizeof(struct packet));
! 626: wwp.command_pipe_number = sc->channel_number;
! 627: wwp.status_pipe_number = sc->channel_number;
! 628: wwp.command = CMD_WRITEW;
! 629: wwp.device_number = port;
! 630: if (bpp_send(sc, &wwp, WAIT))
! 631: return (ENXIO);
! 632: }
! 633:
! 634: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
! 635: }
! 636:
! 637: int
! 638: vxioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
! 639: {
! 640: int error;
! 641: int unit, port;
! 642: struct tty *tp;
! 643: struct vx_info *vxt;
! 644: struct vxsoftc *sc;
! 645:
! 646: unit = VX_UNIT(dev);
! 647: if (unit >= vx_cd.cd_ndevs ||
! 648: (sc = (struct vxsoftc *) vx_cd.cd_devs[unit]) == NULL) {
! 649: return (ENODEV);
! 650: }
! 651: port = VX_PORT(dev);
! 652: vxt = &sc->sc_info[port];
! 653: tp = vxt->tty;
! 654: if (!tp)
! 655: return ENXIO;
! 656:
! 657: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
! 658: if (error >= 0)
! 659: return (error);
! 660:
! 661: error = ttioctl(tp, cmd, data, flag, p);
! 662: if (error >= 0)
! 663: return (error);
! 664:
! 665: switch (cmd) {
! 666: case TIOCSBRK:
! 667: /* */
! 668: break;
! 669:
! 670: case TIOCCBRK:
! 671: /* */
! 672: break;
! 673:
! 674: case TIOCSDTR:
! 675: vx_mctl(dev, TIOCM_DTR | TIOCM_RTS, DMBIS);
! 676: break;
! 677:
! 678: case TIOCCDTR:
! 679: vx_mctl(dev, TIOCM_DTR | TIOCM_RTS, DMBIC);
! 680: break;
! 681:
! 682: case TIOCMSET:
! 683: vx_mctl(dev, *(int *)data, DMSET);
! 684: break;
! 685:
! 686: case TIOCMBIS:
! 687: vx_mctl(dev, *(int *)data, DMBIS);
! 688: break;
! 689:
! 690: case TIOCMBIC:
! 691: vx_mctl(dev, *(int *)data, DMBIC);
! 692: break;
! 693:
! 694: case TIOCMGET:
! 695: *(int *)data = vx_mctl(dev, 0, DMGET);
! 696: break;
! 697:
! 698: case TIOCGFLAGS:
! 699: *(int *)data = vxt->vx_swflags;
! 700: break;
! 701:
! 702: case TIOCSFLAGS:
! 703: error = suser(p, 0);
! 704: if (error != 0)
! 705: return (EPERM);
! 706:
! 707: vxt->vx_swflags = *(int *)data;
! 708: vxt->vx_swflags &= /* only allow valid flags */
! 709: (TIOCFLAG_SOFTCAR | TIOCFLAG_CLOCAL | TIOCFLAG_CRTSCTS);
! 710: break;
! 711:
! 712: default:
! 713: return (ENOTTY);
! 714: }
! 715:
! 716: return 0;
! 717: }
! 718:
! 719: int
! 720: vxstop(struct tty *tp, int flag)
! 721: {
! 722: int s;
! 723:
! 724: s = splvx();
! 725: if (tp->t_state & TS_BUSY) {
! 726: if ((tp->t_state & TS_TTSTOP) == 0)
! 727: tp->t_state |= TS_FLUSH;
! 728: }
! 729: splx(s);
! 730: return 0;
! 731: }
! 732:
! 733: void
! 734: vxputc(struct vxsoftc *sc, int port, u_char c)
! 735: {
! 736: struct wring *wp;
! 737:
! 738: wp = sc->sc_info[port].wringp;
! 739: wp->data[wp->put++ & (WRING_BUF_SIZE - 1)] = c;
! 740: wp->put &= (WRING_BUF_SIZE - 1);
! 741: }
! 742:
! 743: u_short
! 744: vxtspeed(int speed)
! 745: {
! 746: switch (speed) {
! 747: case B0:
! 748: return VB0;
! 749: case B50:
! 750: return VB50;
! 751: case B75:
! 752: return VB75;
! 753: case B110:
! 754: return VB110;
! 755: case B134:
! 756: return VB134;
! 757: case B150:
! 758: return VB150;
! 759: case B200:
! 760: return VB200;
! 761: case B300:
! 762: return VB300;
! 763: case B600:
! 764: return VB600;
! 765: case B1200:
! 766: return VB1200;
! 767: case B1800:
! 768: return VB1800;
! 769: case B2400:
! 770: return VB2400;
! 771: case B4800:
! 772: return VB4800;
! 773: case B9600:
! 774: return VB9600;
! 775: case B19200:
! 776: return VB19200;
! 777: case B38400:
! 778: return VB38400;
! 779: default:
! 780: return VB9600;
! 781: }
! 782: }
! 783:
! 784: int
! 785: vx_ccparam(struct vxsoftc *sc, struct termios *par, int port)
! 786: {
! 787: int imask = 0, s;
! 788: int cflag;
! 789: struct packet pkt;
! 790:
! 791: if (par->c_ospeed == 0) {
! 792: s = splvx();
! 793: /* disconnect, drop RTS DTR stop receiver */
! 794: rts_ctl(sc, port, 0);
! 795: dtr_ctl(sc, port, 0);
! 796: splx(s);
! 797: return (0xff);
! 798: }
! 799:
! 800: bzero(&pkt, sizeof(struct packet));
! 801: pkt.command = CMD_IOCTL;
! 802: pkt.ioctl_cmd_l = IOCTL_TCGETA;
! 803: pkt.command_pipe_number = sc->channel_number;
! 804: pkt.status_pipe_number = sc->channel_number;
! 805: pkt.device_number = port;
! 806: if (bpp_send(sc, &pkt, WAIT))
! 807: return 0xff;
! 808:
! 809: cflag = pkt.pb.tio.c_cflag;
! 810: cflag |= vxtspeed(par->c_ospeed);
! 811:
! 812: switch (par->c_cflag & CSIZE) {
! 813: case CS5:
! 814: cflag |= VCS5;
! 815: imask = 0x1F;
! 816: break;
! 817: case CS6:
! 818: cflag |= VCS6;
! 819: imask = 0x3F;
! 820: break;
! 821: case CS7:
! 822: cflag |= VCS7;
! 823: imask = 0x7F;
! 824: break;
! 825: default:
! 826: cflag |= VCS8;
! 827: imask = 0xFF;
! 828: }
! 829:
! 830: if (par->c_cflag & PARENB) cflag |= VPARENB;
! 831: else cflag &= ~VPARENB;
! 832: if (par->c_cflag & PARODD) cflag |= VPARODD;
! 833: else cflag &= ~VPARODD;
! 834: if (par->c_cflag & CREAD) cflag |= VCREAD;
! 835: else cflag &= ~VCREAD;
! 836: if (par->c_cflag & CLOCAL) cflag |= VCLOCAL;
! 837: else cflag &= ~VCLOCAL;
! 838: if (par->c_cflag & HUPCL) cflag |= VHUPCL;
! 839: else cflag &= ~VHUPCL;
! 840:
! 841: pkt.command = CMD_IOCTL;
! 842: pkt.ioctl_cmd_l = IOCTL_TCSETA;
! 843: pkt.command_pipe_number = sc->channel_number;
! 844: pkt.status_pipe_number = sc->channel_number;
! 845: pkt.device_number = port;
! 846: pkt.pb.tio.c_cflag = cflag;
! 847: if (bpp_send(sc, &pkt, WAIT))
! 848: return 0xff;
! 849:
! 850: return imask;
! 851: }
! 852:
! 853: void
! 854: vx_unblock(struct tty *tp)
! 855: {
! 856: tp->t_state &= ~TS_FLUSH;
! 857: if (tp->t_outq.c_cc != 0)
! 858: vxstart(tp);
! 859: }
! 860:
! 861: void
! 862: vxstart(struct tty *tp)
! 863: {
! 864: dev_t dev;
! 865: struct vxsoftc *sc;
! 866: struct wring *wp;
! 867: int cc, port, unit, s, cnt, i;
! 868: u_short get, put;
! 869: char buffer[256];
! 870:
! 871: dev = tp->t_dev;
! 872: port = VX_PORT(dev);
! 873: unit = VX_UNIT(dev);
! 874: if (unit >= vx_cd.cd_ndevs ||
! 875: (sc = (struct vxsoftc *) vx_cd.cd_devs[unit]) == NULL) {
! 876: return;
! 877: }
! 878:
! 879: if ((tp->t_state & TS_ISOPEN) == 0)
! 880: return;
! 881:
! 882: s = splvx();
! 883: if ((tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP | TS_FLUSH)) == 0) {
! 884: tp->t_state |= TS_BUSY;
! 885: wp = sc->sc_info[port].wringp;
! 886: get = wp->get;
! 887: put = wp->put;
! 888: cc = tp->t_outq.c_cc;
! 889: while (cc > 0) {
! 890: cnt = min(sizeof buffer, cc);
! 891: cnt = q_to_b(&tp->t_outq, buffer, cnt);
! 892: buffer[cnt] = 0;
! 893: for (i = 0; i < cnt; i++) {
! 894: vxputc(sc, port, buffer[i]);
! 895: }
! 896: cc -= cnt;
! 897: }
! 898: tp->t_state &= ~TS_BUSY;
! 899: }
! 900: splx(s);
! 901: }
! 902:
! 903: void
! 904: read_chars(struct vxsoftc *sc, int port)
! 905: {
! 906: /*
! 907: * This routine is called by vx_intr() when there are
! 908: * characters in the read ring. It will process one
! 909: * cooked line, put the chars in the line disipline ring,
! 910: * and then return. The characters may then
! 911: * be read by vxread.
! 912: */
! 913: struct vx_info *vxt;
! 914: struct rring *rp;
! 915: struct tty *tp;
! 916: u_short get, put;
! 917: int frame_count, i, open;
! 918: char c;
! 919:
! 920: vxt = &sc->sc_info[port];
! 921: tp = vxt->tty;
! 922: rp = vxt->rringp;
! 923: open = vxt->open;
! 924: get = rp->get;
! 925: put = rp->put;
! 926: #ifdef DEBUG_VXT
! 927: printf("read_chars() get=%d, put=%d ", get, put);
! 928: printf("open = %d ring at 0x%x\n", open, rp);
! 929: #endif
! 930: while (get != put) {
! 931: frame_count = rp->data[rp->get++ & (RRING_BUF_SIZE - 1)];
! 932: rp->get &= (RRING_BUF_SIZE - 1);
! 933: for (i = 0; i < frame_count; i++) {
! 934: c = rp->data[rp->get++ & (RRING_BUF_SIZE - 1)];
! 935: rp->get &= (RRING_BUF_SIZE - 1);
! 936: if (open)
! 937: (*linesw[tp->t_line].l_rint)(c, tp);
! 938: }
! 939: c = rp->data[rp->get++ & (RRING_BUF_SIZE - 1)];
! 940: rp->get &= (RRING_BUF_SIZE - 1);
! 941: if (!(c & DELIMITER)) {
! 942: vx_frame(sc, port);
! 943: break;
! 944: } else {
! 945: break;
! 946: }
! 947: get = rp->get;
! 948: put = rp->put;
! 949: }
! 950: vxt->read_pending = 0;
! 951: read_wakeup(sc, port);
! 952: }
! 953:
! 954: void
! 955: ccode(struct vxsoftc *sc, int port, char c)
! 956: {
! 957: struct vx_info *vxt;
! 958: struct tty *tp;
! 959:
! 960: tp = vxt->tty;
! 961: (*linesw[tp->t_line].l_rint)(c, tp);
! 962: }
! 963:
! 964: int
! 965: vx_intr(void *arg)
! 966: {
! 967: struct vxsoftc *sc = arg;
! 968: struct envelope *envp, *next_envp;
! 969: struct packet *pktp, pkt;
! 970: int valid;
! 971: short cmd;
! 972: u_char port;
! 973:
! 974: while (env_isvalid(get_status_head(sc))) {
! 975: pktp = get_packet(sc, get_status_head(sc));
! 976: valid = env_isvalid(get_status_head(sc));
! 977: cmd = pktp->command;
! 978: port = pktp->device_number;
! 979: /*
! 980: * If we are waiting on this packet, store the info
! 981: * so bpp_send can process the packet
! 982: */
! 983: if (sc->sc_bppwait_pktp == pktp)
! 984: d16_bcopy(pktp, &sc->sc_bppwait_pkt, sizeof(struct packet));
! 985:
! 986: d16_bcopy(pktp, &pkt, sizeof(struct packet));
! 987: next_envp = get_next_envelope(sc, get_status_head(sc));
! 988: envp = get_status_head(sc);
! 989: /* return envelope and packet to the free queues */
! 990: put_free_envelope(sc, envp);
! 991: put_free_packet(sc, pktp);
! 992: /* mark new status pipe head pointer */
! 993: set_status_head(sc, next_envp);
! 994: /* if it was valid, process packet */
! 995: switch (cmd) {
! 996: case CMD_READW:
! 997: #ifdef DEBUG_VXT
! 998: printf("READW Packet\n");
! 999: #endif
! 1000: read_chars(sc, port);
! 1001: break;
! 1002: case CMD_WRITEW:
! 1003: #ifdef DEBUG_VXT
! 1004: printf("WRITEW Packet\n"); /* Still don't know XXXsmurph */
! 1005: #endif
! 1006: break;
! 1007: case CMD_EVENT:
! 1008: #ifdef DEBUG_VXT
! 1009: printf("EVENT Packet\n");
! 1010: #endif
! 1011: vx_event(sc, &pkt);
! 1012: break;
! 1013: case CMD_PROCESSED:
! 1014: #ifdef DEBUG_VXT
! 1015: printf("CMD_PROCESSED Packet\n");
! 1016: #endif
! 1017: break;
! 1018: default:
! 1019: #ifdef DEBUG_VXT
! 1020: printf("Other packet 0x%x\n", cmd);
! 1021: #endif
! 1022: break;
! 1023: }
! 1024: }
! 1025: return 1;
! 1026: }
! 1027:
! 1028: int
! 1029: vx_event(struct vxsoftc *sc, struct packet *evntp)
! 1030: {
! 1031: u_short code = evntp->event_code;
! 1032: struct packet evnt;
! 1033: struct vx_info *vxt;
! 1034:
! 1035: vxt = &sc->sc_info[evntp->device_number];
! 1036:
! 1037: if (code & E_INTR) {
! 1038: ccode(sc, evntp->device_number, CINTR);
! 1039: }
! 1040: if (code & E_QUIT) {
! 1041: ccode(sc, evntp->device_number, CQUIT);
! 1042: }
! 1043: if (code & E_HUP) {
! 1044: rts_ctl(sc, evntp->device_number, 0);
! 1045: dtr_ctl(sc, evntp->device_number, 0);
! 1046: }
! 1047: if (code & E_DCD) {
! 1048: vxt->vx_linestatus |= TIOCM_CD;
! 1049: }
! 1050: if (code & E_DSR) {
! 1051: vxt->vx_linestatus |= TIOCM_DSR;
! 1052: }
! 1053: if (code & E_CTS) {
! 1054: vxt->vx_linestatus |= TIOCM_CTS;
! 1055: }
! 1056: if (code & E_LOST_DCD) {
! 1057: vxt->vx_linestatus &= ~TIOCM_CD;
! 1058: }
! 1059: if (code & E_LOST_DSR) {
! 1060: vxt->vx_linestatus &= ~TIOCM_DSR;
! 1061: }
! 1062: if (code & E_LOST_CTS) {
! 1063: vxt->vx_linestatus &= ~TIOCM_CTS;
! 1064: }
! 1065: if (code & E_PR_FAULT) {
! 1066: /* do something... */
! 1067: }
! 1068: if (code & E_PR_POUT) {
! 1069: /* do something... */
! 1070: }
! 1071: if (code & E_PR_SELECT) {
! 1072: /* do something... */
! 1073: }
! 1074: if (code & E_SWITCH) {
! 1075: /* do something... */
! 1076: }
! 1077: if (code & E_BREAK) {
! 1078: vx_break(sc, evntp->device_number);
! 1079: }
! 1080:
! 1081: /* send an event packet back to the device */
! 1082: bzero(&evnt, sizeof(struct packet));
! 1083: evnt.command = CMD_EVENT;
! 1084: evnt.device_number = evntp->device_number;
! 1085: evnt.command_pipe_number = sc->channel_number;
! 1086: /* return status on same channel */
! 1087: evnt.status_pipe_number = sc->channel_number;
! 1088: /* send packet to the firmware */
! 1089: bpp_send(sc, &evnt, NOWAIT);
! 1090:
! 1091: return 1;
! 1092: }
! 1093:
! 1094: void
! 1095: vx_overflow(struct vxsoftc *sc, int port, long *ptime, u_char *msg)
! 1096: {
! 1097: log(LOG_WARNING, "%s port %d: overrun\n",
! 1098: sc->sc_dev.dv_xname, port);
! 1099: }
! 1100:
! 1101: void
! 1102: vx_frame(struct vxsoftc *sc, int port)
! 1103: {
! 1104: log(LOG_WARNING, "%s port %d: frame error\n",
! 1105: sc->sc_dev.dv_xname, port);
! 1106: }
! 1107:
! 1108: void
! 1109: vx_break(struct vxsoftc *sc, int port)
! 1110: {
! 1111: /*
! 1112: * No need to check for a ddb break, as the console can never be on
! 1113: * this hardware.
! 1114: */
! 1115: log(LOG_WARNING, "%s port %d: break detected\n",
! 1116: sc->sc_dev.dv_xname, port);
! 1117: }
! 1118:
! 1119: /*
! 1120: * Initialization and Buffered Pipe Protocol (BPP) code
! 1121: */
! 1122:
! 1123: void
! 1124: create_free_queue(struct vxsoftc *sc)
! 1125: {
! 1126: int i;
! 1127: struct envelope *envp, env;
! 1128: struct packet *pktp, pkt;
! 1129:
! 1130: envp = (struct envelope *)VIRTUAL(ENVELOPE_AREA);
! 1131: sc->elist_head = envp;
! 1132: for (i = 1; i <= NENVELOPES; i++) {
! 1133: bzero(&env, sizeof(struct envelope));
! 1134: if (i == NENVELOPES)
! 1135: env.link = NULL;
! 1136: else
! 1137: env.link = ENVELOPE_AREA + i * sizeof(struct envelope);
! 1138: env.packet_ptr = NULL;
! 1139: env.valid_flag = 0;
! 1140: d16_bcopy(&env, envp, sizeof(struct envelope));
! 1141: envp++;
! 1142: }
! 1143: sc->elist_tail = --envp;
! 1144:
! 1145: pktp = (struct packet *)VIRTUAL(PACKET_AREA);
! 1146: sc->plist_head = pktp;
! 1147: for (i = 1; i <= NPACKETS; i++) {
! 1148: bzero(&pkt, sizeof(struct packet));
! 1149: if (i == NPACKETS)
! 1150: pkt.link = NULL;
! 1151: else
! 1152: pkt.link = PACKET_AREA + i * sizeof(struct packet);
! 1153: d16_bcopy(&pkt, pktp, sizeof(struct packet));
! 1154: pktp++;
! 1155: }
! 1156: sc->plist_tail = --pktp;
! 1157: }
! 1158:
! 1159: void *
! 1160: get_free_envelope(struct vxsoftc *sc)
! 1161: {
! 1162: struct envelope *envp;
! 1163: paddr_t link;
! 1164:
! 1165: envp = sc->elist_head;
! 1166: /* pick envelope next pointer from the envelope itself */
! 1167: d16_bcopy((const void *)&envp->link, &link, sizeof link);
! 1168: sc->elist_head = (struct envelope *)VIRTUAL(link);
! 1169: d16_bzero(envp, sizeof(struct envelope));
! 1170:
! 1171: return envp;
! 1172: }
! 1173:
! 1174: void
! 1175: put_free_envelope(struct vxsoftc *sc, void *ep)
! 1176: {
! 1177: struct envelope *envp = (struct envelope *)ep;
! 1178: u_long link;
! 1179:
! 1180: #if 0
! 1181: d16_bzero(envp, sizeof(struct envelope));
! 1182: #endif
! 1183: /* put envelope next pointer in the envelope itself */
! 1184: link = PHYSICAL((vaddr_t)envp);
! 1185: d16_bzero((void *)&envp->link, sizeof envp->link);
! 1186: d16_bcopy(&link, (void *)&sc->elist_tail->link, sizeof link);
! 1187:
! 1188: sc->elist_tail = envp;
! 1189: }
! 1190:
! 1191: void *
! 1192: get_free_packet(struct vxsoftc *sc)
! 1193: {
! 1194: struct packet *pktp;
! 1195: paddr_t link;
! 1196:
! 1197: pktp = sc->plist_head;
! 1198: /* pick packet next pointer from the packet itself */
! 1199: d16_bcopy((const void *)&pktp->link, &link, sizeof link);
! 1200: sc->plist_head = (struct packet *)VIRTUAL(link);
! 1201: d16_bzero(pktp, sizeof(struct packet));
! 1202:
! 1203: return pktp;
! 1204: }
! 1205:
! 1206: void
! 1207: put_free_packet(struct vxsoftc *sc, void *pp)
! 1208: {
! 1209: struct packet *pktp = (struct packet *)pp;
! 1210: u_long link;
! 1211:
! 1212: #if 0
! 1213: d16_bzero(pktp, sizeof(struct packet));
! 1214: #endif
! 1215: pktp->command = CMD_PROCESSED;
! 1216: /* put packet next pointer in the packet itself */
! 1217: link = PHYSICAL((vaddr_t)pktp);
! 1218: d16_bzero((void *)&pktp->link, sizeof pktp->link);
! 1219: d16_bcopy(&link, (void *)&sc->plist_tail->link, sizeof link);
! 1220:
! 1221: sc->plist_tail = pktp;
! 1222: }
! 1223:
! 1224: /*
! 1225: * This is the nitty gritty. All the rest if this code
! 1226: * was hell to come by. Getting this right from the
! 1227: * Moto manual took *time*!
! 1228: */
! 1229: int
! 1230: create_channels(struct vxsoftc *sc)
! 1231: {
! 1232: u_long envp;
! 1233: u_short status;
! 1234: u_short tas;
! 1235: struct vxreg *ipc_csr = sc->vx_reg;
! 1236:
! 1237: /* wait for busy bit to clear */
! 1238: while ((ipc_csr->ipc_cr & IPC_CR_BUSY))
! 1239: ;
! 1240:
! 1241: create_free_queue(sc);
! 1242:
! 1243: /* set up channel header. we only want one */
! 1244: tas = ipc_csr->ipc_tas;
! 1245: while (!(tas & IPC_TAS_VALID_STATUS)) {
! 1246: envp = PHYSICAL((vaddr_t)get_free_envelope(sc));
! 1247: sc->channel->command_pipe_head_ptr_h = HI(envp);
! 1248: sc->channel->command_pipe_head_ptr_l = LO(envp);
! 1249: sc->channel->command_pipe_tail_ptr_h =
! 1250: sc->channel->command_pipe_head_ptr_h;
! 1251: sc->channel->command_pipe_tail_ptr_l =
! 1252: sc->channel->command_pipe_head_ptr_l;
! 1253: envp = PHYSICAL((vaddr_t)get_free_envelope(sc));
! 1254: sc->channel->status_pipe_head_ptr_h = HI(envp);
! 1255: sc->channel->status_pipe_head_ptr_l = LO(envp);
! 1256: sc->channel->status_pipe_tail_ptr_h =
! 1257: sc->channel->status_pipe_head_ptr_h;
! 1258: sc->channel->status_pipe_tail_ptr_l =
! 1259: sc->channel->status_pipe_head_ptr_l;
! 1260: sc->channel->interrupt_level = IPL_TTY;
! 1261: sc->channel->interrupt_vec = sc->sc_vec;
! 1262: sc->channel->channel_priority = 0;
! 1263: sc->channel->channel_number = 0;
! 1264: sc->channel->valid = 1;
! 1265: sc->channel->address_modifier = 0x8d; /* A32/D16 supervisor data access */
! 1266: sc->channel->datasize = 0; /* 32 bit data mode */
! 1267:
! 1268: /* loop until TAS bit is zero */
! 1269: while ((ipc_csr->ipc_tas & IPC_TAS_TAS))
! 1270: ;
! 1271: ipc_csr->ipc_tas |= IPC_TAS_TAS;
! 1272: /* load address of channel header */
! 1273: ipc_csr->ipc_addrh = HI(CHANNEL_H);
! 1274: ipc_csr->ipc_addrl = LO(CHANNEL_H);
! 1275: /* load address modifier reg (supervisor data access) */
! 1276: ipc_csr->ipc_amr = 0x8d;
! 1277: /* load tas with create channel command */
! 1278: ipc_csr->ipc_tas |= IPC_CSR_CREATE;
! 1279: /* set vaild command bit */
! 1280: ipc_csr->ipc_tas |= IPC_TAS_VALID_CMD;
! 1281: /* notify IPC of the CSR command */
! 1282: ipc_csr->ipc_cr |= IPC_CR_ATTEN;
! 1283:
! 1284: /* loop until IPC sets valid status bit */
! 1285: delay(5000);
! 1286: tas = ipc_csr->ipc_tas;
! 1287: }
! 1288:
! 1289: /* save the status */
! 1290: status = ipc_csr->ipc_sr;
! 1291: /* set COMMAND COMPLETE bit */
! 1292: ipc_csr->ipc_tas |= IPC_TAS_COMPLETE;
! 1293: /* notify IPC that we are through */
! 1294: ipc_csr->ipc_cr |= IPC_CR_ATTEN;
! 1295: /* check and see if the channel was created */
! 1296: if (status == 0 && sc->channel->valid) {
! 1297: sc->channel_number = sc->channel->channel_number;
! 1298: #ifdef DEBUG_VXT
! 1299: printf("%s: created channel %d\n", sc->sc_dev.dv_xname,
! 1300: sc->channel->channel_number);
! 1301: #endif
! 1302: return 0;
! 1303: } else {
! 1304: switch (status) {
! 1305: case 0x0000:
! 1306: printf("%s: channel not valid\n",
! 1307: sc->sc_dev.dv_xname);
! 1308: break;
! 1309: case 0xFFFF:
! 1310: printf("%s: invalid CSR command\n",
! 1311: sc->sc_dev.dv_xname);
! 1312: break;
! 1313: case 0xC000:
! 1314: printf("%s: could not read channel structure\n",
! 1315: sc->sc_dev.dv_xname);
! 1316: break;
! 1317: case 0x8000:
! 1318: printf("%s: could not write channel structure\n",
! 1319: sc->sc_dev.dv_xname);
! 1320: break;
! 1321: default:
! 1322: printf("%s: unknown IPC CSR command error 0x%x\n",
! 1323: sc->sc_dev.dv_xname, status);
! 1324: break;
! 1325: }
! 1326: return 1;
! 1327: }
! 1328: }
! 1329:
! 1330: struct envelope *
! 1331: get_next_envelope(struct vxsoftc *sc, struct envelope *thisenv)
! 1332: {
! 1333: paddr_t ptr;
! 1334:
! 1335: d16_bcopy((const void*)&thisenv->link, &ptr, sizeof ptr);
! 1336:
! 1337: return (struct envelope *)VIRTUAL(ptr);
! 1338: }
! 1339:
! 1340: int
! 1341: env_isvalid(struct envelope *thisenv)
! 1342: {
! 1343: return (int)thisenv->valid_flag;
! 1344: }
! 1345:
! 1346: struct envelope *
! 1347: get_cmd_tail(struct vxsoftc *sc)
! 1348: {
! 1349: paddr_t retaddr;
! 1350:
! 1351: retaddr = sc->channel->command_pipe_tail_ptr_h << 16;
! 1352: retaddr += sc->channel->command_pipe_tail_ptr_l;
! 1353: return (struct envelope *)VIRTUAL(retaddr);
! 1354: }
! 1355:
! 1356: struct envelope *
! 1357: get_status_head(struct vxsoftc *sc)
! 1358: {
! 1359: paddr_t retaddr;
! 1360:
! 1361: retaddr = sc->channel->status_pipe_head_ptr_h << 16;
! 1362: retaddr += sc->channel->status_pipe_head_ptr_l;
! 1363: return (struct envelope *)VIRTUAL(retaddr);
! 1364: }
! 1365:
! 1366: void
! 1367: set_status_head(struct vxsoftc *sc, void *envp)
! 1368: {
! 1369: paddr_t ptr;
! 1370:
! 1371: ptr = PHYSICAL((vaddr_t)envp);
! 1372: sc->channel->status_pipe_head_ptr_h = HI(ptr);
! 1373: sc->channel->status_pipe_head_ptr_l = LO(ptr);
! 1374: }
! 1375:
! 1376: struct packet *
! 1377: get_packet(struct vxsoftc *sc, struct envelope *thisenv)
! 1378: {
! 1379: paddr_t baseaddr;
! 1380:
! 1381: if (thisenv == NULL)
! 1382: return NULL;
! 1383:
! 1384: /*
! 1385: * packet ptr returned on status pipe is only last two bytes
! 1386: * so we must supply the full address based on the board address.
! 1387: * This also works for all envelopes because every address is an
! 1388: * offset to the board address.
! 1389: */
! 1390: d16_bcopy((const void *)&thisenv->packet_ptr, &baseaddr, sizeof baseaddr);
! 1391: return (struct packet *)VIRTUAL(baseaddr);
! 1392: }
! 1393:
! 1394: /*
! 1395: * Send a command via BPP
! 1396: */
! 1397: int
! 1398: bpp_send(struct vxsoftc *sc, void *pkt, int wait_flag)
! 1399: {
! 1400: struct envelope *envp;
! 1401: struct packet *pktp;
! 1402: paddr_t ptr;
! 1403: int tmo;
! 1404:
! 1405: /* load up packet in dual port mem */
! 1406: pktp = get_free_packet(sc);
! 1407: d16_bcopy(pkt, pktp, sizeof(struct packet));
! 1408:
! 1409: envp = get_cmd_tail(sc);
! 1410: ptr = PHYSICAL((vaddr_t)get_free_envelope(sc)); /* put a NULL env on the tail */
! 1411: sc->channel->command_pipe_tail_ptr_h = HI(ptr);
! 1412: sc->channel->command_pipe_tail_ptr_l = LO(ptr);
! 1413: d16_bcopy(&ptr, (void *)&envp->link, sizeof envp->link);
! 1414: ptr = PHYSICAL((vaddr_t)pktp);
! 1415: d16_bcopy(&ptr, (void *)&envp->packet_ptr, sizeof envp->packet_ptr);
! 1416: envp->valid_flag = 1;
! 1417:
! 1418: sc->vx_reg->ipc_cr |= IPC_CR_ATTEN;
! 1419:
! 1420: /* wait for a packet to return */
! 1421: if (wait_flag == NOWAIT)
! 1422: return 0;
! 1423:
! 1424: tmo = 0;
! 1425: while (pktp->command != CMD_PROCESSED) {
! 1426: #ifdef DEBUG_VXT
! 1427: printf("Polling for packet 0x%x in envelope 0x%x...\n", pktp, envp);
! 1428: #endif
! 1429: vx_intr(sc);
! 1430: if (++tmo > 20) {
! 1431: printf("%s: bpp_send pkt %x env %x timed out %d\n",
! 1432: sc->sc_dev.dv_xname, pktp, envp, pktp->command);
! 1433: return ETIMEDOUT;
! 1434: }
! 1435: delay(5000);
! 1436: }
! 1437: d16_bcopy(pktp, pkt, sizeof(struct packet));
! 1438: return pktp->error_l;
! 1439: }
! 1440:
! 1441: /*
! 1442: * BPP commands
! 1443: */
! 1444:
! 1445: int
! 1446: vx_init(struct vxsoftc *sc)
! 1447: {
! 1448: int i;
! 1449: int error;
! 1450: struct init_info *infp, inf;
! 1451: paddr_t wringp, rringp;
! 1452: struct packet init;
! 1453: struct packet evnt;
! 1454:
! 1455: /* init wait queue */
! 1456: d16_bzero(&sc->sc_bppwait_pkt, sizeof(struct packet));
! 1457: sc->sc_bppwait_pktp = NULL;
! 1458: /* set up init_info array */
! 1459: wringp = WRING_AREA;
! 1460: rringp = RRING_AREA;
! 1461: infp = (struct init_info *)VIRTUAL(INIT_INFO_AREA);
! 1462:
! 1463: for (i = 0; i < NVXPORTS; i++) {
! 1464: bzero(&inf, sizeof(struct init_info));
! 1465: inf.write_ring_ptr_h = HI(wringp);
! 1466: inf.write_ring_ptr_l = LO(wringp);
! 1467: sc->sc_info[i].wringp = (struct wring *)VIRTUAL(wringp);
! 1468: inf.read_ring_ptr_h = HI(rringp);
! 1469: inf.read_ring_ptr_l = LO(rringp);
! 1470: sc->sc_info[i].rringp = (struct rring *)VIRTUAL(rringp);
! 1471: #ifdef DEBUG_VXT
! 1472: printf("write at 0x%8x, read at 0x%8x\n", wringp, rringp);
! 1473: #endif
! 1474: inf.write_ring_size = WRING_DATA_SIZE;
! 1475: inf.read_ring_size = RRING_DATA_SIZE;
! 1476: inf.def_termio.c_iflag = VBRKINT;
! 1477: inf.def_termio.c_oflag = 0;
! 1478: inf.def_termio.c_cflag = (VB9600 | VCS8);
! 1479:
! 1480: inf.def_termio.c_lflag = VISIG; /* enable signal processing */
! 1481: inf.def_termio.c_line = 1; /* raw line discipline */
! 1482: inf.def_termio.c_cc[0] = CINTR;
! 1483: inf.def_termio.c_cc[1] = CQUIT;
! 1484: inf.def_termio.c_cc[2] = CERASE;
! 1485: inf.def_termio.c_cc[3] = CKILL;
! 1486: inf.def_termio.c_cc[4] = CEOF;
! 1487: inf.def_termio.c_cc[5] = CEOL;
! 1488: d16_bcopy(&inf, infp, sizeof(struct init_info));
! 1489: wringp += sizeof(struct wring);
! 1490: rringp += sizeof(struct rring);
! 1491: infp++;
! 1492: }
! 1493:
! 1494: /* set up init_packet */
! 1495: bzero(&init, sizeof(struct packet));
! 1496: init.command = CMD_INIT;
! 1497: init.command_pipe_number = sc->channel_number;
! 1498: /* return status on the same channel */
! 1499: init.status_pipe_number = sc->channel_number;
! 1500: init.interrupt_level = IPL_TTY;
! 1501: init.interrupt_vec = sc->sc_vec;
! 1502: init.init_info_ptr_h = HI(INIT_INFO_AREA);
! 1503: init.init_info_ptr_l = LO(INIT_INFO_AREA);
! 1504:
! 1505: /* send packet to the firmware and wait for completion */
! 1506: if ((error = bpp_send(sc, &init, WAIT)) != 0)
! 1507: return error;
! 1508:
! 1509: /* send one event packet to each device */
! 1510: for (i = 0; i < NVXPORTS; i++) {
! 1511: bzero(&evnt, sizeof(struct packet));
! 1512: evnt.command = CMD_EVENT;
! 1513: evnt.device_number = i;
! 1514: evnt.command_pipe_number = sc->channel_number;
! 1515: /* return status on same channel */
! 1516: evnt.status_pipe_number = sc->channel_number;
! 1517: /* send packet to the firmware */
! 1518: bpp_send(sc, &evnt, NOWAIT);
! 1519: }
! 1520:
! 1521: return 0;
! 1522: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to vx.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mvme88k / dev