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