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