1 /* $NetBSD: zs.c,v 1.39 2015/02/18 16:47:58 macallan Exp $ */ 2 3 /*- 4 * Copyright (c) 1996, 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Gordon W. Ross and Wayne Knowles 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Zilog Z8530 Dual UART driver (machine-dependent part) 34 * 35 * Runs two serial lines per chip using slave drivers. 36 * Plain tty/async lines use the zs_async slave. 37 */ 38 39 #include <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: zs.c,v 1.39 2015/02/18 16:47:58 macallan Exp $"); 41 42 #include "opt_ddb.h" 43 #include "opt_kgdb.h" 44 45 #include <sys/param.h> 46 #include <sys/systm.h> 47 #include <sys/conf.h> 48 #include <sys/device.h> 49 #include <sys/file.h> 50 #include <sys/ioctl.h> 51 #include <sys/kernel.h> 52 #include <sys/proc.h> 53 #include <sys/tty.h> 54 #include <sys/time.h> 55 #include <sys/syslog.h> 56 #include <sys/cpu.h> 57 #include <sys/intr.h> 58 59 #include <machine/machtype.h> 60 #include <machine/autoconf.h> 61 #include <machine/z8530var.h> 62 63 #include <dev/cons.h> 64 #include <dev/ic/z8530reg.h> 65 66 #include <sgimips/hpc/hpcvar.h> 67 #include <sgimips/hpc/hpcreg.h> 68 69 #include <dev/arcbios/arcbios.h> 70 #include <dev/arcbios/arcbiosvar.h> 71 72 #include "ioconf.h" 73 74 /* 75 * Some warts needed by z8530tty.c - 76 * The default parity REALLY needs to be the same as the PROM uses, 77 * or you can not see messages done with printf during boot-up... 78 */ 79 int zs_def_cflag = (CREAD | CS8 | HUPCL); 80 81 #define PCLK 3672000 /* PCLK pin input clock rate */ 82 83 #ifndef ZS_DEFSPEED 84 #define ZS_DEFSPEED 9600 85 #endif 86 87 /* 88 * Define interrupt levels. 89 */ 90 #define ZSHARD_PRI 64 91 92 /* SGI shouldn't need ZS_DELAY() as recovery time is done in hardware? */ 93 #define ZS_DELAY() delay(3) 94 95 /* The layout of this is hardware-dependent (padding, order). */ 96 struct zschan { 97 uint8_t pad1[3]; 98 volatile uint8_t zc_csr; /* ctrl,status, and indirect access */ 99 uint8_t pad2[3]; 100 volatile uint8_t zc_data; /* data */ 101 }; 102 103 struct zsdevice { 104 struct zschan zs_chan_b; 105 struct zschan zs_chan_a; 106 }; 107 108 /* Return the byte offset of element within a structure */ 109 #define OFFSET(struct_def, el) ((size_t)&((struct_def *)0)->el) 110 111 #define ZS_CHAN_A OFFSET(struct zsdevice, zs_chan_a) 112 #define ZS_CHAN_B OFFSET(struct zsdevice, zs_chan_b) 113 #define ZS_REG_CSR 0 114 #define ZS_REG_DATA 1 115 static int zs_chan_offset[] = {ZS_CHAN_A, ZS_CHAN_B}; 116 117 static void zscnprobe (struct consdev *); 118 static void zscninit (struct consdev *); 119 static int zscngetc (dev_t); 120 static void zscnputc (dev_t, int); 121 static void zscnpollc (dev_t, int); 122 123 static int cons_port; 124 125 struct consdev zs_cn = { 126 zscnprobe, 127 zscninit, 128 zscngetc, 129 zscnputc, 130 zscnpollc, 131 NULL, 132 NULL, 133 NULL, 134 NODEV, 135 CN_NORMAL 136 }; 137 138 /* Flags from cninit() */ 139 static int zs_consunit = -1; 140 static int zs_conschan = -1; 141 142 /* Default speed for all channels */ 143 static int zs_defspeed = ZS_DEFSPEED; 144 static volatile int zssoftpending; 145 146 static uint8_t zs_init_reg[16] = { 147 0, /* 0: CMD (reset, etc.) */ 148 0, /* 1: No interrupts yet. */ 149 ZSHARD_PRI, /* 2: IVECT */ 150 ZSWR3_RX_8 | ZSWR3_RX_ENABLE, 151 ZSWR4_CLK_X16 | ZSWR4_ONESB, 152 ZSWR5_TX_8 | ZSWR5_TX_ENABLE, 153 0, /* 6: TXSYNC/SYNCLO */ 154 0, /* 7: RXSYNC/SYNCHI */ 155 0, /* 8: alias for data port */ 156 ZSWR9_MASTER_IE, 157 0, /*10: Misc. TX/RX control bits */ 158 ZSWR11_TXCLK_BAUD | ZSWR11_RXCLK_BAUD | ZSWR11_TRXC_OUT_ENA, 159 BPS_TO_TCONST(PCLK/16, ZS_DEFSPEED), /*12: BAUDLO (default=9600) */ 160 0, /*13: BAUDHI (default=9600) */ 161 ZSWR14_BAUD_ENA, 162 ZSWR15_BREAK_IE, 163 }; 164 165 166 /**************************************************************** 167 * Autoconfig 168 ****************************************************************/ 169 170 /* Definition of the driver for autoconfig. */ 171 static int zs_hpc_match(device_t, cfdata_t, void *); 172 static void zs_hpc_attach(device_t, device_t, void *); 173 static int zs_print(void *, const char *name); 174 175 CFATTACH_DECL_NEW(zsc_hpc, sizeof(struct zsc_softc), 176 zs_hpc_match, zs_hpc_attach, NULL, NULL); 177 178 static int zshard (void *); 179 void zssoft (void *); 180 static int zs_get_speed (struct zs_chanstate *); 181 struct zschan *zs_get_chan_addr (int zs_unit, int channel); 182 int zs_getc (void *); 183 void zs_putc (void *, int); 184 185 /* 186 * Is the zs chip present? 187 */ 188 static int 189 zs_hpc_match(device_t parent, cfdata_t cf, void *aux) 190 { 191 struct hpc_attach_args *ha = aux; 192 193 if (strcmp(ha->ha_name, cf->cf_name) == 0) 194 return (1); 195 196 return (0); 197 } 198 199 /* 200 * Attach a found zs. 201 * 202 * Match slave number to zs unit number, so that misconfiguration will 203 * not set up the keyboard as ttya, etc. 204 */ 205 static void 206 zs_hpc_attach(device_t parent, device_t self, void *aux) 207 { 208 struct zsc_softc *zsc = device_private(self); 209 struct hpc_attach_args *haa = aux; 210 struct zsc_attach_args zsc_args; 211 struct zs_chanstate *cs; 212 struct zs_channel *ch; 213 int zs_unit, channel, err, s; 214 const char *promconsdev; 215 216 promconsdev = arcbios_GetEnvironmentVariable("ConsoleOut"); 217 218 zsc->zsc_dev = self; 219 zsc->zsc_bustag = haa->ha_st; 220 if ((err = bus_space_subregion(haa->ha_st, haa->ha_sh, 221 haa->ha_devoff, 0x10, 222 &zsc->zsc_base)) != 0) { 223 aprint_error(": unable to map 85c30 registers, error = %d\n", 224 err); 225 return; 226 } 227 228 zs_unit = device_unit(self); 229 aprint_normal("\n"); 230 231 /* 232 * Initialize software state for each channel. 233 * 234 * Done in reverse order of channels since the first serial port 235 * is actually attached to the *second* channel, and vice versa. 236 * Doing it this way should force a 'zstty*' to attach zstty0 to 237 * channel 1 and zstty1 to channel 0. They couldn't have wired 238 * it up in a more sensible fashion, could they? 239 */ 240 for (channel = 1; channel >= 0; channel--) { 241 zsc_args.channel = channel; 242 ch = &zsc->zsc_cs_store[channel]; 243 cs = zsc->zsc_cs[channel] = (struct zs_chanstate *)ch; 244 245 zs_lock_init(cs); 246 cs->cs_reg_csr = NULL; 247 cs->cs_reg_data = NULL; 248 cs->cs_channel = channel; 249 cs->cs_private = NULL; 250 cs->cs_ops = &zsops_null; 251 cs->cs_brg_clk = PCLK / 16; 252 253 if (bus_space_subregion(zsc->zsc_bustag, zsc->zsc_base, 254 zs_chan_offset[channel], 255 sizeof(struct zschan), 256 &ch->cs_regs) != 0) { 257 aprint_error_dev(self, "cannot map regs\n"); 258 return; 259 } 260 ch->cs_bustag = zsc->zsc_bustag; 261 262 memcpy(cs->cs_creg, zs_init_reg, 16); 263 memcpy(cs->cs_preg, zs_init_reg, 16); 264 265 zsc_args.hwflags = 0; 266 zsc_args.consdev = NULL; 267 268 if (zs_consunit == -1 && zs_conschan == -1) { 269 /* 270 * If this channel is being used by the PROM console, 271 * pass the generic zs driver a 'no reset' flag so the 272 * channel gets left in the appropriate state after 273 * attach. 274 * 275 * Note: the channel mappings are swapped. 276 */ 277 if (promconsdev != NULL && 278 strlen(promconsdev) == 9 && 279 strncmp(promconsdev, "serial", 6) == 0 && 280 (promconsdev[7] == '0' || promconsdev[7] == '1')) { 281 if (promconsdev[7] == '1' && channel == 0) 282 zsc_args.hwflags |= ZS_HWFLAG_NORESET; 283 else if (promconsdev[7] == '0' && channel == 1) 284 zsc_args.hwflags |= ZS_HWFLAG_NORESET; 285 } 286 } 287 288 /* If console, don't stomp speed, let zstty know */ 289 if (zs_unit == zs_consunit && channel == zs_conschan) { 290 zsc_args.consdev = &zs_cn; 291 zsc_args.hwflags = ZS_HWFLAG_CONSOLE; 292 293 cs->cs_defspeed = zs_get_speed(cs); 294 } else 295 cs->cs_defspeed = zs_defspeed; 296 297 cs->cs_defcflag = zs_def_cflag; 298 299 /* Make these correspond to cs_defcflag (-crtscts) */ 300 cs->cs_rr0_dcd = ZSRR0_DCD; 301 cs->cs_rr0_cts = 0; 302 cs->cs_wr5_dtr = ZSWR5_DTR | ZSWR5_RTS; 303 cs->cs_wr5_rts = 0; 304 305 /* 306 * Clear the master interrupt enable. 307 * The INTENA is common to both channels, 308 * so just do it on the A channel. 309 */ 310 if (channel == 0) { 311 zs_write_reg(cs, 9, 0); 312 } 313 /* 314 * Look for a child driver for this channel. 315 * The child attach will setup the hardware. 316 */ 317 if (!config_found(self, (void *)&zsc_args, zs_print)) { 318 /* No sub-driver. Just reset it. */ 319 uint8_t reset = (channel == 0) ? 320 ZSWR9_A_RESET : ZSWR9_B_RESET; 321 322 s = splhigh(); 323 zs_write_reg(cs, 9, reset); 324 splx(s); 325 } 326 } 327 328 329 zsc->sc_si = softint_establish(SOFTINT_SERIAL, zssoft, zsc); 330 cpu_intr_establish(haa->ha_irq, IPL_TTY, zshard, NULL); 331 332 evcnt_attach_dynamic(&zsc->zsc_intrcnt, EVCNT_TYPE_INTR, NULL, 333 device_xname(self), "intr"); 334 335 /* 336 * Set the master interrupt enable and interrupt vector. 337 * (common to both channels, do it on A) 338 */ 339 cs = zsc->zsc_cs[0]; 340 s = splhigh(); 341 /* interrupt vector */ 342 zs_write_reg(cs, 2, zs_init_reg[2]); 343 /* master interrupt control (enable) */ 344 zs_write_reg(cs, 9, zs_init_reg[9]); 345 splx(s); 346 } 347 348 static int 349 zs_print(void *aux, const char *name) 350 { 351 struct zsc_attach_args *args = aux; 352 353 if (name != NULL) 354 aprint_normal("%s: ", name); 355 356 if (args->channel != -1) 357 aprint_normal(" channel %d", args->channel); 358 359 return UNCONF; 360 } 361 362 /* 363 * Our ZS chips all share a common, autovectored interrupt, 364 * so we have to look at all of them on each interrupt. 365 */ 366 static int 367 zshard(void *arg) 368 { 369 register struct zsc_softc *zsc; 370 register int rr3, unit, rval, softreq; 371 372 rval = 0; 373 for (unit = 0; unit < zsc_cd.cd_ndevs; unit++) { 374 zsc = device_lookup_private(&zsc_cd, unit); 375 if (zsc == NULL) 376 continue; 377 378 zsc->zsc_intrcnt.ev_count++; 379 while ((rr3 = zsc_intr_hard(zsc))) { 380 rval |= rr3; 381 } 382 383 softreq = zsc->zsc_cs[0]->cs_softreq; 384 softreq |= zsc->zsc_cs[1]->cs_softreq; 385 if (softreq && (zssoftpending == 0)) { 386 zssoftpending = 1; 387 softint_schedule(zsc->sc_si); 388 } 389 } 390 return rval; 391 } 392 393 /* 394 * Similar scheme as for zshard (look at all of them) 395 */ 396 void 397 zssoft(void *arg) 398 { 399 register struct zsc_softc *zsc; 400 register int s, unit; 401 402 /* This is not the only ISR on this IPL. */ 403 if (zssoftpending == 0) 404 return; 405 406 /* 407 * The soft intr. bit will be set by zshard only if 408 * the variable zssoftpending is zero. The order of 409 * these next two statements prevents our clearing 410 * the soft intr bit just after zshard has set it. 411 */ 412 /*isr_soft_clear(ZSSOFT_PRI);*/ 413 zssoftpending = 0; 414 415 /* Make sure we call the tty layer at spltty. */ 416 s = spltty(); 417 for (unit = 0; unit < zsc_cd.cd_ndevs; unit++) { 418 zsc = device_lookup_private(&zsc_cd, unit); 419 if (zsc == NULL) 420 continue; 421 (void) zsc_intr_soft(zsc); 422 } 423 splx(s); 424 return; 425 } 426 427 428 /* 429 * Compute the current baud rate given a ZS channel. 430 */ 431 static int 432 zs_get_speed(struct zs_chanstate *cs) 433 { 434 int tconst; 435 436 tconst = zs_read_reg(cs, 12); 437 tconst |= zs_read_reg(cs, 13) << 8; 438 return (TCONST_TO_BPS(cs->cs_brg_clk, tconst)); 439 } 440 441 /* 442 * MD functions for setting the baud rate and control modes. 443 */ 444 int 445 zs_set_speed(struct zs_chanstate *cs, int bps) 446 { 447 int tconst; 448 449 #if 0 450 while (!(zs_read_csr(cs) & ZSRR0_TX_READY)) 451 {/*nop*/} 452 #endif 453 /* Wait for transmit buffer to empty */ 454 if (bps == 0) { 455 return (0); 456 } 457 458 #ifdef DIAGNOSTIC 459 if (cs->cs_brg_clk == 0) 460 panic("zs_set_speed"); 461 #endif 462 463 tconst = BPS_TO_TCONST(cs->cs_brg_clk, bps); 464 if (tconst < 0) 465 return (EINVAL); 466 467 #if 0 468 /* Convert back to make sure we can do it. */ 469 int real_bps = TCONST_TO_BPS(cs->cs_brg_clk, tconst); 470 471 /* XXX - Allow some tolerance here? */ 472 if (real_bps != bps) 473 return (EINVAL); 474 #endif 475 476 cs->cs_preg[12] = tconst; 477 cs->cs_preg[13] = tconst >> 8; 478 479 /* Caller will stuff the pending registers. */ 480 return (0); 481 } 482 483 int 484 zs_set_modes(struct zs_chanstate *cs, int cflag) 485 { 486 int s; 487 488 /* 489 * Output hardware flow control on the chip is horrendous: 490 * if carrier detect drops, the receiver is disabled, and if 491 * CTS drops, the transmitter is stoped IN MID CHARACTER! 492 * Therefore, NEVER set the HFC bit, and instead use the 493 * status interrupt to detect CTS changes. 494 */ 495 s = splzs(); 496 cs->cs_rr0_pps = 0; 497 if ((cflag & (CLOCAL | MDMBUF)) != 0) { 498 cs->cs_rr0_dcd = 0; 499 if ((cflag & MDMBUF) == 0) 500 cs->cs_rr0_pps = ZSRR0_DCD; 501 } else 502 cs->cs_rr0_dcd = ZSRR0_DCD; 503 if ((cflag & CRTSCTS) != 0) { 504 cs->cs_wr5_dtr = ZSWR5_DTR; 505 cs->cs_wr5_rts = ZSWR5_RTS; 506 cs->cs_rr0_cts = ZSRR0_CTS; 507 } else if ((cflag & MDMBUF) != 0) { 508 cs->cs_wr5_dtr = 0; 509 cs->cs_wr5_rts = ZSWR5_DTR; 510 cs->cs_rr0_cts = ZSRR0_DCD; 511 } else { 512 cs->cs_wr5_dtr = ZSWR5_DTR | ZSWR5_RTS; 513 cs->cs_wr5_rts = 0; 514 cs->cs_rr0_cts = 0; 515 } 516 splx(s); 517 518 /* Caller will stuff the pending registers. */ 519 return (0); 520 } 521 522 523 /* 524 * Read or write the chip with suitable delays. 525 */ 526 527 uint8_t 528 zs_read_reg(struct zs_chanstate *cs, uint8_t reg) 529 { 530 uint8_t val; 531 struct zs_channel *zsc = (struct zs_channel *)cs; 532 533 bus_space_write_1(zsc->cs_bustag, zsc->cs_regs, 534 (ZS_REG_CSR << 2) + 3, reg); 535 ZS_DELAY(); 536 val = bus_space_read_1(zsc->cs_bustag, zsc->cs_regs, 537 (ZS_REG_CSR << 2) + 3); 538 ZS_DELAY(); 539 return val; 540 } 541 542 void 543 zs_write_reg(struct zs_chanstate *cs, uint8_t reg, uint8_t val) 544 { 545 struct zs_channel *zsc = (struct zs_channel *)cs; 546 547 bus_space_write_1(zsc->cs_bustag, zsc->cs_regs, 548 (ZS_REG_CSR << 2) + 3, reg); 549 ZS_DELAY(); 550 bus_space_write_1(zsc->cs_bustag, zsc->cs_regs, 551 (ZS_REG_CSR << 2) + 3, val); 552 ZS_DELAY(); 553 } 554 555 uint8_t 556 zs_read_csr(struct zs_chanstate *cs) 557 { 558 struct zs_channel *zsc = (struct zs_channel *)cs; 559 uint8_t val; 560 561 val = bus_space_read_1(zsc->cs_bustag, zsc->cs_regs, 562 (ZS_REG_CSR << 2) + 3); 563 ZS_DELAY(); 564 return val; 565 } 566 567 void 568 zs_write_csr(struct zs_chanstate *cs, uint8_t val) 569 { 570 struct zs_channel *zsc = (struct zs_channel *)cs; 571 572 bus_space_write_1(zsc->cs_bustag, zsc->cs_regs, 573 (ZS_REG_CSR << 2) + 3, val); 574 ZS_DELAY(); 575 } 576 577 uint8_t 578 zs_read_data(struct zs_chanstate *cs) 579 { 580 struct zs_channel *zsc = (struct zs_channel *)cs; 581 uint8_t val; 582 583 val = bus_space_read_1(zsc->cs_bustag, zsc->cs_regs, 584 (ZS_REG_DATA << 2) + 3); 585 ZS_DELAY(); 586 return val; 587 } 588 589 void 590 zs_write_data(struct zs_chanstate *cs, uint8_t val) 591 { 592 struct zs_channel *zsc = (struct zs_channel *)cs; 593 594 bus_space_write_1(zsc->cs_bustag, zsc->cs_regs, 595 (ZS_REG_DATA << 2) + 3, val); 596 ZS_DELAY(); 597 } 598 599 void 600 zs_abort(struct zs_chanstate *cs) 601 { 602 #if defined(KGDB) 603 zskgdb(cs); 604 #elif defined(DDB) 605 Debugger(); 606 #endif 607 } 608 609 610 /*********************************************************/ 611 /* Polled character I/O functions for console and KGDB */ 612 /*********************************************************/ 613 614 struct zschan * 615 zs_get_chan_addr(int zs_unit, int channel) 616 { 617 static int dumped_addr = 0; 618 struct zsdevice *addr; 619 struct zschan *zc; 620 621 switch (mach_type) { 622 case MACH_SGI_IP12: 623 if (zs_unit == 2 && (mach_subtype == MACH_SGI_IP12_4D_3X || 624 mach_subtype == MACH_SGI_IP12_VIP12)) { 625 addr = (struct zsdevice *) 626 MIPS_PHYS_TO_KSEG1(0x1fb80d20); 627 break; 628 } 629 630 /* FALLTHROUGH */ 631 case MACH_SGI_IP20: 632 if (zs_unit == 0) { 633 addr = (struct zsdevice *) 634 MIPS_PHYS_TO_KSEG1(0x1fb80d00); 635 } else if (zs_unit == 1) { 636 addr = (struct zsdevice *) 637 MIPS_PHYS_TO_KSEG1(0x1fb80d10); 638 } else { 639 panic("zs_get_chan_addr: bad zs_unit %d\n", zs_unit); 640 } 641 break; 642 643 case MACH_SGI_IP22: 644 if (zs_unit != 0) 645 panic("zs_get_chan_addr zs_unit != 0 on IP%d", 646 mach_type); 647 648 addr = (struct zsdevice *) MIPS_PHYS_TO_KSEG1(0x1fbd9830); 649 break; 650 651 default: 652 panic("zs_get_chan_addr: unsupported IP%d", mach_type); 653 } 654 655 /* 656 * We need to swap serial ports to match reality on 657 * non-keyboard channels. 658 */ 659 if (mach_type == MACH_SGI_IP22) { 660 if (channel == 0) 661 zc = &addr->zs_chan_b; 662 else 663 zc = &addr->zs_chan_a; 664 } else { 665 if (zs_unit == 0) { 666 if (channel == 0) 667 zc = &addr->zs_chan_a; 668 else 669 zc = &addr->zs_chan_b; 670 } else { 671 if (channel == 0) 672 zc = &addr->zs_chan_b; 673 else 674 zc = &addr->zs_chan_a; 675 } 676 } 677 678 if (dumped_addr == 0) { 679 dumped_addr++; 680 aprint_debug("zs unit %d, channel %d had address %p\n", 681 zs_unit, channel, zc); 682 } 683 684 return (zc); 685 } 686 687 int 688 zs_getc(void *arg) 689 { 690 register volatile struct zschan *zc = arg; 691 register int s, c, rr0; 692 693 s = splzs(); 694 /* Wait for a character to arrive. */ 695 do { 696 rr0 = zc->zc_csr; 697 ZS_DELAY(); 698 } while ((rr0 & ZSRR0_RX_READY) == 0); 699 700 c = zc->zc_data; 701 ZS_DELAY(); 702 splx(s); 703 704 return (c); 705 } 706 707 /* 708 * Polled output char. 709 */ 710 void 711 zs_putc(void *arg, int c) 712 { 713 register volatile struct zschan *zc = arg; 714 register int s, rr0; 715 716 s = splzs(); 717 /* Wait for transmitter to become ready. */ 718 do { 719 rr0 = zc->zc_csr; 720 ZS_DELAY(); 721 } while ((rr0 & ZSRR0_TX_READY) == 0); 722 723 zc->zc_data = c; 724 wbflush(); 725 ZS_DELAY(); 726 splx(s); 727 } 728 729 /***************************************************************/ 730 void 731 zscnprobe(struct consdev *cn) 732 { 733 } 734 735 void 736 zscninit(struct consdev *cn) 737 { 738 extern const struct cdevsw zstty_cdevsw; 739 const char* consdev; 740 741 if ((consdev = arcbios_GetEnvironmentVariable("ConsoleOut")) == NULL) 742 panic("zscninit without valid ARCS ConsoleOut setting!"); 743 744 if (strlen(consdev) != 9 || 745 strncmp(consdev, "serial", 6) != 0) 746 panic("zscninit with ARCS console not set to serial!"); 747 748 cons_port = consdev[7] - '0'; 749 750 #if 0 751 /* 752 * If your IP12 serial console goes missing after consinit(), 753 * try flipping this the other way 'round. If there are some 754 * IP12 machines that actually require this, we'll be in for 755 * a lot of funnies once again... 756 */ 757 if (mach_type == MACH_SGI_IP12) 758 cons_port = 1 - cons_port; 759 #endif 760 761 cn->cn_dev = makedev(cdevsw_lookup_major(&zstty_cdevsw), cons_port); 762 cn->cn_pri = CN_REMOTE; 763 764 /* Mark this unit as the console */ 765 zs_consunit = 0; 766 767 /* SGI hardware wires serial port 1 to channel B, port 2 to A */ 768 if (cons_port == 0) 769 zs_conschan = 1; 770 else 771 zs_conschan = 0; 772 } 773 774 int 775 zscngetc(dev_t dev) 776 { 777 struct zschan *zs; 778 779 switch (mach_type) { 780 case MACH_SGI_IP12: 781 case MACH_SGI_IP20: 782 zs = zs_get_chan_addr(1, cons_port); 783 break; 784 785 case MACH_SGI_IP22: 786 default: 787 zs = zs_get_chan_addr(0, cons_port); 788 break; 789 } 790 791 return zs_getc(zs); 792 } 793 794 void 795 zscnputc(dev_t dev, int c) 796 { 797 struct zschan *zs; 798 799 switch (mach_type) { 800 case MACH_SGI_IP12: 801 case MACH_SGI_IP20: 802 zs = zs_get_chan_addr(1, cons_port); 803 break; 804 805 case MACH_SGI_IP22: 806 default: 807 zs = zs_get_chan_addr(0, cons_port); 808 break; 809 } 810 811 zs_putc(zs, c); 812 } 813 814 void 815 zscnpollc(dev_t dev, int on) 816 { 817 } 818