Annotation of sys/arch/sparc/dev/zs.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: zs.c,v 1.43 2006/01/09 20:57:00 miod Exp $ */
! 2: /* $NetBSD: zs.c,v 1.50 1997/10/18 00:00:40 gwr Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1996 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by Gordon W. Ross.
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. All advertising materials mentioning features or use of this software
! 20: * must display the following acknowledgement:
! 21: * This product includes software developed by the NetBSD
! 22: * Foundation, Inc. and its contributors.
! 23: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 24: * contributors may be used to endorse or promote products derived
! 25: * from this software without specific prior written permission.
! 26: *
! 27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 37: * POSSIBILITY OF SUCH DAMAGE.
! 38: */
! 39:
! 40: /*
! 41: * Zilog Z8530 Dual UART driver (machine-dependent part)
! 42: *
! 43: * Runs two serial lines per chip using slave drivers.
! 44: * Plain tty/async lines use the zs_async slave.
! 45: * Sun keyboard/mouse uses the zs_kbd/zs_ms slaves.
! 46: */
! 47:
! 48: #include <sys/param.h>
! 49: #include <sys/systm.h>
! 50: #include <sys/conf.h>
! 51: #include <sys/device.h>
! 52: #include <sys/file.h>
! 53: #include <sys/ioctl.h>
! 54: #include <sys/kernel.h>
! 55: #include <sys/proc.h>
! 56: #include <sys/tty.h>
! 57: #include <sys/time.h>
! 58: #include <sys/syslog.h>
! 59:
! 60: #include <machine/autoconf.h>
! 61: #include <machine/bsd_openprom.h>
! 62: #include <machine/conf.h>
! 63: #include <machine/cpu.h>
! 64: #include <machine/eeprom.h>
! 65: #if defined(SUN4)
! 66: #include <machine/oldmon.h>
! 67: #endif
! 68: #include <machine/psl.h>
! 69: #include <machine/z8530var.h>
! 70:
! 71: #include <dev/cons.h>
! 72: #include <sparc/dev/z8530reg.h>
! 73:
! 74: #include <sparc/sparc/vaddrs.h>
! 75: #include <sparc/sparc/auxioreg.h>
! 76: #include <sparc/dev/cons.h>
! 77:
! 78: #ifdef solbourne
! 79: #include <machine/prom.h>
! 80: #endif
! 81:
! 82: #include <uvm/uvm_extern.h>
! 83:
! 84: #include "zskbd.h"
! 85: #include "zs.h"
! 86:
! 87: /* Make life easier for the initialized arrays here. */
! 88: #if NZS < 3
! 89: #undef NZS
! 90: #define NZS 3
! 91: #endif
! 92:
! 93: /*
! 94: * Some warts needed by z8530tty.c -
! 95: * The default parity REALLY needs to be the same as the PROM uses,
! 96: * or you can not see messages done with printf during boot-up...
! 97: */
! 98: int zs_def_cflag = (CREAD | CS8 | HUPCL);
! 99: int zs_major = 12;
! 100:
! 101: /*
! 102: * The Sun provides a 4.9152 MHz clock to the ZS chips.
! 103: */
! 104: #define PCLK (9600 * 512) /* PCLK pin input clock rate */
! 105:
! 106: /*
! 107: * Select software interrupt bit based on TTY ipl.
! 108: */
! 109: #if IPL_TTY == 1
! 110: # define IE_ZSSOFT IE_L1
! 111: #elif IPL_TTY == 4
! 112: # define IE_ZSSOFT IE_L4
! 113: #elif IPL_TTY == 6
! 114: # define IE_ZSSOFT IE_L6
! 115: #else
! 116: # error "no suitable software interrupt bit"
! 117: #endif
! 118:
! 119: #define ZS_DELAY() (CPU_ISSUN4C ? (0) : delay(2))
! 120:
! 121: /* The layout of this is hardware-dependent (padding, order). */
! 122: struct zschan {
! 123: #if defined(SUN4) || defined(SUN4C) || defined(SUN4M)
! 124: volatile u_char zc_csr; /* ctrl,status, and indirect access */
! 125: u_char zc_xxx0;
! 126: volatile u_char zc_data; /* data */
! 127: u_char zc_xxx1;
! 128: #endif
! 129: #if defined(solbourne)
! 130: volatile u_char zc_csr; /* ctrl,status, and indirect access */
! 131: u_char zc_xxx0[7];
! 132: volatile u_char zc_data; /* data */
! 133: u_char zc_xxx1[7];
! 134: #endif
! 135: };
! 136: struct zsdevice {
! 137: /* Yes, they are backwards. */
! 138: struct zschan zs_chan_b;
! 139: struct zschan zs_chan_a;
! 140: };
! 141:
! 142: /* Saved PROM mappings */
! 143: struct zsdevice *zsaddr[NZS];
! 144:
! 145: /* Flags from cninit() */
! 146: int zs_hwflags[NZS][2];
! 147:
! 148: /* Default speed for each channel */
! 149: int zs_defspeed[NZS][2] = {
! 150: { 9600, /* ttya */
! 151: 9600 }, /* ttyb */
! 152: { 1200, /* keyboard */
! 153: 1200 }, /* mouse */
! 154: { 9600, /* ttyc */
! 155: 9600 }, /* ttyd */
! 156: };
! 157:
! 158: u_char zs_init_reg[16] = {
! 159: 0, /* 0: CMD (reset, etc.) */
! 160: 0, /* 1: No interrupts yet. */
! 161: 0, /* 2: IVECT */
! 162: ZSWR3_RX_8 | ZSWR3_RX_ENABLE,
! 163: ZSWR4_CLK_X16 | ZSWR4_ONESB | ZSWR4_EVENP,
! 164: ZSWR5_TX_8 | ZSWR5_TX_ENABLE,
! 165: 0, /* 6: TXSYNC/SYNCLO */
! 166: 0, /* 7: RXSYNC/SYNCHI */
! 167: 0, /* 8: alias for data port */
! 168: ZSWR9_MASTER_IE | ZSWR9_NO_VECTOR,
! 169: 0, /*10: Misc. TX/RX control bits */
! 170: ZSWR11_TXCLK_BAUD | ZSWR11_RXCLK_BAUD,
! 171: ((PCLK/32)/9600)-2, /*12: BAUDLO (default=9600) */
! 172: 0, /*13: BAUDHI (default=9600) */
! 173: ZSWR14_BAUD_ENA | ZSWR14_BAUD_FROM_PCLK,
! 174: ZSWR15_BREAK_IE /* | ZSWR15_DCD_IE */,
! 175: };
! 176:
! 177: struct zschan *
! 178: zs_get_chan_addr(zs_unit, channel)
! 179: int zs_unit, channel;
! 180: {
! 181: struct zsdevice *addr;
! 182: struct zschan *zc;
! 183:
! 184: if (zs_unit >= NZS)
! 185: return NULL;
! 186: addr = zsaddr[zs_unit];
! 187: if (addr == NULL)
! 188: addr = zsaddr[zs_unit] = findzs(zs_unit);
! 189: if (addr == NULL)
! 190: return NULL;
! 191: if (channel == 0) {
! 192: zc = &addr->zs_chan_a;
! 193: } else {
! 194: zc = &addr->zs_chan_b;
! 195: }
! 196: return (zc);
! 197: }
! 198:
! 199:
! 200: /****************************************************************
! 201: * Autoconfig
! 202: ****************************************************************/
! 203:
! 204: /* Definition of the driver for autoconfig. */
! 205: int zs_match(struct device *, void *, void *);
! 206: void zs_attach(struct device *, struct device *, void *);
! 207: int zs_print(void *, const char *nam);
! 208:
! 209: /* Power management hooks (for Tadpole SPARCbooks) */
! 210: void zs_disable(struct zs_chanstate *);
! 211: int zs_enable(struct zs_chanstate *);
! 212:
! 213: struct cfattach zs_ca = {
! 214: sizeof(struct zsc_softc), zs_match, zs_attach
! 215: };
! 216:
! 217: struct cfdriver zs_cd = {
! 218: NULL, "zs", DV_DULL
! 219: };
! 220:
! 221: /* Interrupt handlers. */
! 222: int zshard(void *);
! 223: int zssoft(void *);
! 224: struct intrhand levelhard = { zshard };
! 225: struct intrhand levelsoft = { zssoft };
! 226:
! 227: int zs_get_speed(struct zs_chanstate *);
! 228:
! 229:
! 230: /*
! 231: * Is the zs chip present?
! 232: */
! 233: int
! 234: zs_match(parent, vcf, aux)
! 235: struct device *parent;
! 236: void *vcf, *aux;
! 237: {
! 238: struct cfdata *cf = (struct cfdata *)vcf;
! 239: struct confargs *ca = (struct confargs *)aux;
! 240: struct romaux *ra = &ca->ca_ra;
! 241:
! 242: if (strcmp(cf->cf_driver->cd_name, ra->ra_name))
! 243: return (0);
! 244:
! 245: #ifdef solbourne
! 246: if (CPU_ISKAP)
! 247: return (ca->ca_bustype == BUS_OBIO);
! 248: #endif
! 249:
! 250: if ((ca->ca_bustype == BUS_MAIN && !CPU_ISSUN4) ||
! 251: (ca->ca_bustype == BUS_OBIO && CPU_ISSUN4M))
! 252: return (getpropint(ra->ra_node, "slave", -2) == cf->cf_unit);
! 253: ra->ra_len = NBPG;
! 254: return (probeget(ra->ra_vaddr, 1) != -1);
! 255: }
! 256:
! 257: /*
! 258: * Attach a found zs.
! 259: *
! 260: * USE ROM PROPERTIES port-a-ignore-cd AND port-b-ignore-cd FOR
! 261: * SOFT CARRIER, AND keyboard PROPERTY FOR KEYBOARD/MOUSE?
! 262: */
! 263: void
! 264: zs_attach(parent, self, aux)
! 265: struct device *parent;
! 266: struct device *self;
! 267: void *aux;
! 268: {
! 269: struct zsc_softc *zsc = (void *) self;
! 270: struct confargs *ca = aux;
! 271: struct romaux *ra = &ca->ca_ra;
! 272: struct zsc_attach_args zsc_args;
! 273: volatile struct zschan *zc;
! 274: struct zs_chanstate *cs;
! 275: int pri, s, zs_unit, channel;
! 276: static int didintr, prevpri;
! 277:
! 278: zs_unit = zsc->zsc_dev.dv_unit;
! 279:
! 280: /* Use the mapping setup by the Sun PROM. */
! 281: if (zsaddr[zs_unit] == NULL)
! 282: zsaddr[zs_unit] = findzs(zs_unit);
! 283:
! 284: if (ca->ca_bustype==BUS_MAIN)
! 285: if ((void*)zsaddr[zs_unit] != ra->ra_vaddr)
! 286: panic("zsattach");
! 287: if (ra->ra_nintr != 1) {
! 288: printf(": expected 1 interrupt, got %d\n", ra->ra_nintr);
! 289: return;
! 290: }
! 291: pri = ra->ra_intr[0].int_pri;
! 292: printf(" pri %d, softpri %d\n", pri, IPL_TTY);
! 293:
! 294: /*
! 295: * Initialize software state for each channel.
! 296: */
! 297: for (channel = 0; channel < 2; channel++) {
! 298: zsc_args.type = "serial";
! 299: /* XXX hardcoded */
! 300: if (zs_unit == 1) {
! 301: if (channel == 0)
! 302: zsc_args.type = "keyboard";
! 303: if (channel == 1)
! 304: zsc_args.type = "mouse";
! 305: }
! 306:
! 307: zsc_args.channel = channel;
! 308: zsc_args.hwflags = zs_hwflags[zs_unit][channel];
! 309: cs = &zsc->zsc_cs[channel];
! 310:
! 311: cs->cs_channel = channel;
! 312: cs->cs_private = NULL;
! 313: cs->cs_ops = &zsops_null;
! 314: cs->cs_brg_clk = PCLK / 16;
! 315:
! 316: zc = zs_get_chan_addr(zs_unit, channel);
! 317:
! 318: cs->cs_reg_csr = &zc->zc_csr;
! 319: cs->cs_reg_data = &zc->zc_data;
! 320:
! 321: bcopy(zs_init_reg, cs->cs_creg, 16);
! 322: bcopy(zs_init_reg, cs->cs_preg, 16);
! 323:
! 324: /* XXX: Get these from the PROM properties! */
! 325: /* XXX: See the mvme167 code. Better. */
! 326: if (zsc_args.hwflags & ZS_HWFLAG_CONSOLE)
! 327: cs->cs_defspeed = zs_get_speed(cs);
! 328: else
! 329: cs->cs_defspeed = zs_defspeed[zs_unit][channel];
! 330: cs->cs_defcflag = zs_def_cflag;
! 331:
! 332: /* Make these correspond to cs_defcflag (-crtscts) */
! 333: cs->cs_rr0_dcd = ZSRR0_DCD;
! 334: cs->cs_rr0_cts = 0;
! 335: cs->cs_wr5_dtr = ZSWR5_DTR | ZSWR5_RTS;
! 336: cs->cs_wr5_rts = 0;
! 337:
! 338: /*
! 339: * Clear the master interrupt enable.
! 340: * The INTENA is common to both channels,
! 341: * so just do it on the A channel.
! 342: */
! 343: if (channel == 0) {
! 344: zs_write_reg(cs, 9, 0);
! 345: }
! 346:
! 347: /*
! 348: * Look for a child driver for this channel.
! 349: * The child attach will setup the hardware.
! 350: */
! 351: if (!config_found(self, (void *)&zsc_args, zs_print)) {
! 352: /* No sub-driver. Just reset it. */
! 353: u_char reset = (channel == 0) ?
! 354: ZSWR9_A_RESET : ZSWR9_B_RESET;
! 355: s = splzs();
! 356: zs_write_reg(cs, 9, reset);
! 357: splx(s);
! 358: }
! 359: }
! 360:
! 361: /*
! 362: * Now safe to install interrupt handlers. Note the arguments
! 363: * to the interrupt handlers aren't used. Note, we only do this
! 364: * once since both SCCs interrupt at the same level and vector.
! 365: */
! 366: if (!didintr) {
! 367: didintr = 1;
! 368: prevpri = pri;
! 369: intr_establish(pri, &levelhard, IPL_ZS, self->dv_xname);
! 370: intr_establish(IPL_TTY, &levelsoft, IPL_TTY, self->dv_xname);
! 371: } else if (pri != prevpri)
! 372: panic("broken zs interrupt scheme");
! 373:
! 374: /*
! 375: * Set the master interrupt enable and interrupt vector.
! 376: * (common to both channels, do it on A)
! 377: */
! 378: cs = &zsc->zsc_cs[0];
! 379: s = splhigh();
! 380: /* interrupt vector */
! 381: zs_write_reg(cs, 2, zs_init_reg[2]);
! 382: /* master interrupt control (enable) */
! 383: zs_write_reg(cs, 9, zs_init_reg[9]);
! 384: splx(s);
! 385:
! 386: #ifdef SUN4M
! 387: /* register power management routines if necessary */
! 388: if (CPU_ISSUN4M) {
! 389: if (getpropint(ra->ra_node, "pwr-on-auxio2", 0))
! 390: for (channel = 0; channel < 2; channel++) {
! 391: cs = &zsc->zsc_cs[channel];
! 392: cs->disable = zs_disable;
! 393: cs->enable = zs_enable;
! 394: cs->enabled = 0;
! 395: }
! 396: }
! 397: #endif
! 398:
! 399: #if 0
! 400: /*
! 401: * XXX: L1A hack - We would like to be able to break into
! 402: * the debugger during the rest of autoconfiguration, so
! 403: * lower interrupts just enough to let zs interrupts in.
! 404: * This is done after both zs devices are attached.
! 405: */
! 406: if (zs_unit == 1) {
! 407: printf("zs1: enabling zs interrupts\n");
! 408: (void)splfd(); /* XXX: splzs - 1 */
! 409: }
! 410: #endif
! 411: }
! 412:
! 413: int
! 414: zs_print(aux, name)
! 415: void *aux;
! 416: const char *name;
! 417: {
! 418: struct zsc_attach_args *args = aux;
! 419:
! 420: if (name != NULL)
! 421: printf("%s:", name);
! 422:
! 423: if (args->channel != -1)
! 424: printf(" channel %d", args->channel);
! 425:
! 426: return UNCONF;
! 427: }
! 428:
! 429: volatile int zssoftpending;
! 430:
! 431: /*
! 432: * Our ZS chips all share a common, autovectored interrupt,
! 433: * so we have to look at all of them on each interrupt.
! 434: */
! 435: int
! 436: zshard(arg)
! 437: void *arg;
! 438: {
! 439: struct zsc_softc *zsc;
! 440: int unit, rr3, rval, softreq;
! 441:
! 442: rval = softreq = 0;
! 443: for (unit = 0; unit < zs_cd.cd_ndevs; unit++) {
! 444: zsc = zs_cd.cd_devs[unit];
! 445: if (zsc == NULL)
! 446: continue;
! 447: rr3 = zsc_intr_hard(zsc);
! 448: /* Count up the interrupts. */
! 449: if (rr3) {
! 450: rval |= rr3;
! 451: }
! 452: softreq |= zsc->zsc_cs[0].cs_softreq;
! 453: softreq |= zsc->zsc_cs[1].cs_softreq;
! 454: }
! 455:
! 456: /* We are at splzs here, so no need to lock. */
! 457: if (softreq && (zssoftpending == 0)) {
! 458: zssoftpending = IE_ZSSOFT;
! 459: #if defined(SUN4M)
! 460: if (CPU_ISSUN4M)
! 461: raise(0, IPL_TTY);
! 462: else
! 463: #endif
! 464: ienab_bis(IE_ZSSOFT);
! 465: }
! 466: return (rval);
! 467: }
! 468:
! 469: /*
! 470: * Similar scheme as for zshard (look at all of them)
! 471: */
! 472: int
! 473: zssoft(arg)
! 474: void *arg;
! 475: {
! 476: struct zsc_softc *zsc;
! 477: int s, unit;
! 478:
! 479: /* This is not the only ISR on this IPL. */
! 480: if (zssoftpending == 0)
! 481: return (0);
! 482:
! 483: /*
! 484: * The soft intr. bit will be set by zshard only if
! 485: * the variable zssoftpending is zero. The order of
! 486: * these next two statements prevents our clearing
! 487: * the soft intr bit just after zshard has set it.
! 488: */
! 489: /* ienab_bic(IE_ZSSOFT); */
! 490: zssoftpending = 0;
! 491:
! 492: /* Make sure we call the tty layer at spltty. */
! 493: s = spltty();
! 494: for (unit = 0; unit < zs_cd.cd_ndevs; unit++) {
! 495: zsc = zs_cd.cd_devs[unit];
! 496: if (zsc == NULL)
! 497: continue;
! 498: (void)zsc_intr_soft(zsc);
! 499: }
! 500: splx(s);
! 501: return (1);
! 502: }
! 503:
! 504:
! 505: /*
! 506: * Compute the current baud rate given a ZS channel.
! 507: */
! 508: int
! 509: zs_get_speed(cs)
! 510: struct zs_chanstate *cs;
! 511: {
! 512: int tconst;
! 513:
! 514: tconst = zs_read_reg(cs, 12);
! 515: tconst |= zs_read_reg(cs, 13) << 8;
! 516: return (TCONST_TO_BPS(cs->cs_brg_clk, tconst));
! 517: }
! 518:
! 519: /*
! 520: * MD functions for setting the baud rate and control modes.
! 521: */
! 522: int
! 523: zs_set_speed(cs, bps)
! 524: struct zs_chanstate *cs;
! 525: int bps; /* bits per second */
! 526: {
! 527: int tconst, real_bps;
! 528:
! 529: if (bps == 0)
! 530: return (0);
! 531:
! 532: #ifdef DIAGNOSTIC
! 533: if (cs->cs_brg_clk == 0)
! 534: panic("zs_set_speed");
! 535: #endif
! 536:
! 537: tconst = BPS_TO_TCONST(cs->cs_brg_clk, bps);
! 538: if (tconst < 0)
! 539: return (EINVAL);
! 540:
! 541: /* Convert back to make sure we can do it. */
! 542: real_bps = TCONST_TO_BPS(cs->cs_brg_clk, tconst);
! 543:
! 544: /* XXX - Allow some tolerance here? */
! 545: if (real_bps != bps)
! 546: return (EINVAL);
! 547:
! 548: cs->cs_preg[12] = tconst;
! 549: cs->cs_preg[13] = tconst >> 8;
! 550:
! 551: /* Caller will stuff the pending registers. */
! 552: return (0);
! 553: }
! 554:
! 555: int
! 556: zs_set_modes(cs, cflag)
! 557: struct zs_chanstate *cs;
! 558: int cflag; /* bits per second */
! 559: {
! 560: int s;
! 561:
! 562: /*
! 563: * Output hardware flow control on the chip is horrendous:
! 564: * if carrier detect drops, the receiver is disabled, and if
! 565: * CTS drops, the transmitter is stoped IN MID CHARACTER!
! 566: * Therefore, NEVER set the HFC bit, and instead use the
! 567: * status interrupt to detect CTS changes.
! 568: */
! 569: s = splzs();
! 570: cs->cs_rr0_pps = 0;
! 571: if ((cflag & (CLOCAL | MDMBUF)) != 0) {
! 572: cs->cs_rr0_dcd = 0;
! 573: if ((cflag & MDMBUF) == 0)
! 574: cs->cs_rr0_pps = ZSRR0_DCD;
! 575: } else
! 576: cs->cs_rr0_dcd = ZSRR0_DCD;
! 577: if ((cflag & CRTSCTS) != 0) {
! 578: cs->cs_wr5_dtr = ZSWR5_DTR;
! 579: cs->cs_wr5_rts = ZSWR5_RTS;
! 580: cs->cs_rr0_cts = ZSRR0_CTS;
! 581: #if 0 /* JLW */
! 582: } else if ((cflag & CDTRCTS) != 0) {
! 583: cs->cs_wr5_dtr = 0;
! 584: cs->cs_wr5_rts = ZSWR5_DTR;
! 585: cs->cs_rr0_cts = ZSRR0_CTS;
! 586: #endif
! 587: } else if ((cflag & MDMBUF) != 0) {
! 588: cs->cs_wr5_dtr = 0;
! 589: cs->cs_wr5_rts = ZSWR5_DTR;
! 590: cs->cs_rr0_cts = ZSRR0_DCD;
! 591: } else {
! 592: cs->cs_wr5_dtr = ZSWR5_DTR | ZSWR5_RTS;
! 593: cs->cs_wr5_rts = 0;
! 594: cs->cs_rr0_cts = 0;
! 595: }
! 596: splx(s);
! 597:
! 598: /* Caller will stuff the pending registers. */
! 599: return (0);
! 600: }
! 601:
! 602:
! 603: /*
! 604: * Read or write the chip with suitable delays.
! 605: */
! 606:
! 607: u_char
! 608: zs_read_reg(cs, reg)
! 609: struct zs_chanstate *cs;
! 610: u_char reg;
! 611: {
! 612: u_char val;
! 613:
! 614: *cs->cs_reg_csr = reg;
! 615: ZS_DELAY();
! 616: val = *cs->cs_reg_csr;
! 617: ZS_DELAY();
! 618: return val;
! 619: }
! 620:
! 621: void
! 622: zs_write_reg(cs, reg, val)
! 623: struct zs_chanstate *cs;
! 624: u_char reg, val;
! 625: {
! 626: *cs->cs_reg_csr = reg;
! 627: ZS_DELAY();
! 628: *cs->cs_reg_csr = val;
! 629: ZS_DELAY();
! 630: }
! 631:
! 632: u_char zs_read_csr(cs)
! 633: struct zs_chanstate *cs;
! 634: {
! 635: register u_char val;
! 636:
! 637: val = *cs->cs_reg_csr;
! 638: ZS_DELAY();
! 639: return val;
! 640: }
! 641:
! 642: void zs_write_csr(cs, val)
! 643: struct zs_chanstate *cs;
! 644: u_char val;
! 645: {
! 646: *cs->cs_reg_csr = val;
! 647: ZS_DELAY();
! 648: }
! 649:
! 650: u_char zs_read_data(cs)
! 651: struct zs_chanstate *cs;
! 652: {
! 653: register u_char val;
! 654:
! 655: val = *cs->cs_reg_data;
! 656: ZS_DELAY();
! 657: return val;
! 658: }
! 659:
! 660: void zs_write_data(cs, val)
! 661: struct zs_chanstate *cs;
! 662: u_char val;
! 663: {
! 664: *cs->cs_reg_data = val;
! 665: ZS_DELAY();
! 666: }
! 667:
! 668: #ifdef SUN4M
! 669: /*
! 670: * Power management hooks for zsopen() and zsclose().
! 671: * We use them to power on/off the ports on the Tadpole SPARCbook machines
! 672: * (on other sun4m machines, this is a no-op).
! 673: */
! 674:
! 675: /*
! 676: * Since the serial power control is global, we need to remember which channels
! 677: * have their ports open, so as not to power off when closing one channel if
! 678: * both were open. Simply xor'ing the zs_chanstate pointers is enough to let us
! 679: * know if the serial lines are used or not.
! 680: */
! 681: static vaddr_t zs_sb_enable = 0;
! 682:
! 683: int
! 684: zs_enable(struct zs_chanstate *cs)
! 685: {
! 686: if (cs->enabled == 0) {
! 687: if (zs_sb_enable == 0)
! 688: sb_auxregbisc(1, AUXIO2_SERIAL, 0);
! 689: zs_sb_enable ^= (vaddr_t)cs;
! 690: cs->enabled = 1;
! 691: }
! 692: return (0);
! 693: }
! 694:
! 695: void
! 696: zs_disable(struct zs_chanstate *cs)
! 697: {
! 698: if (cs->enabled != 0) {
! 699: cs->enabled = 0;
! 700: zs_sb_enable ^= (vaddr_t)cs;
! 701: if (zs_sb_enable == 0)
! 702: sb_auxregbisc(1, 0, AUXIO2_SERIAL);
! 703: }
! 704: }
! 705:
! 706: #endif /* SUN4M */
! 707:
! 708: /****************************************************************
! 709: * Console support functions (Sun specific!)
! 710: * Note: this code is allowed to know about the layout of
! 711: * the chip registers, and uses that to keep things simple.
! 712: * XXX - I think I like the mvme167 code better. -gwr
! 713: ****************************************************************/
! 714:
! 715: extern void Debugger(void);
! 716: void *zs_conschan;
! 717:
! 718: /*
! 719: * Handle user request to enter kernel debugger.
! 720: */
! 721: void
! 722: zs_abort(cs)
! 723: struct zs_chanstate *cs;
! 724: {
! 725: volatile struct zschan *zc = zs_conschan;
! 726: int rr0;
! 727:
! 728: /* Wait for end of break to avoid PROM abort. */
! 729: /* XXX - Limit the wait? */
! 730: do {
! 731: rr0 = zc->zc_csr;
! 732: ZS_DELAY();
! 733: } while (rr0 & ZSRR0_BREAK);
! 734:
! 735: #if defined(KGDB)
! 736: zskgdb(cs);
! 737: #elif defined(DDB)
! 738: {
! 739: extern int db_active;
! 740:
! 741: if (!db_active)
! 742: Debugger();
! 743: else
! 744: /* Debugger is probably hosed */
! 745: callrom();
! 746: }
! 747: #else
! 748: printf("stopping on keyboard abort\n");
! 749: callrom();
! 750: #endif
! 751: }
! 752:
! 753: /*
! 754: * Polled input char.
! 755: */
! 756: int
! 757: zs_getc(arg)
! 758: void *arg;
! 759: {
! 760: volatile struct zschan *zc = arg;
! 761: int s, c, rr0;
! 762:
! 763: s = splhigh();
! 764: /* Wait for a character to arrive. */
! 765: do {
! 766: rr0 = zc->zc_csr;
! 767: ZS_DELAY();
! 768: } while ((rr0 & ZSRR0_RX_READY) == 0);
! 769:
! 770: c = zc->zc_data;
! 771: ZS_DELAY();
! 772: splx(s);
! 773:
! 774: return (c);
! 775: }
! 776:
! 777: /*
! 778: * Polled output char.
! 779: */
! 780: void
! 781: zs_putc(arg, c)
! 782: void *arg;
! 783: int c;
! 784: {
! 785: volatile struct zschan *zc = arg;
! 786: int s, rr0;
! 787:
! 788: s = splhigh();
! 789: /* Wait for transmitter to become ready. */
! 790: do {
! 791: rr0 = zc->zc_csr;
! 792: ZS_DELAY();
! 793: } while ((rr0 & ZSRR0_TX_READY) == 0);
! 794:
! 795: /*
! 796: * Send the next character.
! 797: * Now you'd think that this could be followed by a ZS_DELAY()
! 798: * just like all the other chip accesses, but it turns out that
! 799: * the `transmit-ready' interrupt isn't de-asserted until
! 800: * some period of time after the register write completes
! 801: * (more than a couple instructions). So to avoid stray
! 802: * interrupts we put in the 2us delay regardless of cpu model.
! 803: */
! 804: zc->zc_data = c;
! 805: delay(2);
! 806:
! 807: splx(s);
! 808: }
! 809:
! 810: /*****************************************************************/
! 811:
! 812: cons_decl(zs);
! 813:
! 814: /*
! 815: * Console table shared by ttya, ttyb
! 816: */
! 817: struct consdev consdev_tty = {
! 818: zscnprobe,
! 819: zscninit,
! 820: zscngetc,
! 821: zscnputc,
! 822: zscnpollc,
! 823: };
! 824:
! 825: int zstty_unit; /* set in consinit() */
! 826:
! 827: void
! 828: zscnprobe(cn)
! 829: struct consdev *cn;
! 830: {
! 831: cn->cn_dev = makedev(zs_major, zstty_unit);
! 832: cn->cn_pri = CN_REMOTE;
! 833: }
! 834:
! 835: void
! 836: zscninit(cn)
! 837: struct consdev *cn;
! 838: {
! 839: }
! 840:
! 841: /*
! 842: * Polled console input putchar.
! 843: */
! 844: int
! 845: zscngetc(dev)
! 846: dev_t dev;
! 847: {
! 848: return (zs_getc(zs_conschan));
! 849: }
! 850:
! 851: /*
! 852: * Polled console output putchar.
! 853: */
! 854: void
! 855: zscnputc(dev, c)
! 856: dev_t dev;
! 857: int c;
! 858: {
! 859: zs_putc(zs_conschan, c);
! 860: }
! 861:
! 862: int swallow_zsintrs;
! 863:
! 864: void
! 865: zscnpollc(dev, on)
! 866: dev_t dev;
! 867: int on;
! 868: {
! 869: /*
! 870: * Need to tell zs driver to acknowledge all interrupts or we get
! 871: * annoying spurious interrupt messages. This is because mucking
! 872: * with spl() levels during polling does not prevent interrupts from
! 873: * being generated.
! 874: */
! 875:
! 876: if (on) swallow_zsintrs++;
! 877: else swallow_zsintrs--;
! 878: }
! 879:
! 880: /*****************************************************************/
! 881:
! 882: #if defined(SUN4) || defined(SUN4C) || defined(SUN4M)
! 883:
! 884: cons_decl(prom);
! 885:
! 886: /*
! 887: * The console is set to this one initially,
! 888: * which lets us use the PROM until consinit()
! 889: * is called to select a real console.
! 890: */
! 891: struct consdev consdev_prom = {
! 892: promcnprobe,
! 893: promcninit,
! 894: promcngetc,
! 895: promcnputc,
! 896: nullcnpollc,
! 897: };
! 898:
! 899: /*
! 900: * The console table pointer is statically initialized
! 901: * to point to the PROM (output only) table, so that
! 902: * early calls to printf will work.
! 903: */
! 904: struct consdev *cn_tab = &consdev_prom;
! 905:
! 906: void
! 907: promcnprobe(cn)
! 908: struct consdev *cn;
! 909: {
! 910: cn->cn_dev = makedev(0, 0);
! 911: cn->cn_pri = CN_INTERNAL;
! 912: }
! 913:
! 914: void
! 915: promcninit(cn)
! 916: struct consdev *cn;
! 917: {
! 918: }
! 919:
! 920: /*
! 921: * PROM console input putchar.
! 922: */
! 923: int
! 924: promcngetc(dev)
! 925: dev_t dev;
! 926: {
! 927: int s, c;
! 928:
! 929: if (promvec->pv_romvec_vers > 2) {
! 930: int n = 0;
! 931: unsigned char c0;
! 932:
! 933: s = splhigh();
! 934: while (n <= 0) {
! 935: n = (*promvec->pv_v2devops.v2_read)
! 936: (*promvec->pv_v2bootargs.v2_fd0, &c0, 1);
! 937: }
! 938: splx(s);
! 939:
! 940: c = c0;
! 941: } else {
! 942: #if defined(SUN4)
! 943: /* SUN4 PROM: must turn off local echo */
! 944: extern struct om_vector *oldpvec;
! 945: int saveecho = 0;
! 946: #endif
! 947: s = splhigh();
! 948: #if defined(SUN4)
! 949: if (CPU_ISSUN4) {
! 950: saveecho = *(oldpvec->echo);
! 951: *(oldpvec->echo) = 0;
! 952: }
! 953: #endif
! 954: c = (*promvec->pv_getchar)();
! 955: #if defined(SUN4)
! 956: if (CPU_ISSUN4)
! 957: *(oldpvec->echo) = saveecho;
! 958: #endif
! 959: splx(s);
! 960: }
! 961:
! 962: if (c == '\r')
! 963: c = '\n';
! 964:
! 965: return (c);
! 966: }
! 967:
! 968: /*
! 969: * PROM console output putchar.
! 970: */
! 971: void
! 972: promcnputc(dev, c)
! 973: dev_t dev;
! 974: int c;
! 975: {
! 976: int s;
! 977: char c0 = (c & 0x7f);
! 978:
! 979: s = splhigh();
! 980: if (promvec->pv_romvec_vers > 2)
! 981: (*promvec->pv_v2devops.v2_write)
! 982: (*promvec->pv_v2bootargs.v2_fd1, &c0, 1);
! 983: else
! 984: (*promvec->pv_putchar)(c);
! 985: splx(s);
! 986: }
! 987:
! 988: #endif /* SUN4 || SUN4C || SUN4M */
! 989:
! 990: /*****************************************************************/
! 991:
! 992: #if 0
! 993: extern struct consdev consdev_kd;
! 994: #endif
! 995:
! 996: char *prom_inSrc_name[] = {
! 997: "keyboard/display",
! 998: "ttya", "ttyb",
! 999: "ttyc", "ttyd" };
! 1000:
! 1001: /*
! 1002: * This function replaces sys/dev/cninit.c
! 1003: * Determine which device is the console using
! 1004: * the PROM "input source" and "output sink".
! 1005: */
! 1006: void
! 1007: consinit()
! 1008: {
! 1009: struct zschan *zc;
! 1010: struct consdev *console = cn_tab;
! 1011: int channel, zs_unit;
! 1012: int inSource, outSink;
! 1013:
! 1014: #if defined(SUN4) || defined(SUN4C) || defined(SUN4M)
! 1015: if (promvec->pv_romvec_vers > 2) {
! 1016: /* We need to probe the PROM device tree */
! 1017: int node,fd;
! 1018: char buffer[128];
! 1019: struct nodeops *no;
! 1020: struct v2devops *op;
! 1021: char *cp;
! 1022: extern int fbnode;
! 1023:
! 1024: inSource = outSink = -1;
! 1025: no = promvec->pv_nodeops;
! 1026: op = &promvec->pv_v2devops;
! 1027:
! 1028: node = findroot();
! 1029: if (no->no_proplen(node, "stdin-path") >= sizeof(buffer)) {
! 1030: printf("consinit: increase buffer size and recompile\n");
! 1031: goto setup_output;
! 1032: }
! 1033: /* XXX: fix above */
! 1034:
! 1035: no->no_getprop(node, "stdin-path",buffer);
! 1036:
! 1037: /*
! 1038: * Open an "instance" of this device.
! 1039: * You'd think it would be appropriate to call v2_close()
! 1040: * on the handle when we're done with it. But that seems
! 1041: * to cause the device to shut down somehow; for the moment,
! 1042: * we simply leave it open...
! 1043: */
! 1044: if ((fd = op->v2_open(buffer)) == 0 ||
! 1045: (node = op->v2_fd_phandle(fd)) == 0) {
! 1046: printf("consinit: bogus stdin path %s.\n",buffer);
! 1047: goto setup_output;
! 1048: }
! 1049: if (no->no_proplen(node,"keyboard") >= 0) {
! 1050: inSource = PROMDEV_KBD;
! 1051: goto setup_output;
! 1052: }
! 1053: if (strcmp(getpropstring(node,"device_type"),"serial") != 0) {
! 1054: /* not a serial, not keyboard. what is it?!? */
! 1055: inSource = -1;
! 1056: goto setup_output;
! 1057: }
! 1058: /*
! 1059: * At this point we assume the device path is in the form
! 1060: * ....device@x,y:a for ttya and ...device@x,y:b for ttyb.
! 1061: * If it isn't, we defer to the ROM
! 1062: */
! 1063: cp = buffer;
! 1064: while (*cp)
! 1065: cp++;
! 1066: cp -= 2;
! 1067: #ifdef DEBUG
! 1068: if (cp < buffer)
! 1069: panic("consinit: bad stdin path %s",buffer);
! 1070: #endif
! 1071: /* XXX: only allows tty's a->z, assumes PROMDEV_TTYx contig */
! 1072: if (cp[0]==':' && cp[1] >= 'a' && cp[1] <= 'z')
! 1073: inSource = PROMDEV_TTYA + (cp[1] - 'a');
! 1074: /* else use rom */
! 1075: setup_output:
! 1076: node = findroot();
! 1077: if (no->no_proplen(node, "stdout-path") >= sizeof(buffer)) {
! 1078: printf("consinit: increase buffer size and recompile\n");
! 1079: goto setup_console;
! 1080: }
! 1081: /* XXX: fix above */
! 1082:
! 1083: no->no_getprop(node, "stdout-path", buffer);
! 1084:
! 1085: if ((fd = op->v2_open(buffer)) == 0 ||
! 1086: (node = op->v2_fd_phandle(fd)) == 0) {
! 1087: printf("consinit: bogus stdout path %s.\n",buffer);
! 1088: goto setup_output;
! 1089: }
! 1090: if (strcmp(getpropstring(node,"device_type"),"display") == 0) {
! 1091: /* frame buffer output */
! 1092: outSink = PROMDEV_SCREEN;
! 1093: fbnode = node;
! 1094: } else if (strcmp(getpropstring(node,"device_type"), "serial")
! 1095: != 0) {
! 1096: /* not screen, not serial. Whatzit? */
! 1097: outSink = -1;
! 1098: } else { /* serial console. which? */
! 1099: /*
! 1100: * At this point we assume the device path is in the
! 1101: * form:
! 1102: * ....device@x,y:a for ttya, etc.
! 1103: * If it isn't, we defer to the ROM
! 1104: */
! 1105: cp = buffer;
! 1106: while (*cp)
! 1107: cp++;
! 1108: cp -= 2;
! 1109: #ifdef DEBUG
! 1110: if (cp < buffer)
! 1111: panic("consinit: bad stdout path %s",buffer);
! 1112: #endif
! 1113: /* XXX: only allows tty's a->z, assumes PROMDEV_TTYx contig */
! 1114: if (cp[0]==':' && cp[1] >= 'a' && cp[1] <= 'z')
! 1115: outSink = PROMDEV_TTYA + (cp[1] - 'a');
! 1116: else outSink = -1;
! 1117: }
! 1118: } else {
! 1119: inSource = *promvec->pv_stdin;
! 1120: outSink = *promvec->pv_stdout;
! 1121: }
! 1122: #endif /* SUN4 || SUN4C || SUN4M */
! 1123: #ifdef solbourne
! 1124: if (CPU_ISKAP) {
! 1125: const char *dev;
! 1126:
! 1127: inSource = PROMDEV_TTYA; /* default */
! 1128: dev = prom_getenv(ENV_INPUTDEVICE);
! 1129: if (dev != NULL) {
! 1130: if (strcmp(dev, "ttyb") == 0)
! 1131: inSource = PROMDEV_TTYB;
! 1132: if (strcmp(dev, "keyboard") == 0)
! 1133: inSource = PROMDEV_KBD;
! 1134: }
! 1135:
! 1136: outSink = PROMDEV_TTYA; /* default */
! 1137: dev = prom_getenv(ENV_OUTPUTDEVICE);
! 1138: if (dev != NULL) {
! 1139: if (strcmp(dev, "ttyb") == 0)
! 1140: outSink = PROMDEV_TTYB;
! 1141: if (strcmp(dev, "screen") == 0)
! 1142: outSink = PROMDEV_SCREEN;
! 1143: }
! 1144: }
! 1145: #endif
! 1146:
! 1147: #if defined(SUN4) || defined(SUN4C) || defined(SUN4M)
! 1148: setup_console:
! 1149: #endif
! 1150:
! 1151: if (inSource != outSink) {
! 1152: printf("cninit: mismatched PROM output selector\n");
! 1153: }
! 1154:
! 1155: switch (inSource) {
! 1156: default:
! 1157: printf("cninit: invalid inSource=%d\n", inSource);
! 1158: callrom();
! 1159: inSource = PROMDEV_KBD;
! 1160: /* FALLTHROUGH */
! 1161:
! 1162: case PROMDEV_KBD: /* keyboard/display */
! 1163: #if NZSKBD > 0
! 1164: zs_unit = 1;
! 1165: channel = 0;
! 1166: break;
! 1167: #else /* NZSKBD */
! 1168: printf("cninit: kdb/display not configured\n");
! 1169: callrom();
! 1170: inSource = PROMDEV_TTYA;
! 1171: /* FALLTHROUGH */
! 1172: #endif /* NZSKBD */
! 1173:
! 1174: case PROMDEV_TTYA:
! 1175: case PROMDEV_TTYB:
! 1176: zstty_unit = inSource - PROMDEV_TTYA;
! 1177: zs_unit = 0;
! 1178: channel = zstty_unit & 1;
! 1179: console = &consdev_tty;
! 1180: break;
! 1181:
! 1182: }
! 1183: /* Now that inSource has been validated, print it. */
! 1184: printf("console is %s\n", prom_inSrc_name[inSource]);
! 1185:
! 1186: zc = zs_get_chan_addr(zs_unit, channel);
! 1187: if (zc == NULL) {
! 1188: printf("cninit: zs not mapped.\n");
! 1189: return;
! 1190: }
! 1191: zs_conschan = zc;
! 1192: zs_hwflags[zs_unit][channel] = ZS_HWFLAG_CONSOLE;
! 1193: /* switch to selected console */
! 1194: cn_tab = console;
! 1195: (*cn_tab->cn_probe)(cn_tab);
! 1196: (*cn_tab->cn_init)(cn_tab);
! 1197: #ifdef KGDB
! 1198: zs_kgdb_init();
! 1199: #endif
! 1200: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to zs.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc / dev