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