gtmpsc.c revision 1.1
1 /* $NetBSD: gtmpsc.c,v 1.1 2003/03/05 22:08:21 matt Exp $ */ 2 3 /* 4 * Copyright (c) 2002 Allegro Networks, Inc., Wasabi Systems, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed for the NetBSD Project by 18 * Allegro Networks, Inc., and Wasabi Systems, Inc. 19 * 4. The name of Allegro Networks, Inc. may not be used to endorse 20 * or promote products derived from this software without specific prior 21 * written permission. 22 * 5. The name of Wasabi Systems, Inc. may not be used to endorse 23 * or promote products derived from this software without specific prior 24 * written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY ALLEGRO NETWORKS, INC. AND 27 * WASABI SYSTEMS, INC. ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 28 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 29 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 30 * IN NO EVENT SHALL EITHER ALLEGRO NETWORKS, INC. OR WASABI SYSTEMS, INC. 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 * mpsc.c - MPSC serial driver, supports UART mode only 42 * 43 * 44 * creation Mon Apr 9 19:40:15 PDT 2001 cliff 45 */ 46 47 #include "opt_kgdb.h" 48 49 #include <sys/param.h> 50 #include <sys/conf.h> 51 #include <sys/device.h> 52 #include <sys/proc.h> 53 #include <sys/systm.h> 54 #include <sys/tty.h> 55 #include <sys/callout.h> 56 #include <sys/fcntl.h> 57 #ifdef KGDB 58 #include <sys/kernel.h> 59 #include <sys/kgdb.h> 60 #endif 61 #include <powerpc/atomic.h> 62 #include <dev/cons.h> 63 #include <machine/bus.h> 64 #include <machine/cpu.h> /* for DELAY */ 65 #include <machine/stdarg.h> 66 #include "gtmpsc.h" 67 68 69 #include <dev/marvell/gtreg.h> 70 #include <dev/marvell/gtvar.h> 71 #include <dev/marvell/gtintrreg.h> 72 #include <dev/marvell/gtmpscreg.h> 73 #include <dev/marvell/gtsdmareg.h> 74 #include <dev/marvell/gtmpscvar.h> 75 #include <dev/marvell/gtbrgreg.h> 76 77 /* 78 * XXX these delays were derived empiracaly 79 */ 80 #define GTMPSC_POLL_DELAY 1 /* 1 usec */ 81 #define GTMPSC_RESET_DELAY 100 /* 100 usec */ 82 83 #define BURSTLEN 128 84 85 /* 86 * stat values for gtmpsc_common_pollc 87 */ 88 #define GTMPSC_STAT_NONE 0 89 #define GTMPSC_STAT_BREAK 1 90 91 92 #define PRINTF(x) gtmpsc_mem_printf x 93 94 #if defined(DEBUG) 95 unsigned int mpscdebug = 0; 96 # define STATIC 97 # define DPRINTF(x) do { if (mpscdebug) gtmpsc_mem_printf x ; } while (0) 98 #else 99 # define STATIC static 100 # define DPRINTF(x) 101 #endif 102 103 #define GTMPSCUNIT_MASK 0x7ffff 104 #define GTMPSCDIALOUT_MASK 0x80000 105 106 #define GTMPSCUNIT(x) (minor(x) & GTMPSCUNIT_MASK) 107 #define GTMPSCDIALOUT(x) (minor(x) & GTMPSCDIALOUT_MASK) 108 109 STATIC void gtmpscinit __P((struct gtmpsc_softc *)); 110 STATIC int gtmpscmatch __P((struct device *, struct cfdata *, void *)); 111 STATIC void gtmpscattach __P((struct device *, struct device *, void *)); 112 STATIC int compute_cdv __P((unsigned int)); 113 STATIC void gtmpsc_loadchannelregs __P((struct gtmpsc_softc *)); 114 STATIC void gtmpscshutdown __P((struct gtmpsc_softc *)); 115 STATIC void gtmpscstart __P((struct tty *)); 116 STATIC int gtmpscparam __P((struct tty *, struct termios *)); 117 STATIC int gtmpsc_probe __P((void)); 118 STATIC int gtmpsc_intr __P((void *)); 119 STATIC int gtmpsc_softintr(void *); 120 121 STATIC void gtmpsc_common_putn __P((struct gtmpsc_softc *)); 122 STATIC void gtmpsc_common_putc __P((unsigned int, unsigned char)); 123 STATIC int gtmpsc_common_getc __P((unsigned int)); 124 STATIC int gtmpsc_common_pollc __P((unsigned int, char *, int *)); 125 STATIC void gtmpsc_poll __P((void *)); 126 #ifdef KGDB 127 STATIC void gtmpsc_kgdb_poll __P((void *)); 128 #endif 129 STATIC void gtmpsc_mem_printf __P((const char *, ...)); 130 131 STATIC void gtmpsc_txdesc_init(gtmpsc_poll_sdma_t *, gtmpsc_poll_sdma_t *); 132 STATIC void gtmpsc_rxdesc_init(gtmpsc_poll_sdma_t *, gtmpsc_poll_sdma_t *); 133 STATIC unsigned int gtmpsc_get_causes(void); 134 STATIC void gtmpsc_hackinit(struct gtmpsc_softc *); 135 STATIC void gtmpscinit_stop(struct gtmpsc_softc *, int); 136 STATIC void gtmpscinit_start(struct gtmpsc_softc *, int); 137 void gtmpsc_printf(const char *fmt, ...); 138 void gtmpsc_puts(char *); 139 140 void gtmpsccnprobe __P((struct consdev *)); 141 void gtmpsccninit __P((struct consdev *)); 142 int gtmpsccngetc __P((dev_t)); 143 void gtmpsccnputc __P((dev_t, int)); 144 void gtmpsccnpollc __P((dev_t, int)); 145 void gtmpsccnhalt __P((dev_t)); 146 147 STATIC void gtmpsc_txflush __P((gtmpsc_softc_t *)); 148 STATIC void gtmpsc_iflush __P((gtmpsc_softc_t *)); 149 STATIC void gtmpsc_shutdownhook __P((void *)); 150 151 dev_type_open(gtmpscopen); 152 dev_type_close(gtmpscclose); 153 dev_type_read(gtmpscread); 154 dev_type_write(gtmpscwrite); 155 dev_type_ioctl(gtmpscioctl); 156 dev_type_stop(gtmpscstop); 157 dev_type_tty(gtmpsctty); 158 dev_type_poll(gtmpscpoll); 159 160 const struct cdevsw gtmpsc_cdevsw = { 161 gtmpscopen, gtmpscclose, gtmpscread, gtmpscwrite, gtmpscioctl, 162 gtmpscstop, gtmpsctty, gtmpscpoll, nommap, ttykqfilter, D_TTY 163 }; 164 165 CFATTACH_DECL(gtmpsc, sizeof(struct gtmpsc_softc), 166 gtmpscmatch, gtmpscattach, NULL, NULL); 167 168 extern struct cfdriver gtmpsc_cd; 169 170 #if 0 171 struct consdev consdev_mpsc = { 172 gtmpsccnprobe, 173 gtmpsccninit, 174 gtmpsccngetc, 175 gtmpsccnputc, 176 gtmpsccnpollc, 177 NULL, 178 NULL, /* cn_flush */ 179 gtmpsccnhalt, 180 }; 181 #endif 182 183 STATIC int gtmpsc_nattached = 0; 184 STATIC void *gtmpsc_sdma_ih = NULL; 185 STATIC void *gtmpsc_soft_ih = NULL; 186 187 gtmpsc_softc_t *gtmpsc_scp[GTMPSC_NCHAN] = { 0 }; 188 189 STATIC int gt_reva_gtmpsc_bug; 190 unsigned int sdma_imask; /* soft copy of SDMA IMASK reg */ 191 192 #ifdef KGDB 193 #include <sys/kgdb.h> 194 195 static int gtmpsc_kgdb_addr; 196 static int gtmpsc_kgdb_attached; 197 198 int kgdb_break_immediate /* = 0 */ ; 199 200 STATIC int gtmpsc_kgdb_getc __P((void *)); 201 STATIC void gtmpsc_kgdb_putc __P((void *, int)); 202 #endif /* KGDB */ 203 204 /* 205 * hacks for console initialization 206 * which happens prior to autoconfig "attach" 207 */ 208 STATIC unsigned int gtmpsccninit_done = 0; 209 STATIC gtmpsc_softc_t gtmpsc_fake_softc; 210 STATIC unsigned char gtmpsc_earlybuf[NBPG] __attribute__ ((aligned(NBPG))); 211 STATIC unsigned char gtmpsc_fake_dmapage[NBPG] __attribute__ ((aligned(NBPG))); 212 213 214 #define GTMPSC_PRINT_BUF_SIZE 4096 215 STATIC unsigned char gtmpsc_print_buf[GTMPSC_PRINT_BUF_SIZE] = { 0 }; 216 217 unsigned int gtmpsc_poll_putc_cnt = 0; 218 unsigned int gtmpsc_poll_putn_cnt = 0; 219 unsigned int gtmpsc_poll_getc_cnt = 0; 220 unsigned int gtmpsc_poll_pollc_cnt = 0; 221 unsigned int gtmpsc_poll_putc_miss = 0; 222 unsigned int gtmpsc_poll_putn_miss = 0; 223 unsigned int gtmpsc_poll_getc_miss = 0; 224 unsigned int gtmpsc_poll_pollc_miss = 0; 225 226 227 #ifndef SDMA_COHERENT 228 /* 229 * inlines to flush, invalidate cache 230 * required if DMA cache coherency is broken 231 * note that pointer `p' args are assumed to be cache aligned 232 * and the size is assumed to be one CACHELINESIZE block 233 */ 234 235 #define GTMPSC_CACHE_FLUSH(p) gtmpsc_cache_flush(p) 236 #define GTMPSC_CACHE_INVALIDATE(p) gtmpsc_cache_invalidate(p) 237 238 static volatile inline void 239 gtmpsc_cache_flush(void *p) 240 { 241 __asm __volatile ("eieio; dcbf 0,%0; lwz %0,0(%0); sync;" 242 : "+r"(p):); 243 } 244 245 static volatile inline void 246 gtmpsc_cache_invalidate(void *p) 247 { 248 __asm __volatile ("eieio; dcbi 0,%0; sync;" :: "r"(p)); 249 } 250 #else 251 252 #define GTMPSC_CACHE_FLUSH(p) 253 #define GTMPSC_CACHE_INVALIDATE(p) 254 255 #endif /* SDMA_COHERENT */ 256 257 258 extern unsigned int gtbase; 259 260 #define GT_READ(d,a) \ 261 gtmpsc_reg_read(gtbase, (a)) 262 #define GT_WRITE(d,a,v) \ 263 gtmpsc_reg_write(gtbase,(a),(v)) 264 265 266 #define SDMA_IMASK_ENABLE(bit) ({ \ 267 unsigned int r; \ 268 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_ICAUSE, ~(bit)); \ 269 if (gt_reva_gtmpsc_bug) \ 270 r = sdma_imask; \ 271 else \ 272 r = GT_READ(sc->gtmpsc_dev.dv_parent, SDMA_IMASK); \ 273 r |= (bit); \ 274 sdma_imask = r; \ 275 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_IMASK, r); \ 276 }) 277 278 #define SDMA_IMASK_DISABLE(bit) ({ \ 279 unsigned int r; \ 280 if (gt_reva_gtmpsc_bug) \ 281 r = sdma_imask; \ 282 else \ 283 r = GT_READ(sc->gtmpsc_dev.dv_parent, SDMA_IMASK); \ 284 r &= ~(bit); \ 285 sdma_imask = r; \ 286 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_IMASK, r); \ 287 }) 288 289 static volatile inline unsigned int 290 gtmpsc_reg_read(unsigned int p, unsigned int off) 291 { 292 unsigned int rv; 293 294 #undef GCC_R0_OFF_NOT_BROKEN 295 #ifdef GCC_R0_OFF_NOT_BROKEN 296 asm volatile("lwbrx %0,%1,%2; eieio;" 297 : "=r"(rv) : "r"(off), "r"(p)); 298 #else 299 asm volatile("lwbrx %0,0,%1; eieio;" 300 : "=r"(rv) : "r"(p + off)); 301 #endif 302 DPRINTF(("READ 0x%x 0x%x\n", off, rv)); 303 304 return rv; 305 } 306 307 static volatile inline void 308 gtmpsc_reg_write(unsigned int p, unsigned int off, unsigned int v) 309 { 310 #ifdef GCC_R0_OFF_NOT_BROKEN 311 asm volatile("stwbrx %0,%1,%2; eieio;" 312 :: "r"(v), "r"(off), "r"(p)); 313 #else 314 asm volatile("stwbrx %0,0,%1; eieio;" 315 :: "r"(v), "r"(p+off)); 316 #endif 317 DPRINTF(("WRITE 0x%x 0x%x\n", off, v)); 318 } 319 320 321 322 static volatile inline unsigned int 323 desc_read(unsigned int *ip) 324 { 325 unsigned int rv; 326 327 asm volatile ("lwzx %0,0,%1; eieio;" 328 : "=r"(rv) : "r"(ip)); 329 return rv; 330 } 331 332 static volatile inline void 333 desc_write(unsigned int *ip, unsigned int val) 334 { 335 asm volatile ("stwx %0,0,%1; eieio;" 336 :: "r"(val), "r"(ip)); 337 } 338 339 340 /* 341 * gtmpsc_txdesc_init - set up TX descriptor ring 342 */ 343 STATIC void 344 gtmpsc_txdesc_init(gtmpsc_poll_sdma_t *vmps, gtmpsc_poll_sdma_t *pmps) 345 { 346 int n; 347 sdma_desc_t *dp; 348 gtmpsc_polltx_t *vtxp; 349 gtmpsc_polltx_t *ptxp; 350 gtmpsc_polltx_t *next_ptxp; 351 gtmpsc_polltx_t *first_ptxp; 352 353 first_ptxp = ptxp = &pmps->tx[0]; 354 vtxp = &vmps->tx[0]; 355 next_ptxp = ptxp + 1; 356 for (n = (GTMPSC_NTXDESC - 1); n--; ) { 357 dp = &vtxp->txdesc; 358 desc_write(&dp->sdma_csr, 0); 359 desc_write(&dp->sdma_cnt, 0); 360 desc_write(&dp->sdma_bufp, (u_int32_t)&ptxp->txbuf); 361 desc_write(&dp->sdma_next, (u_int32_t)&next_ptxp->txdesc); 362 GTMPSC_CACHE_FLUSH(dp); 363 vtxp++; 364 ptxp++; 365 next_ptxp++; 366 } 367 dp = &vtxp->txdesc; 368 desc_write(&dp->sdma_csr, 0); 369 desc_write(&dp->sdma_cnt, 0); 370 desc_write(&dp->sdma_bufp, (u_int32_t)&ptxp->txbuf); 371 desc_write(&dp->sdma_next, (u_int32_t)&first_ptxp->txdesc); 372 GTMPSC_CACHE_FLUSH(dp); 373 } 374 375 /* 376 * gtmpsc_rxdesc_init - set up RX descriptor ring 377 */ 378 STATIC void 379 gtmpsc_rxdesc_init(gtmpsc_poll_sdma_t *vmps, gtmpsc_poll_sdma_t *pmps) 380 { 381 int n; 382 sdma_desc_t *dp; 383 gtmpsc_pollrx_t *vrxp; 384 gtmpsc_pollrx_t *prxp; 385 gtmpsc_pollrx_t *next_prxp; 386 gtmpsc_pollrx_t *first_prxp; 387 unsigned int csr; 388 389 csr = SDMA_CSR_RX_L|SDMA_CSR_RX_F|SDMA_CSR_RX_OWN|SDMA_CSR_RX_EI; 390 first_prxp = prxp = &pmps->rx[0]; 391 vrxp = &vmps->rx[0]; 392 next_prxp = prxp + 1; 393 for (n = (GTMPSC_NRXDESC - 1); n--; ) { 394 dp = &vrxp->rxdesc; 395 desc_write(&dp->sdma_csr, csr); 396 desc_write(&dp->sdma_cnt, 397 GTMPSC_RXBUFSZ << SDMA_RX_CNT_BUFSZ_SHIFT); 398 desc_write(&dp->sdma_bufp, (u_int32_t)&prxp->rxbuf); 399 desc_write(&dp->sdma_next, (u_int32_t)&next_prxp->rxdesc); 400 GTMPSC_CACHE_FLUSH(dp); 401 vrxp++; 402 prxp++; 403 next_prxp++; 404 } 405 dp = &vrxp->rxdesc; 406 desc_write(&dp->sdma_csr, SDMA_CSR_RX_OWN); 407 desc_write(&dp->sdma_cnt, 408 GTMPSC_RXBUFSZ << SDMA_RX_CNT_BUFSZ_SHIFT); 409 desc_write(&dp->sdma_bufp, (u_int32_t)&prxp->rxbuf); 410 desc_write(&dp->sdma_next, (u_int32_t)&first_prxp->rxdesc); 411 GTMPSC_CACHE_FLUSH(dp); 412 } 413 414 /* 415 * Compute the BRG countdown value (CDV in BRG_BCR) 416 */ 417 418 STATIC int 419 compute_cdv(unsigned int baud) 420 { 421 unsigned int cdv; 422 423 if (baud == 0) 424 return 0; 425 cdv = (BRG_DEFAULT_INPUT_RATE / (baud * GTMPSC_CLOCK_DIVIDER) + 1) / 2 - 1; 426 if (cdv > BRG_BCR_CDV_MAX) 427 return -1; 428 return cdv; 429 } 430 431 STATIC void 432 gtmpsc_loadchannelregs(struct gtmpsc_softc *sc) 433 { 434 u_int brg_bcr; 435 u_int unit; 436 437 unit = sc->gtmpsc_unit; 438 brg_bcr = unit ? BRG_BCR1 : BRG_BCR0; 439 440 GT_WRITE(sc->gtmpsc_dev.dv_parent, brg_bcr, sc->gtmpsc_brg_bcr); 441 GT_WRITE(sc->gtmpsc_dev.dv_parent, GTMPSC_U_CHRN(unit, 3), sc->gtmpsc_chr3); 442 } 443 444 STATIC int 445 gtmpscmatch(struct device *parent, struct cfdata *self, void *aux) 446 { 447 struct gt_attach_args *ga = aux; 448 449 if (gtmpsc_nattached >= GTMPSC_NCHAN) { 450 return 0; 451 } 452 453 if (strcmp(ga->ga_name, gtmpsc_cd.cd_name) != 0) { 454 return 0; 455 } 456 457 return 1; 458 } 459 460 STATIC void 461 gtmpscattach(struct device *parent, struct device *self, void *aux) 462 { 463 struct gt_attach_args *ga = aux; 464 struct gt_softc *gt = (struct gt_softc *) parent; 465 struct gtmpsc_softc *sc = (struct gtmpsc_softc *) self; 466 gtmpsc_poll_sdma_t *vmps; 467 gtmpsc_poll_sdma_t *pmps; 468 struct tty *tp; 469 caddr_t kva; 470 int rsegs; 471 int err; 472 int s; 473 474 DPRINTF(("mpscattach\n")); 475 if (ga->ga_unit >= GTMPSC_NCHAN) 476 return; 477 478 s = splhigh(); 479 480 sc->gtmpsc_gt = gt; 481 sc->gtmpsc_memt = ga->ga_memt; 482 sc->gtmpsc_dmat = ga->ga_dmat; 483 sc->gtmpsc_unit = ga->ga_unit; 484 485 printf(", SDMA"); 486 err = bus_dmamem_alloc(sc->gtmpsc_dmat, NBPG, NBPG, NBPG, 487 sc->gtmpsc_dma_segs, 1, &rsegs, 488 BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW); 489 if (err) { 490 PRINTF(("mpscattach: bus_dmamem_alloc error 0x%x\n", err)); 491 splx(s); 492 return; 493 } 494 #ifndef SDMA_COHERENT 495 err = bus_dmamem_map(sc->gtmpsc_dmat, sc->gtmpsc_dma_segs, 1, NBPG, 496 &kva, BUS_DMA_NOWAIT); 497 #else 498 err = bus_dmamem_map(sc->gtmpsc_dmat, sc->gtmpsc_dma_segs, 1, NBPG, 499 &kva, BUS_DMA_NOWAIT|BUS_DMA_COHERENT); 500 #endif 501 if (err) { 502 PRINTF(("mpscattach: bus_dmamem_map error 0x%x\n", err)); 503 splx(s); 504 return; 505 } 506 507 bzero(kva, NBPG); /* paranoid/superfluous */ 508 509 vmps = (gtmpsc_poll_sdma_t *)kva; /* KVA */ 510 pmps = (gtmpsc_poll_sdma_t *)sc->gtmpsc_dma_segs[0].ds_addr; /* PA */ 511 #ifdef DEBUG 512 printf(" at %p/%p", vmps, pmps); 513 #endif 514 gtmpsc_txdesc_init(vmps, pmps); 515 gtmpsc_rxdesc_init(vmps, pmps); 516 sc->gtmpsc_poll_sdmapage = vmps; 517 518 if (gtmpsc_scp[sc->gtmpsc_unit] != NULL) 519 gtmpsc_txflush(gtmpsc_scp[sc->gtmpsc_unit]); 520 521 sc->gtmpsc_tty = tp = ttymalloc(); 522 tp->t_oproc = gtmpscstart; 523 tp->t_param = gtmpscparam; 524 tty_attach(tp); 525 526 gtmpsc_nattached++; 527 gtmpscinit(sc); 528 529 gtmpsc_scp[sc->gtmpsc_unit] = sc; 530 531 if (gtmpsc_nattached == 1) { 532 void *ih; 533 534 KASSERT(gtmpsc_sdma_ih == NULL); 535 ih = intr_establish(IRQ_SDMA, IST_LEVEL, IPL_SERIAL, 536 gtmpsc_intr, &sc); 537 if (ih == NULL) 538 panic("mpscattach: cannot intr_establish IRQ_SDMA"); 539 gtmpsc_sdma_ih = ih; 540 541 KASSERT(gtmpsc_soft_ih == NULL); 542 ih = intr_establish(SIR_SERIAL, IST_SOFT, IPL_SOFTSERIAL, 543 gtmpsc_softintr, NULL); 544 if (ih == NULL) 545 panic("mpscattach: cannot intr_establish SIR_SERIAL"); 546 gtmpsc_soft_ih = ih; 547 } 548 printf(" irqs %d, %d", IRQ_SDMA, SIR_SERIAL); 549 550 shutdownhook_establish(gtmpsc_shutdownhook, sc); 551 552 #ifdef DDB 553 if (sc->gtmpsc_unit == 0) 554 SDMA_IMASK_ENABLE(SDMA_INTR_RXBUF(sc->gtmpsc_unit)); 555 #endif /* DDB */ 556 557 printf("%s\n", (gt_reva_gtmpsc_bug) ? " [Rev A. bug]" : ""); 558 559 splx(s); 560 #ifdef KGDB 561 /* 562 * Allow kgdb to "take over" this port. If this is 563 * the kgdb device, it has exclusive use. 564 */ 565 if (sc->gtmpsc_unit == comkgdbport) { 566 if (comkgdbport == 0) { /* FIXME */ 567 printf("%s(kgdb): cannot share with console\n", 568 sc->gtmpsc_dev.dv_xname); 569 return; 570 } 571 572 sc->gtmpsc_flags |= GTMPSCF_KGDB; 573 printf("%s: kgdb\n", sc->gtmpsc_dev.dv_xname); 574 gtmpsc_txflush(gtmpsc_scp[0]); 575 kgdb_attach(gtmpsc_kgdb_getc, gtmpsc_kgdb_putc, NULL); 576 kgdb_dev = 123; /* unneeded, only to satisfy some tests */ 577 gtmpsc_kgdb_attached = 1; 578 SDMA_IMASK_ENABLE(SDMA_INTR_RXBUF(sc->gtmpsc_unit)); 579 kgdb_connect(1); 580 } 581 #endif /* KGDB */ 582 583 } 584 585 STATIC void 586 gtmpscshutdown(struct gtmpsc_softc *sc) 587 { 588 struct tty *tp; 589 int s; 590 591 #ifdef KGDB 592 if (sc->gtmpsc_flags & GTMPSCF_KGDB != 0) 593 return; 594 #endif 595 tp = sc->gtmpsc_tty; 596 s = splserial(); 597 /* Fake carrier off */ 598 (void) (*tp->t_linesw->l_modem)(tp, 0); 599 SDMA_IMASK_DISABLE(SDMA_INTR_RXBUF(sc->gtmpsc_unit)); 600 splx(s); 601 } 602 603 int 604 gtmpscopen(dev_t dev, int flag, int mode, struct proc *p) 605 { 606 struct gtmpsc_softc *sc; 607 int unit = GTMPSCUNIT(dev); 608 struct tty *tp; 609 int s; 610 int s2; 611 int error; 612 613 if (unit >= gtmpsc_cd.cd_ndevs) 614 return ENXIO; 615 sc = gtmpsc_cd.cd_devs[unit]; 616 if (!sc) 617 return ENXIO; 618 #ifdef KGDB 619 /* 620 * If this is the kgdb port, no other use is permitted. 621 */ 622 if (sc->gtmpsc_flags & GTMPSCF_KGDB != 0) 623 return (EBUSY); 624 #endif 625 tp = sc->gtmpsc_tty; 626 if (ISSET(tp->t_state, TS_ISOPEN) && 627 ISSET(tp->t_state, TS_XCLUDE) && 628 p->p_ucred->cr_uid != 0) 629 return (EBUSY); 630 631 s = spltty(); 632 633 if (!(tp->t_state & TS_ISOPEN)) { 634 struct termios t; 635 636 tp->t_dev = dev; 637 s2 = splserial(); 638 SDMA_IMASK_ENABLE(SDMA_INTR_RXBUF(unit)); 639 splx(s2); 640 t.c_ispeed = 0; 641 #if 0 642 t.c_ospeed = TTYDEF_SPEED; 643 #else 644 t.c_ospeed = GT_MPSC_DEFAULT_BAUD_RATE; 645 #endif 646 t.c_cflag = TTYDEF_CFLAG; 647 /* Make sure gtmpscparam() will do something. */ 648 tp->t_ospeed = 0; 649 (void) gtmpscparam(tp, &t); 650 tp->t_iflag = TTYDEF_IFLAG; 651 tp->t_oflag = TTYDEF_OFLAG; 652 tp->t_lflag = TTYDEF_LFLAG; 653 ttychars(tp); 654 ttsetwater(tp); 655 s2 = splserial(); 656 /* Clear the input ring */ 657 sc->gtmpsc_rxfifo_putix = 0; 658 sc->gtmpsc_rxfifo_getix = 0; 659 sc->gtmpsc_rxfifo_navail = GTMPSC_RXFIFOSZ; 660 gtmpsc_iflush(sc); 661 splx(s2); 662 } 663 splx(s); 664 error = ttyopen(tp, GTMPSCDIALOUT(dev), ISSET(flag, O_NONBLOCK)); 665 if (error) 666 goto bad; 667 668 error = (*tp->t_linesw->l_open)(dev, tp); 669 if (error) 670 goto bad; 671 672 return (0); 673 674 bad: 675 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 676 /* 677 * We failed to open the device, and nobody else had it opened. 678 * Clean up the state as appropriate. 679 */ 680 gtmpscshutdown(sc); 681 } 682 683 return (error); 684 } 685 686 int 687 gtmpscclose(dev_t dev, int flag, int mode, struct proc *p) 688 { 689 int unit = GTMPSCUNIT(dev); 690 struct gtmpsc_softc *sc = gtmpsc_cd.cd_devs[unit]; 691 struct tty *tp = sc->gtmpsc_tty; 692 int s; 693 694 s = splserial(); 695 if (!ISSET(tp->t_state, TS_ISOPEN)) { 696 splx(s); 697 return (0); 698 } 699 700 (*tp->t_linesw->l_close)(tp, flag); 701 ttyclose(tp); 702 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 703 /* 704 * Although we got a last close, the device may still be in 705 * use; e.g. if this was the dialout node, and there are still 706 * processes waiting for carrier on the non-dialout node. 707 */ 708 gtmpscshutdown(sc); 709 } 710 711 splx(s); 712 return (0); 713 } 714 715 int 716 gtmpscread(dev_t dev, struct uio *uio, int flag) 717 { 718 struct gtmpsc_softc *sc = gtmpsc_cd.cd_devs[GTMPSCUNIT(dev)]; 719 struct tty *tp = sc->gtmpsc_tty; 720 721 return (*tp->t_linesw->l_read)(tp, uio, flag); 722 } 723 724 int 725 gtmpscwrite(dev_t dev, struct uio *uio, int flag) 726 { 727 struct gtmpsc_softc *sc = gtmpsc_cd.cd_devs[GTMPSCUNIT(dev)]; 728 struct tty *tp = sc->gtmpsc_tty; 729 730 return (*tp->t_linesw->l_write)(tp, uio, flag); 731 } 732 733 int 734 gtmpscpoll(dev_t dev, int events, struct proc *p) 735 { 736 struct gtmpsc_softc *sc = gtmpsc_cd.cd_devs[GTMPSCUNIT(dev)]; 737 struct tty *tp = sc->gtmpsc_tty; 738 739 return ((*tp->t_linesw->l_poll)(tp, events, p)); 740 } 741 742 int 743 gtmpscioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) 744 { 745 struct gtmpsc_softc *sc = gtmpsc_cd.cd_devs[GTMPSCUNIT(dev)]; 746 struct tty *tp = sc->gtmpsc_tty; 747 int error; 748 749 if ((error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, p)) >= 0) 750 return error; 751 if ((error = ttioctl(tp, cmd, data, flag, p)) >= 0) 752 return error; 753 return ENOTTY; 754 } 755 756 struct tty * 757 gtmpsctty(dev_t dev) 758 { 759 struct gtmpsc_softc *sc = gtmpsc_cd.cd_devs[GTMPSCUNIT(dev)]; 760 761 return sc->gtmpsc_tty; 762 } 763 764 void 765 gtmpscstop(struct tty *tp, int flag) 766 { 767 } 768 769 STATIC void 770 gtmpscstart(struct tty *tp) 771 { 772 struct gtmpsc_softc *sc; 773 unsigned char *tba; 774 unsigned int unit; 775 int s, s2, tbc; 776 777 unit = GTMPSCUNIT(tp->t_dev); 778 if (unit >= GTMPSC_NCHAN) 779 return; 780 sc = gtmpsc_scp[unit]; 781 if (sc == NULL) 782 return; 783 784 s = spltty(); 785 if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP)) 786 goto out; 787 if (sc->sc_tx_stopped) 788 goto out; 789 if (tp->t_outq.c_cc <= tp->t_lowat) { 790 if ((tp->t_state & TS_ASLEEP) != 0) { 791 tp->t_state &= ~TS_ASLEEP; 792 wakeup(&tp->t_outq); 793 } 794 selwakeup(&tp->t_wsel); 795 if (tp->t_outq.c_cc == 0) 796 goto out; 797 } 798 799 /* Grab the first contiguous region of buffer space. */ 800 tba = tp->t_outq.c_cf; 801 tbc = ndqb(&tp->t_outq, 0); 802 803 s2 = splserial(); 804 805 sc->sc_tba = tba; 806 sc->sc_tbc = tbc; 807 sc->cnt_tx_from_ldisc += tbc; 808 SDMA_IMASK_ENABLE(SDMA_INTR_TXBUF(unit)); 809 tp->t_state |= TS_BUSY; 810 sc->sc_tx_busy = 1; 811 gtmpsc_common_putn(sc); 812 813 splx(s2); 814 out: 815 splx(s); 816 } 817 818 STATIC int 819 gtmpscparam(struct tty *tp, struct termios *t) 820 { 821 struct gtmpsc_softc *sc = gtmpsc_cd.cd_devs[GTMPSCUNIT(tp->t_dev)]; 822 int ospeed = compute_cdv(t->c_ospeed); 823 int s; 824 825 /* Check requested parameters. */ 826 if (ospeed < 0) 827 return (EINVAL); 828 if (t->c_ispeed && t->c_ispeed != t->c_ospeed) 829 return (EINVAL); 830 831 /* 832 * If there were no changes, don't do anything. This avoids dropping 833 * input and improves performance when all we did was frob things like 834 * VMIN and VTIME. 835 */ 836 if (tp->t_ospeed == t->c_ospeed && 837 tp->t_cflag == t->c_cflag) 838 return (0); 839 840 s = splserial(); 841 842 sc->gtmpsc_brg_bcr = BRG_BCR_EN | BRG_BCR_CLKS_TCLK | ospeed; 843 sc->gtmpsc_chr3 = GTMPSC_MAXIDLE(t->c_ospeed); 844 845 /* And copy to tty. */ 846 tp->t_ispeed = 0; 847 tp->t_ospeed = t->c_ospeed; 848 tp->t_cflag = t->c_cflag; 849 850 if (!sc->sc_heldchange) { 851 if (sc->sc_tx_busy) { 852 sc->sc_heldtbc = sc->sc_tbc; 853 sc->sc_tbc = 0; 854 sc->sc_heldchange = 1; 855 } else 856 gtmpsc_loadchannelregs(sc); 857 } 858 859 splx(s); 860 861 /* Fake carrier on */ 862 (void) (*tp->t_linesw->l_modem)(tp, 1); 863 864 return 0; 865 } 866 867 STATIC int 868 gtmpsc_probe(void) 869 { 870 return 1; /* XXX */ 871 } 872 873 STATIC unsigned int 874 gtmpsc_get_causes(void) 875 { 876 int i; 877 struct gtmpsc_softc *sc; 878 unsigned int cause = 0; 879 static unsigned int bits[4] = { 880 SDMA_INTR_RXBUF(0), 881 SDMA_INTR_TXBUF(0), 882 SDMA_INTR_RXBUF(1), 883 SDMA_INTR_TXBUF(1), 884 }; 885 sdma_desc_t *desc_addr[4]; 886 static unsigned int fake_once = SDMA_INTR_RXBUF(0) 887 | SDMA_INTR_RXBUF(1); 888 889 desc_addr[0] = 0; 890 desc_addr[1] = 0; 891 desc_addr[2] = 0; 892 desc_addr[3] = 0; 893 sc = gtmpsc_cd.cd_devs[0]; 894 if (sc != 0) { 895 if (sdma_imask & SDMA_INTR_RXBUF(0)) { 896 desc_addr[0] = 897 &sc->gtmpsc_poll_sdmapage->rx[sc->gtmpsc_poll_rxix].rxdesc; 898 GTMPSC_CACHE_INVALIDATE(desc_addr[0]); 899 asm volatile ("dcbt 0,%0" :: "r"(desc_addr[0])); 900 } 901 if (sdma_imask & SDMA_INTR_TXBUF(0)) { 902 desc_addr[1] = 903 &sc->gtmpsc_poll_sdmapage->tx[sc->gtmpsc_poll_txix].txdesc; 904 GTMPSC_CACHE_INVALIDATE(desc_addr[1]); 905 asm volatile ("dcbt 0,%0" :: "r"(desc_addr[1])); 906 } 907 } 908 sc = gtmpsc_cd.cd_devs[1]; 909 if (sc != 0) { 910 if (sdma_imask & SDMA_INTR_RXBUF(1)) { 911 desc_addr[2] = 912 &sc->gtmpsc_poll_sdmapage->rx[sc->gtmpsc_poll_rxix].rxdesc; 913 GTMPSC_CACHE_INVALIDATE(desc_addr[2]); 914 asm volatile ("dcbt 0,%0" :: "r"(desc_addr[2])); 915 } 916 if (sdma_imask & SDMA_INTR_TXBUF(1)) { 917 desc_addr[3] = 918 &sc->gtmpsc_poll_sdmapage->tx[sc->gtmpsc_poll_txix].txdesc; 919 GTMPSC_CACHE_INVALIDATE(desc_addr[3]); 920 asm volatile ("dcbt 0,%0" :: "r"(desc_addr[3])); 921 } 922 } 923 924 for (i = 0; i < 4; ++i) 925 if ((sdma_imask & bits[i]) && desc_addr[i] != 0 && 926 (desc_addr[i]->sdma_csr & SDMA_CSR_TX_OWN) == 0) 927 cause |= bits[i]; 928 if (fake_once & sdma_imask) { 929 cause |= fake_once & sdma_imask; 930 /* fake_once &= ~(cause & fake_once); */ 931 } 932 return cause; 933 } 934 935 STATIC int 936 gtmpsc_intr(void *arg) 937 { 938 struct gtmpsc_softc *sc; 939 unsigned int unit; 940 int spurious = 1; 941 unsigned int r; 942 unsigned int cause=0; 943 944 if (gt_reva_gtmpsc_bug) 945 cause = gtmpsc_get_causes(); 946 947 #ifdef KGDB 948 if (kgdb_break_immediate) { 949 unit = comkgdbport; 950 sc = gtmpsc_cd.cd_devs[unit]; 951 if (sc == 0 || (sc->gtmpsc_flags & GTMPSCF_KGDB) == 0) 952 goto skip_kgdb; 953 if (gt_reva_gtmpsc_bug) 954 r = cause & sdma_imask; 955 else { 956 r = GT_READ(sc->gtmpsc_dev.dv_parent, SDMA_ICAUSE); 957 r &= GT_READ(sc->gtmpsc_dev.dv_parent, SDMA_IMASK); 958 } 959 r &= SDMA_INTR_RXBUF(unit); 960 if (r == 0) 961 goto skip_kgdb; 962 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_ICAUSE, ~r); 963 spurious = 0; 964 gtmpsc_kgdb_poll(sc); 965 } 966 skip_kgdb: 967 #endif 968 for (unit = 0; unit < GTMPSC_NCHAN; ++unit) { 969 sc = gtmpsc_cd.cd_devs[unit]; 970 if (sc == 0) 971 continue; 972 if (gt_reva_gtmpsc_bug) 973 r = cause & sdma_imask; 974 else { 975 r = GT_READ(sc->gtmpsc_dev.dv_parent, SDMA_ICAUSE); 976 r &= GT_READ(sc->gtmpsc_dev.dv_parent, SDMA_IMASK); 977 } 978 r &= SDMA_U_INTR_MASK(unit); 979 if (r == 0) 980 continue; 981 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_ICAUSE, ~r); 982 spurious = 0; 983 if (r & SDMA_INTR_RXBUF(unit)) { 984 #ifdef KGDB 985 if (sc->gtmpsc_flags & GTMPSCF_KGDB) 986 gtmpsc_kgdb_poll(sc); 987 else 988 #endif 989 gtmpsc_poll(sc); 990 } 991 if (r & SDMA_INTR_TXBUF(unit)) { 992 /* 993 * If we've delayed a parameter change, do it now, 994 * and restart output. 995 */ 996 if (sc->sc_heldchange) { 997 gtmpsc_loadchannelregs(sc); 998 sc->sc_heldchange = 0; 999 sc->sc_tbc = sc->sc_heldtbc; 1000 sc->sc_heldtbc = 0; 1001 } 1002 1003 /* Output the next chunk of the contiguous buffer, 1004 if any. */ 1005 if (sc->sc_tbc > 0) 1006 gtmpsc_common_putn(sc); 1007 if (sc->sc_tbc == 0 && sc->sc_tx_busy) { 1008 sc->sc_tx_busy = 0; 1009 sc->sc_tx_done = 1; 1010 setsoftserial(); 1011 SDMA_IMASK_DISABLE(SDMA_INTR_TXBUF(unit)); 1012 } 1013 } 1014 } 1015 return 1; 1016 /* return !spurious; */ 1017 } 1018 1019 STATIC int 1020 gtmpsc_softintr(void *unused) 1021 { 1022 unsigned int unit; 1023 struct gtmpsc_softc *sc; 1024 struct tty *tp; 1025 int (*rint) __P((int c, struct tty *tp)); 1026 int jobs; 1027 int s; 1028 1029 for (unit = 0; unit < GTMPSC_NCHAN; ++unit) { 1030 sc = gtmpsc_cd.cd_devs[unit]; 1031 if (sc == 0) 1032 continue; 1033 tp = sc->gtmpsc_tty; 1034 rint = tp->t_linesw->l_rint; 1035 do { 1036 jobs = 0; 1037 if (sc->gtmpsc_rxfifo_navail < GTMPSC_RXFIFOSZ) { 1038 s = spltty(); 1039 rint(sc->gtmpsc_rxfifo[sc->gtmpsc_rxfifo_getix++], 1040 tp); 1041 if (sc->gtmpsc_rxfifo_getix >= GTMPSC_RXFIFOSZ) 1042 sc->gtmpsc_rxfifo_getix = 0; 1043 ++sc->cnt_rx_from_fifo; 1044 /* atomic_add() returns the previous value */ 1045 jobs += atomic_add(&sc->gtmpsc_rxfifo_navail, 1) + 1 1046 < GTMPSC_RXFIFOSZ; 1047 splx(s); 1048 } 1049 if (sc->sc_tx_done) { 1050 ++jobs; 1051 sc->sc_tx_done = 0; 1052 s = spltty(); 1053 tp->t_state &= ~TS_BUSY; 1054 if ((tp->t_state & TS_FLUSH) != 0) 1055 tp->t_state &= ~TS_FLUSH; 1056 else 1057 ndflush(&tp->t_outq, (int)(sc->sc_tba - tp->t_outq.c_cf)); 1058 (*tp->t_linesw->l_start)(tp); 1059 splx(s); 1060 } 1061 } while (jobs); 1062 } 1063 return 1; 1064 } 1065 1066 /* 1067 * Console support functions 1068 */ 1069 void 1070 gtmpsccnprobe(struct consdev *cd) 1071 { 1072 int maj; 1073 /* {extern void return_to_dink(int); return_to_dink(gtbase);} */ 1074 1075 if (!gtmpsc_probe()) 1076 return; 1077 1078 maj = cdevsw_lookup_major(>mpsc_cdevsw); 1079 cd->cn_dev = makedev(maj, 0); 1080 cd->cn_pri = CN_INTERNAL; 1081 } 1082 1083 /* 1084 * gtmpsc_hackinit - hacks required to supprt GTMPSC console 1085 */ 1086 STATIC void 1087 gtmpsc_hackinit(struct gtmpsc_softc *sc) 1088 { 1089 gtmpsc_poll_sdma_t *vmps; 1090 gtmpsc_poll_sdma_t *pmps; 1091 1092 DPRINTF(("hackinit\n")); 1093 1094 bzero(sc, sizeof(struct gtmpsc_softc)); 1095 gtmpsc_scp[sc->gtmpsc_unit] = sc; 1096 1097 vmps = (gtmpsc_poll_sdma_t *)gtmpsc_fake_dmapage; /* KVA */ 1098 pmps = (gtmpsc_poll_sdma_t *)gtmpsc_fake_dmapage; /* PA */ 1099 1100 gtmpsc_txdesc_init(vmps, pmps); 1101 gtmpsc_rxdesc_init(vmps, pmps); 1102 1103 sc->gtmpsc_poll_sdmapage = vmps; 1104 } 1105 1106 /* 1107 * gtmpsc_txflush - wait for output to drain 1108 */ 1109 STATIC void 1110 gtmpsc_txflush(gtmpsc_softc_t *sc) 1111 { 1112 unsigned int csr; 1113 unsigned int *csrp; 1114 gtmpsc_polltx_t *vtxp; 1115 int limit = 4000000; /* 4 seconds */ 1116 int ix; 1117 1118 ix = sc->gtmpsc_poll_txix - 1; 1119 if (ix < 0) 1120 ix = GTMPSC_NTXDESC - 1; 1121 1122 vtxp = &sc->gtmpsc_poll_sdmapage->tx[ix]; 1123 csrp = &vtxp->txdesc.sdma_csr; 1124 while (limit > 0) { 1125 GTMPSC_CACHE_INVALIDATE(csrp); 1126 csr = desc_read(csrp); 1127 if ((csr & SDMA_CSR_TX_OWN) == 0) 1128 break; 1129 DELAY(GTMPSC_POLL_DELAY); 1130 limit -= GTMPSC_POLL_DELAY; 1131 } 1132 } 1133 1134 STATIC void 1135 gtmpsc_iflush(gtmpsc_softc_t *sc) 1136 { 1137 int timo; 1138 char c; 1139 int stat; 1140 1141 for (timo = 50000; timo; timo--) 1142 if (gtmpsc_common_pollc(sc->gtmpsc_unit, &c, &stat) == 0) 1143 return; 1144 #ifdef DIAGNOSTIC 1145 printf("%s: gtmpsc_iflush timeout %02x\n", sc->gtmpsc_dev.dv_xname, c); 1146 #endif 1147 } 1148 1149 STATIC void 1150 gtmpscinit_stop(struct gtmpsc_softc *sc, int once) 1151 { 1152 unsigned int r; 1153 unsigned int unit = sc->gtmpsc_unit; 1154 1155 /* 1156 * XXX HACK FIXME 1157 * PMON output has not been flushed. give him a chance 1158 */ 1159 #if 1 1160 if (! once) 1161 DELAY(100000); /* XXX */ 1162 #endif 1163 1164 DPRINTF(("mpscinit: unit 0x%x\n", unit)); 1165 if (unit >= GTMPSC_NCHAN) { 1166 PRINTF(("mpscinit: undefined unit %d\n", sc->gtmpsc_unit)); 1167 return; 1168 } 1169 1170 sc->gtmpsc_chr2 = 0; /* Default value of CHR2 */ 1171 1172 /* 1173 * stop GTMPSC unit 1174 */ 1175 r = sc->gtmpsc_chr2 | GTMPSC_CHR2_RXABORT|GTMPSC_CHR2_TXABORT; 1176 GT_WRITE(sc->gtmpsc_dev.dv_parent, GTMPSC_U_CHRN(unit, 2), r); 1177 1178 DELAY(GTMPSC_RESET_DELAY); 1179 1180 /* 1181 * abort SDMA TX, RX for GTMPSC unit 1182 */ 1183 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_U_SDCM(unit), 1184 SDMA_SDCM_AR|SDMA_SDCM_AT); 1185 1186 if (once == 0) { 1187 /* 1188 * Determine if this is the buggy GT-64260A case. 1189 * If this is, then most of GTMPSC and SDMA registers 1190 * are unreadable. 1191 * (They always yield -1). 1192 */ 1193 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_IMASK, 0); 1194 r = GT_READ(sc->gtmpsc_dev.dv_parent, SDMA_IMASK); 1195 gt_reva_gtmpsc_bug = r == ~0; 1196 sdma_imask = 0; 1197 } 1198 /* 1199 * poll for GTMPSC RX abort completion 1200 */ 1201 if (gt_reva_gtmpsc_bug) { 1202 /* Sync up with the device first */ 1203 r = GT_READ(sc->gtmpsc_dev.dv_parent, GTMPSC_U_CHRN(unit, 2)); 1204 DELAY(GTMPSC_RESET_DELAY); 1205 } else 1206 for (;;) { 1207 r = GT_READ(sc->gtmpsc_dev.dv_parent, 1208 GTMPSC_U_CHRN(unit, 2)); 1209 if (! (r & GTMPSC_CHR2_RXABORT)) 1210 break; 1211 } 1212 1213 /* 1214 * poll for SDMA RX abort completion 1215 */ 1216 for (;;) { 1217 r = GT_READ(sc->gtmpsc_dev.dv_parent, SDMA_U_SDCM(unit)); 1218 if (! (r & SDMA_SDCM_AR)) 1219 break; 1220 } 1221 1222 } 1223 1224 STATIC void 1225 gtmpscinit_start(struct gtmpsc_softc *sc, int once) 1226 { 1227 unsigned int r; 1228 unsigned int unit = sc->gtmpsc_unit; 1229 1230 /* 1231 * initialize softc's "current" transfer indicies & counts 1232 */ 1233 sc->gtmpsc_cx = 0; 1234 sc->gtmpsc_nc = 0; 1235 sc->gtmpsc_poll_txix = 0; 1236 sc->gtmpsc_poll_rxix = 0; 1237 1238 /* 1239 * initialize softc's RX softintr FIFO 1240 */ 1241 sc->gtmpsc_rxfifo_putix = 0; 1242 sc->gtmpsc_rxfifo_getix = 0; 1243 sc->gtmpsc_rxfifo_navail = GTMPSC_RXFIFOSZ; 1244 memset(&sc->gtmpsc_rxfifo[0], 0, GTMPSC_RXFIFOSZ); 1245 1246 /* 1247 * set SDMA unit port TX descriptor pointers 1248 * "next" pointer of last descriptor is start of ring 1249 */ 1250 r = desc_read( 1251 &sc->gtmpsc_poll_sdmapage->tx[GTMPSC_NTXDESC-1].txdesc.sdma_next); 1252 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_U_SCTDP(unit), r); /* current */ 1253 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_U_SFTDP(unit), r); /* first */ 1254 /* 1255 * set SDMA unit port RX descriptor pointer 1256 * "next" pointer of last descriptor is start of ring 1257 */ 1258 r = desc_read( 1259 &sc->gtmpsc_poll_sdmapage->rx[GTMPSC_NRXDESC-1].rxdesc.sdma_next); 1260 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_U_SCRDP(unit), r); /* current */ 1261 1262 /* 1263 * initialize SDMA unit Configuration Register 1264 */ 1265 r = SDMA_SDC_BSZ_8x64|SDMA_SDC_SFM|SDMA_SDC_RFT; 1266 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_U_SDC(unit), r); 1267 1268 /* 1269 * enable SDMA receive 1270 */ 1271 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_U_SDCM(unit), SDMA_SDCM_ERD); 1272 1273 if (once++ == 0) { 1274 /* 1275 * GTMPSC Routing: 1276 * MR0 --> Serial Port 0 1277 * MR1 --> Serial Port 1 1278 */ 1279 GT_WRITE(sc->gtmpsc_dev.dv_parent, GTMPSC_MRR, GTMPSC_MRR_RES); 1280 1281 /* 1282 * RX and TX Clock Routing: 1283 * CRR0 --> BRG0 1284 * CRR1 --> BRG1 1285 */ 1286 r = GTMPSC_CRR_BRG0 | (GTMPSC_CRR_BRG1 << GTMPSC_CRR1_SHIFT); 1287 GT_WRITE(sc->gtmpsc_dev.dv_parent, GTMPSC_RCRR, r); 1288 GT_WRITE(sc->gtmpsc_dev.dv_parent, GTMPSC_TCRR, r); 1289 } 1290 sc->gtmpsc_brg_bcr = 1291 BRG_BCR_EN | BRG_BCR_CLKS_TCLK | compute_cdv(GT_MPSC_DEFAULT_BAUD_RATE); 1292 sc->gtmpsc_chr3 = GTMPSC_MAXIDLE(GT_MPSC_DEFAULT_BAUD_RATE); 1293 gtmpsc_loadchannelregs(sc); 1294 1295 /* 1296 * set MPSC Protocol configuration register for GTMPSC unit 1297 */ 1298 GT_WRITE(sc->gtmpsc_dev.dv_parent, GTMPSC_U_MPCR(unit), GTMPSC_MPCR_CL_8); 1299 1300 /* 1301 * set MPSC LO and HI port config registers for GTMPSC unit 1302 */ 1303 r = GTMPSC_MMCR_LO_MODE_UART 1304 |GTMPSC_MMCR_LO_ET 1305 |GTMPSC_MMCR_LO_ER 1306 |GTMPSC_MMCR_LO_NLM; 1307 GT_WRITE(sc->gtmpsc_dev.dv_parent, GTMPSC_U_MMCR_LO(unit), r); 1308 1309 r = 1310 GTMPSC_MMCR_HI_TCDV_DEFAULT 1311 |GTMPSC_MMCR_HI_RDW 1312 |GTMPSC_MMCR_HI_RCDV_DEFAULT; 1313 GT_WRITE(sc->gtmpsc_dev.dv_parent, GTMPSC_U_MMCR_HI(unit), r); 1314 1315 /* 1316 * tell MPSC receive the Enter Hunt 1317 */ 1318 r = sc->gtmpsc_chr2 | GTMPSC_CHR2_EH; 1319 GT_WRITE(sc->gtmpsc_dev.dv_parent, GTMPSC_U_CHRN(unit, 2), r); 1320 1321 /* 1322 * clear any pending SDMA interrupts for this unit 1323 */ 1324 r = GT_READ(sc->gtmpsc_dev.dv_parent, SDMA_ICAUSE); 1325 r &= ~SDMA_U_INTR_MASK(unit); 1326 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_ICAUSE, r); /* ??? */ 1327 1328 DPRINTF(("gtmpscinit: OK\n")); 1329 } 1330 1331 /* 1332 * gtmpscinit - prepare MPSC for operation 1333 * 1334 * assumes we are called at ipl >= IPL_SERIAL 1335 */ 1336 STATIC void 1337 gtmpscinit(struct gtmpsc_softc *sc) 1338 { 1339 static int once = 0; 1340 1341 gtmpscinit_stop(sc, once); 1342 gtmpscinit_start(sc, once); 1343 once++; 1344 } 1345 1346 /* 1347 * gtmpsccninit - initialize the driver and the mpsc device 1348 */ 1349 void 1350 gtmpsccninit(struct consdev *cd) 1351 { 1352 struct gtmpsc_softc *sc; 1353 unsigned int unit; 1354 int s; 1355 1356 unit = GTMPSCUNIT(cd->cn_dev); 1357 DPRINTF(("gtmpsccninit unit 0x%x\n", unit)); 1358 1359 s = splserial(); 1360 1361 if (gtmpsc_nattached == 0) { 1362 unsigned char *cp; 1363 unsigned char c; 1364 unsigned int i; 1365 1366 sc = >mpsc_fake_softc; 1367 gtmpsc_hackinit(sc); 1368 gtmpscinit(sc); 1369 gtmpsccninit_done = 1; 1370 cp = gtmpsc_earlybuf; 1371 for (i=0; i < sizeof(gtmpsc_earlybuf); i++) { 1372 c = *cp++; 1373 if (c == 0) 1374 break; 1375 gtmpsc_common_putc(0, c); 1376 } 1377 } else { 1378 gtmpsc_poll_sdma_t *vmps; 1379 gtmpsc_poll_sdma_t *pmps; 1380 1381 sc = gtmpsc_scp[unit]; 1382 1383 gtmpsc_txflush(gtmpsc_scp[sc->gtmpsc_unit]); 1384 SDMA_IMASK_DISABLE(SDMA_INTR_RXBUF(sc->gtmpsc_unit) 1385 | SDMA_INTR_TXBUF(sc->gtmpsc_unit)); 1386 1387 gtmpscinit_stop(sc, 1); 1388 1389 pmps = (gtmpsc_poll_sdma_t *)sc->gtmpsc_dma_segs[0].ds_addr; 1390 vmps = sc->gtmpsc_poll_sdmapage; 1391 gtmpsc_txdesc_init(vmps, pmps); 1392 gtmpsc_rxdesc_init(vmps, pmps); 1393 1394 gtmpscinit_start(sc, 1); 1395 } 1396 1397 splx(s); 1398 } 1399 1400 int 1401 gtmpsccngetc(dev_t dev) 1402 { 1403 int s; 1404 int c; 1405 unsigned int unit; 1406 1407 unit = GTMPSCUNIT(dev); 1408 if (unit >= GTMPSC_NCHAN) 1409 return 0; 1410 s = splserial(); 1411 c = gtmpsc_common_getc(unit); 1412 splx(s); 1413 1414 return c; 1415 } 1416 1417 void 1418 gtmpsccnputc(dev_t dev, int c) 1419 { 1420 char ch = c; 1421 int s; 1422 unsigned int unit; 1423 static int ix = 0; 1424 1425 if (gtmpsccninit_done == 0) { 1426 if ((minor(dev) == 0) && (ix < sizeof(gtmpsc_earlybuf))) 1427 gtmpsc_earlybuf[ix++] = (unsigned char)c; 1428 return; 1429 } 1430 1431 unit = GTMPSCUNIT(dev); 1432 DPRINTF(("gtmpsccninit unit 0x%x\n", unit)); 1433 1434 if (unit >= GTMPSC_NCHAN) 1435 return; 1436 s = splserial(); 1437 gtmpsc_common_putc(unit, ch); 1438 splx(s); 1439 } 1440 1441 void 1442 gtmpsccnpollc(dev_t dev, int on) 1443 { 1444 } 1445 1446 /* 1447 * gtmpsc_common_pollc - non-blocking console read 1448 * 1449 * if there is an RX char, return it in *cp 1450 * set *statp if Break detected 1451 * 1452 * assumes we are called at ipl >= IPL_SERIAL 1453 * 1454 * return 1 if there is RX data 1455 * otherwise return 0 1456 */ 1457 STATIC int 1458 gtmpsc_common_pollc(unsigned int unit, char *cp, int *statp) 1459 { 1460 struct gtmpsc_softc *sc = gtmpsc_scp[unit]; 1461 gtmpsc_pollrx_t *vrxp; 1462 unsigned int ix; 1463 unsigned int cx; 1464 unsigned int nc; 1465 1466 *statp = GTMPSC_STAT_NONE; 1467 ix = sc->gtmpsc_poll_rxix; 1468 nc = sc->gtmpsc_nc; 1469 cx = sc->gtmpsc_cx; 1470 if (nc == 0) { 1471 unsigned int *csrp; 1472 unsigned int csr; 1473 1474 vrxp = &sc->gtmpsc_poll_sdmapage->rx[ix]; 1475 csrp = &vrxp->rxdesc.sdma_csr; 1476 cx = 0; 1477 1478 GTMPSC_CACHE_INVALIDATE(csrp); 1479 csr = desc_read(csrp); 1480 if (csr & SDMA_CSR_RX_OWN) 1481 return 0; 1482 if (csr & SDMA_CSR_RX_BR) 1483 *statp = GTMPSC_STAT_BREAK; 1484 if (csr & SDMA_CSR_RX_ES) 1485 PRINTF(("mpsc 0 RX error, rxdesc csr 0x%x\n", csr)); 1486 1487 nc = desc_read(&vrxp->rxdesc.sdma_cnt); 1488 nc &= SDMA_RX_CNT_BCNT_MASK; 1489 csr = SDMA_CSR_RX_L|SDMA_CSR_RX_F|SDMA_CSR_RX_OWN 1490 |SDMA_CSR_RX_EI; 1491 if (nc == 0) { 1492 if ((++ix) >= GTMPSC_NRXDESC) 1493 ix = 0; 1494 sc->gtmpsc_poll_rxix = ix; 1495 desc_write(csrp, csr); 1496 GTMPSC_CACHE_FLUSH(csrp); 1497 return 0; 1498 } 1499 bcopy(vrxp->rxbuf, sc->gtmpsc_rxbuf, nc); 1500 desc_write(csrp, csr); 1501 GTMPSC_CACHE_FLUSH(csrp); 1502 } 1503 gtmpsc_poll_pollc_cnt++; 1504 nc--; 1505 *cp = sc->gtmpsc_rxbuf[cx++]; 1506 if (nc == 0) { 1507 if ((++ix) >= GTMPSC_NRXDESC) 1508 ix = 0; 1509 sc->gtmpsc_poll_rxix = ix; 1510 } 1511 sc->gtmpsc_cx = cx; 1512 sc->gtmpsc_nc = nc; 1513 return 1; 1514 } 1515 1516 /* 1517 * gtmpsc_common_getc - polled console read 1518 * 1519 * We copy data from the DMA buffers into a buffer in the softc 1520 * to reduce descriptor ownership turnaround time 1521 * MPSC can crater if it wraps descriptor rings, 1522 * which is asynchronous and throttled only by line speed. 1523 * 1524 * This code assumes the buffer PA==KVA 1525 * and assumes we are called at ipl >= IPL_SERIAL 1526 */ 1527 STATIC int 1528 gtmpsc_common_getc(unsigned int unit) 1529 { 1530 struct gtmpsc_softc *sc = gtmpsc_scp[unit]; 1531 gtmpsc_pollrx_t *vrxp; 1532 unsigned int ix; 1533 unsigned int cx; 1534 unsigned int nc; 1535 int c; 1536 1537 ix = sc->gtmpsc_poll_rxix; 1538 nc = sc->gtmpsc_nc; 1539 cx = sc->gtmpsc_cx; 1540 while (nc == 0) { 1541 unsigned int *csrp; 1542 unsigned int csr; 1543 unsigned int r; 1544 1545 vrxp = &sc->gtmpsc_poll_sdmapage->rx[ix]; 1546 csrp = &vrxp->rxdesc.sdma_csr; 1547 cx = 0; 1548 1549 GTMPSC_CACHE_INVALIDATE(csrp); 1550 csr = desc_read(csrp); 1551 if (csr & SDMA_CSR_RX_OWN) { 1552 r = sc->gtmpsc_chr2 | GTMPSC_CHR2_CRD; 1553 GT_WRITE(sc->gtmpsc_dev.dv_parent, 1554 GTMPSC_U_CHRN(unit, 2), r); 1555 do { 1556 1557 gtmpsc_poll_getc_miss++; 1558 GTMPSC_CACHE_INVALIDATE(csrp); 1559 csr = desc_read(csrp); 1560 } while (csr & SDMA_CSR_RX_OWN); 1561 } 1562 if (csr & SDMA_CSR_RX_ES) 1563 PRINTF(("mpsc 0 RX error, rxdesc csr 0x%x\n", csr)); 1564 1565 nc = desc_read(&vrxp->rxdesc.sdma_cnt); 1566 nc &= SDMA_RX_CNT_BCNT_MASK; 1567 if (nc) { 1568 bcopy(vrxp->rxbuf, sc->gtmpsc_rxbuf, nc); 1569 } else { 1570 if ((++ix) >= GTMPSC_NRXDESC) 1571 ix = 0; 1572 sc->gtmpsc_poll_rxix = ix; 1573 } 1574 csr = SDMA_CSR_RX_L|SDMA_CSR_RX_F|SDMA_CSR_RX_OWN 1575 |SDMA_CSR_RX_EI; 1576 desc_write(csrp, csr); 1577 GTMPSC_CACHE_FLUSH(csrp); 1578 #ifdef KGDB 1579 if (unit == comkgdbport && gt_reva_gtmpsc_bug) 1580 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_ICAUSE, 1581 ~SDMA_INTR_RXBUF(unit)); 1582 #endif 1583 } 1584 gtmpsc_poll_getc_cnt++; 1585 nc--; 1586 c = (int)sc->gtmpsc_rxbuf[cx++]; 1587 if (nc == 0) { 1588 if ((++ix) >= GTMPSC_NRXDESC) 1589 ix = 0; 1590 sc->gtmpsc_poll_rxix = ix; 1591 } 1592 sc->gtmpsc_cx = cx; 1593 sc->gtmpsc_nc = nc; 1594 return c; 1595 } 1596 1597 /* 1598 * gtmpsc_common_putn - write a buffer into the hardware 1599 * 1600 * assumes we are called at ipl >= IPL_SERIAL 1601 */ 1602 STATIC void 1603 gtmpsc_common_putn(struct gtmpsc_softc *sc) 1604 1605 { 1606 int unit = sc->gtmpsc_unit; 1607 int n; 1608 int kick; 1609 gtmpsc_polltx_t *vtxp; 1610 unsigned int *csrp; 1611 unsigned int csr; 1612 unsigned int ix; 1613 unsigned int sdcm; 1614 1615 kick = 0; 1616 for (ix = sc->gtmpsc_poll_txix; sc->sc_tbc;) { 1617 vtxp = &sc->gtmpsc_poll_sdmapage->tx[ix]; 1618 csrp = &vtxp->txdesc.sdma_csr; 1619 GTMPSC_CACHE_INVALIDATE(csrp); 1620 csr = desc_read(csrp); 1621 if ((csr & SDMA_CSR_TX_OWN) != 0) 1622 break; 1623 n = sc->sc_tbc; 1624 if (n > GTMPSC_TXBUFSZ) 1625 n = GTMPSC_TXBUFSZ; 1626 bcopy(sc->sc_tba, vtxp->txbuf, n); 1627 csr = SDMA_CSR_TX_L | SDMA_CSR_TX_F 1628 | SDMA_CSR_TX_EI | SDMA_CSR_TX_OWN; 1629 desc_write(&vtxp->txdesc.sdma_cnt, 1630 (n << SDMA_TX_CNT_BCNT_SHIFT) | n); 1631 desc_write(csrp, csr); 1632 GTMPSC_CACHE_FLUSH(csrp); 1633 sc->sc_tbc -= n; 1634 sc->sc_tba += n; 1635 gtmpsc_poll_putn_cnt += n; 1636 sc->cnt_tx_to_sdma += n; 1637 kick = 1; 1638 1639 if (++ix >= GTMPSC_NTXDESC) 1640 ix = 0; 1641 } 1642 if (kick) { 1643 sc->gtmpsc_poll_txix = ix; 1644 1645 /* 1646 * now kick some SDMA 1647 */ 1648 sdcm = GT_READ(sc->gtmpsc_dev.dv_parent, SDMA_U_SDCM(unit)); 1649 1650 if ((sdcm & SDMA_SDCM_TXD) == 0) { 1651 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_U_SDCM(unit), 1652 SDMA_SDCM_TXD); 1653 } 1654 } 1655 } 1656 1657 /* 1658 * gtmpsc_common_putc - polled console putc 1659 * 1660 * assumes we are called at ipl >= IPL_SERIAL 1661 */ 1662 STATIC void 1663 gtmpsc_common_putc(unsigned int unit, unsigned char c) 1664 { 1665 struct gtmpsc_softc *sc = gtmpsc_scp[unit]; 1666 gtmpsc_polltx_t *vtxp; 1667 unsigned int *csrp; 1668 unsigned int csr; 1669 unsigned int ix; 1670 unsigned int nix; 1671 unsigned int sdcm; 1672 1673 ix = sc->gtmpsc_poll_txix; 1674 nix = ix + 1; 1675 if (nix >= GTMPSC_NTXDESC) 1676 nix = 0; 1677 sc->gtmpsc_poll_txix = nix; 1678 vtxp = &sc->gtmpsc_poll_sdmapage->tx[ix]; 1679 csrp = &vtxp->txdesc.sdma_csr; 1680 1681 for (;;) { 1682 1683 GTMPSC_CACHE_INVALIDATE(csrp); 1684 csr = desc_read(csrp); 1685 if ((csr & SDMA_CSR_TX_OWN) == 0) 1686 break; 1687 gtmpsc_poll_putc_miss++; 1688 } 1689 if (csr & SDMA_CSR_TX_ES) 1690 PRINTF(("mpsc 0 TX error, txdesc csr 0x%x\n", csr)); 1691 1692 gtmpsc_poll_putc_cnt++; 1693 vtxp->txbuf[0] = c; 1694 csr = SDMA_CSR_TX_L | SDMA_CSR_TX_F 1695 | SDMA_CSR_TX_EI | SDMA_CSR_TX_OWN; 1696 desc_write(&vtxp->txdesc.sdma_cnt, (1 << SDMA_TX_CNT_BCNT_SHIFT) | 1); 1697 desc_write(csrp, csr); 1698 GTMPSC_CACHE_FLUSH(csrp); 1699 1700 /* 1701 * now kick some SDMA 1702 */ 1703 sdcm = GT_READ(sc->gtmpsc_dev.dv_parent, SDMA_U_SDCM(unit)); 1704 1705 if ((sdcm & SDMA_SDCM_TXD) == 0) { 1706 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_U_SDCM(unit), 1707 SDMA_SDCM_TXD); 1708 } 1709 } 1710 1711 1712 STATIC void 1713 gtmpsc_poll(void *arg) 1714 { 1715 struct gtmpsc_softc *sc = (struct gtmpsc_softc *)arg; 1716 int kick; 1717 char ch; 1718 int stat; 1719 static struct timeval msg_time = {0,0}; 1720 static struct timeval cur_time; 1721 static int fifo_full = 0; 1722 1723 kick = 0; 1724 while (gtmpsc_common_pollc(sc->gtmpsc_unit, &ch, &stat)) { 1725 #ifdef DDB 1726 if (stat) 1727 break; 1728 #endif 1729 ++sc->cnt_rx_from_sdma; 1730 if (sc->gtmpsc_rxfifo_navail != 0) { 1731 sc->gtmpsc_rxfifo[sc->gtmpsc_rxfifo_putix++] = ch; 1732 if (sc->gtmpsc_rxfifo_putix == GTMPSC_RXFIFOSZ) 1733 sc->gtmpsc_rxfifo_putix = 0; 1734 atomic_add(&sc->gtmpsc_rxfifo_navail, -1); 1735 ++sc->cnt_rx_to_fifo; 1736 fifo_full = 0; 1737 kick = 1; 1738 } else { 1739 if (fifo_full == 0) { 1740 fifo_full = 1; 1741 microtime(&cur_time); 1742 if (cur_time.tv_sec - msg_time.tv_sec >= 5) { 1743 /* Only do this once in 5 sec */ 1744 msg_time = cur_time; 1745 printf("mpsc%d: input FIFO full, " 1746 "dropping incoming characters\n", 1747 sc->gtmpsc_unit); 1748 } 1749 } 1750 } 1751 } 1752 #ifdef DDB 1753 if (stat) { 1754 struct consdev *ocd = cn_tab; 1755 if (ocd->cn_init != gtmpsccninit) { 1756 cn_tab = &constab[0]; 1757 Debugger(); 1758 cn_tab = ocd; 1759 } else { 1760 Debugger(); 1761 } 1762 } 1763 #endif 1764 if (kick) 1765 setsoftserial(); 1766 } 1767 1768 #ifdef KGDB 1769 /* ARGSUSED */ 1770 STATIC int 1771 gtmpsc_kgdb_getc(arg) 1772 void *arg; 1773 { 1774 1775 return (gtmpsc_common_getc(comkgdbport)); 1776 } 1777 1778 /* ARGSUSED */ 1779 STATIC void 1780 gtmpsc_kgdb_putc(arg, c) 1781 void *arg; 1782 int c; 1783 { 1784 1785 return (gtmpsc_common_putc(comkgdbport, c)); 1786 } 1787 1788 STATIC void 1789 gtmpsc_kgdb_poll(void *arg) 1790 { 1791 struct gtmpsc_softc *sc = (struct gtmpsc_softc *)arg; 1792 int s; 1793 char c; 1794 int brk; 1795 1796 s = splserial(); 1797 if (kgdb_recover == 0) { /* gdb is not currently talking to its agent */ 1798 while (gtmpsc_common_pollc(sc->gtmpsc_unit, &c, &brk)) { 1799 if (c == CTRL('c')) 1800 brk = GTMPSC_STAT_BREAK; 1801 if (brk == GTMPSC_STAT_BREAK) 1802 break; 1803 } 1804 if (brk == GTMPSC_STAT_BREAK) { 1805 if (kgdb_break_immediate) 1806 breakpoint(); 1807 else { 1808 printf("connecting to kgdb\n"); 1809 kgdb_connect(1); 1810 } 1811 } 1812 } 1813 splx(s); 1814 } 1815 1816 #endif /* KGDB */ 1817 1818 void 1819 #ifdef __STDC__ 1820 gtmpsc_printf(const char *fmt, ...) 1821 #else 1822 gtmpsc_printf(fmt, va_alist) 1823 char *fmt; 1824 va_dcl 1825 #endif 1826 1827 { 1828 struct consdev *ocd; 1829 int s; 1830 va_list ap; 1831 1832 s = splserial(); 1833 ocd = cn_tab; 1834 cn_tab = &constab[0]; 1835 va_start(ap, fmt); 1836 printf(fmt, ap); 1837 va_end(ap); 1838 cn_tab = ocd; 1839 splx(s); 1840 } 1841 1842 void 1843 #ifdef __STDC__ 1844 gtmpsc_mem_printf(const char *fmt, ...) 1845 #else 1846 gtmpsc_mem_printf(fmt, va_alist) 1847 char *fmt; 1848 va_dcl 1849 #endif 1850 { 1851 int s; 1852 va_list ap; 1853 static unsigned char *p = gtmpsc_print_buf; 1854 1855 s = splserial(); 1856 if (p >= >mpsc_print_buf[GTMPSC_PRINT_BUF_SIZE - 128]) { 1857 bzero(gtmpsc_print_buf, GTMPSC_PRINT_BUF_SIZE); 1858 p = gtmpsc_print_buf; 1859 } 1860 va_start(ap, fmt); 1861 p += vsprintf(p, fmt, ap); 1862 va_end(ap); 1863 splx(s); 1864 } 1865 1866 void 1867 gtmpsc_shutdownhook(void *arg) 1868 { 1869 gtmpsc_softc_t *sc = (gtmpsc_softc_t *)arg; 1870 1871 gtmpsc_txflush(sc); 1872 } 1873 1874 void 1875 gtmpsccnhalt(dev_t dev) 1876 { 1877 unsigned int unit; 1878 gtmpsc_softc_t *sc = gtmpsc_scp[unit]; 1879 u_int32_t r; 1880 1881 for (unit = 0; unit < GTMPSC_NCHAN; unit++) { 1882 sc = gtmpsc_scp[unit]; 1883 if (sc == NULL) 1884 continue; 1885 1886 /* 1887 * flush TX buffers 1888 */ 1889 gtmpsc_txflush(sc); 1890 1891 /* 1892 * stop MPSC unit RX 1893 */ 1894 r = GT_READ(sc->gtmpsc_dev.dv_parent, GTMPSC_U_CHRN(unit, 2)); 1895 r &= ~GTMPSC_CHR2_EH; 1896 r |= GTMPSC_CHR2_RXABORT; 1897 GT_WRITE(sc->gtmpsc_dev.dv_parent, GTMPSC_U_CHRN(unit, 2), r); 1898 1899 DELAY(GTMPSC_RESET_DELAY); 1900 1901 /* 1902 * abort SDMA RX for MPSC unit 1903 */ 1904 GT_WRITE(sc->gtmpsc_dev.dv_parent, SDMA_U_SDCM(unit), 1905 SDMA_SDCM_AR); 1906 } 1907 } 1908 1909 void 1910 gtmpsc_puts(char *str) 1911 { 1912 char c; 1913 1914 if (str == NULL) 1915 return; 1916 while ((c = *str++) != 0) 1917 gtmpsccnputc(0, c); 1918 } 1919
Indexes created Thu Sep 25 16:09:42 GMT 2025