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