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