1 /* $NetBSD: cy.c,v 1.36 2003/10/31 14:22:48 reinoud Exp $ */ 2 3 /* 4 * cy.c 5 * 6 * Driver for Cyclades Cyclom-8/16/32 multiport serial cards 7 * (currently not tested with Cyclom-32 cards) 8 * 9 * Timo Rossi, 1996 10 * 11 * Supports both ISA and PCI Cyclom cards 12 * 13 * Lots of debug output can be enabled by defining CY_DEBUG 14 * Some debugging counters (number of receive/transmit interrupts etc.) 15 * can be enabled by defining CY_DEBUG1 16 */ 17 18 #include <sys/cdefs.h> 19 __KERNEL_RCSID(0, "$NetBSD: cy.c,v 1.36 2003/10/31 14:22:48 reinoud Exp $"); 20 21 #include <sys/param.h> 22 #include <sys/ioctl.h> 23 #include <sys/syslog.h> 24 #include <sys/fcntl.h> 25 #include <sys/tty.h> 26 #include <sys/proc.h> 27 #include <sys/conf.h> 28 #include <sys/user.h> 29 #include <sys/ioctl.h> 30 #include <sys/select.h> 31 #include <sys/device.h> 32 #include <sys/malloc.h> 33 #include <sys/systm.h> 34 #include <sys/callout.h> 35 36 #include <machine/bus.h> 37 38 #include <dev/ic/cd1400reg.h> 39 #include <dev/ic/cyreg.h> 40 #include <dev/ic/cyvar.h> 41 42 /* Macros to clear/set/test flags. */ 43 #define SET(t, f) (t) |= (f) 44 #define CLR(t, f) (t) &= ~(f) 45 #define ISSET(t, f) ((t) & (f)) 46 47 int cyparam(struct tty *, struct termios *); 48 void cystart(struct tty *); 49 void cy_poll(void *); 50 int cy_modem_control(struct cy_softc *, struct cy_port *, int, int); 51 void cy_enable_transmitter(struct cy_softc *, struct cy_port *); 52 void cd1400_channel_cmd(struct cy_softc *, struct cy_port *, int); 53 int cy_speed(speed_t, int *, int *, int); 54 55 extern struct cfdriver cy_cd; 56 57 dev_type_open(cyopen); 58 dev_type_close(cyclose); 59 dev_type_read(cyread); 60 dev_type_write(cywrite); 61 dev_type_ioctl(cyioctl); 62 dev_type_stop(cystop); 63 dev_type_tty(cytty); 64 dev_type_poll(cypoll); 65 66 const struct cdevsw cy_cdevsw = { 67 cyopen, cyclose, cyread, cywrite, cyioctl, 68 cystop, cytty, cypoll, nommap, ttykqfilter, D_TTY 69 }; 70 71 static int cy_open = 0; 72 static int cy_events = 0; 73 74 int cy_attached_ttys; 75 76 struct callout cy_poll_callout = CALLOUT_INITIALIZER; 77 78 /* 79 * Common probe routine 80 */ 81 int 82 cy_find(struct cy_softc *sc) 83 { 84 int cy_chip, chip; 85 u_char firmware_ver; 86 bus_space_tag_t tag = sc->sc_memt; 87 bus_space_handle_t bsh = sc->sc_bsh; 88 int bustype = sc->sc_bustype; 89 90 /* Cyclom card hardware reset */ 91 bus_space_write_1(tag, bsh, CY16_RESET << bustype, 0); 92 DELAY(500); /* wait for reset to complete */ 93 bus_space_write_1(tag, bsh, CY_CLEAR_INTR << bustype, 0); 94 95 #ifdef CY_DEBUG 96 printf("cy: card reset done\n"); 97 #endif 98 sc->sc_nchips = 0; 99 100 for (cy_chip = 0, chip = 0; cy_chip < CY_MAX_CD1400s; 101 cy_chip++, chip += (CY_CD1400_MEMSPACING << bustype)) { 102 int i; 103 104 /* 105 * the last 4 nchips are 'interleaved' with the first 4 on 106 * 32-port boards 107 */ 108 if (cy_chip == 4) 109 chip -= (CY32_ADDR_FIX << bustype); 110 111 #ifdef CY_DEBUG 112 printf("%s probe chip %d offset 0x%x ... ", 113 sc->sc_dev.dv_xname, cy_chip, chip); 114 #endif 115 116 /* wait until the chip is ready for command */ 117 DELAY(1000); 118 if (bus_space_read_1(tag, bsh, chip + 119 ((CD1400_CCR << 1) << bustype)) != 0) { 120 #ifdef CY_DEBUG 121 printf("not ready for command\n"); 122 #endif 123 break; 124 } 125 /* clear the firmware version reg. */ 126 bus_space_write_1(tag, bsh, chip + 127 ((CD1400_GFRCR << 1) << bustype), 0); 128 129 /* 130 * On Cyclom-16 references to non-existent chip 4 131 * actually access chip 0 (address line 9 not decoded). 132 * Here we check if the clearing of chip 4 GFRCR actually 133 * cleared chip 0 GFRCR. In that case we have a 16 port card. 134 */ 135 if (cy_chip == 4 && 136 bus_space_read_1(tag, bsh, /* off for chip 0 (0) + */ 137 ((CD1400_GFRCR << 1) << bustype)) == 0) 138 break; 139 140 /* reset the chip */ 141 bus_space_write_1(tag, bsh, chip + 142 ((CD1400_CCR << 1) << bustype), 143 CD1400_CCR_CMDRESET | CD1400_CCR_FULLRESET); 144 145 /* wait for the chip to initialize itself */ 146 for (i = 0; i < 200; i++) { 147 DELAY(50); 148 firmware_ver = bus_space_read_1(tag, bsh, chip + 149 ((CD1400_GFRCR << 1) << bustype)); 150 if ((firmware_ver & 0xf0) == 0x40) /* found a CD1400 */ 151 break; 152 } 153 #ifdef CY_DEBUG 154 printf("firmware version 0x%x\n", firmware_ver); 155 #endif 156 157 if ((firmware_ver & 0xf0) != 0x40) 158 break; 159 160 /* firmware version OK, CD1400 found */ 161 sc->sc_nchips++; 162 } 163 164 if (sc->sc_nchips == 0) { 165 #ifdef CY_DEBUG 166 printf("no CD1400s found\n"); 167 #endif 168 return 0; 169 } 170 #ifdef CY_DEBUG 171 printf("found %d CD1400s\n", sc->sc_nchips); 172 #endif 173 174 return 1; 175 } 176 177 void 178 cy_attach(struct cy_softc *sc) 179 { 180 int port, cy_chip, num_chips, cdu, chip; 181 int cy_clock; 182 183 num_chips = sc->sc_nchips; 184 if (num_chips == 0) 185 return; 186 187 memset(sc->sc_ports, 0, sizeof(sc->sc_ports)); 188 189 port = 0; 190 for (cy_chip = 0, chip = 0; cy_chip < num_chips; cy_chip++, 191 chip += (CY_CD1400_MEMSPACING << sc->sc_bustype)) { 192 193 if (cy_chip == 4) 194 chip -= (CY32_ADDR_FIX << sc->sc_bustype); 195 196 #ifdef CY_DEBUG 197 aprint_debug("attach CD1400 #%d offset 0x%x\n", cy_chip, chip); 198 #endif 199 sc->sc_cd1400_offs[cy_chip] = chip; 200 201 /* 202 * configure port 0 as serial port (should already be after 203 * reset) 204 */ 205 cd_write_reg(sc, cy_chip, CD1400_GCR, 0); 206 207 if (cd_read_reg(sc, cy_chip, CD1400_GFRCR) <= 0x46) 208 cy_clock = CY_CLOCK; 209 else 210 cy_clock = CY_CLOCK_60; 211 212 /* set up a receive timeout period (1ms) */ 213 cd_write_reg(sc, cy_chip, CD1400_PPR, 214 (cy_clock / CD1400_PPR_PRESCALER / 1000) + 1); 215 216 for (cdu = 0; cdu < CD1400_NO_OF_CHANNELS; cdu++) { 217 sc->sc_ports[port].cy_softc = sc; 218 sc->sc_ports[port].cy_port_num = port; 219 sc->sc_ports[port].cy_chip = cy_chip; 220 sc->sc_ports[port].cy_clock = cy_clock; 221 222 /* should we initialize anything else here? */ 223 port++; 224 } /* for(each port on one CD1400...) */ 225 226 } /* for(each CD1400 on a card... ) */ 227 228 sc->sc_nchannels = port; 229 230 aprint_normal("%s: %d channels (ttyCY%03d..ttyCY%03d)\n", 231 sc->sc_dev.dv_xname, sc->sc_nchannels, cy_attached_ttys, 232 cy_attached_ttys + (sc->sc_nchannels - 1)); 233 234 cy_attached_ttys += sc->sc_nchannels; 235 236 /* ensure an edge for the next interrupt */ 237 bus_space_write_1(sc->sc_memt, sc->sc_bsh, 238 CY_CLEAR_INTR << sc->sc_bustype, 0); 239 } 240 241 #define CYDIALOUT_MASK 0x80000 242 #define CY_DIALOUT(dev) (minor(dev) & CYDIALOUT_MASK) 243 244 #define CY_PORT(dev) cy_getport((dev)) 245 #define CY_BOARD(cy) ((cy)->cy_softc) 246 247 static struct cy_port * 248 cy_getport(dev_t dev) 249 { 250 int i, j, k, u = minor(dev) & ~CYDIALOUT_MASK; 251 struct cy_softc *sc; 252 253 for (i = 0, j = 0; i < cy_cd.cd_ndevs; i++) { 254 k = j; 255 sc = device_lookup(&cy_cd, i); 256 if (sc == NULL) 257 continue; 258 if (sc->sc_nchannels == 0) 259 continue; 260 j += sc->sc_nchannels; 261 if (j > u) 262 return (&sc->sc_ports[u - k]); 263 } 264 265 return (NULL); 266 } 267 268 /* 269 * open routine. returns zero if successful, else error code 270 */ 271 int 272 cyopen(dev_t dev, int flag, int mode, struct proc *p) 273 { 274 struct cy_softc *sc; 275 struct cy_port *cy; 276 struct tty *tp; 277 int s, error; 278 279 cy = CY_PORT(dev); 280 if (cy == NULL) 281 return (ENXIO); 282 sc = CY_BOARD(cy); 283 284 s = spltty(); 285 if (cy->cy_tty == NULL) { 286 if ((cy->cy_tty = ttymalloc()) == NULL) { 287 splx(s); 288 printf("%s: port %d: can't allocate tty\n", 289 sc->sc_dev.dv_xname, cy->cy_port_num); 290 return (ENOMEM); 291 } 292 tty_attach(cy->cy_tty); 293 } 294 splx(s); 295 296 tp = cy->cy_tty; 297 tp->t_oproc = cystart; 298 tp->t_param = cyparam; 299 tp->t_dev = dev; 300 301 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 302 ttychars(tp); 303 tp->t_iflag = TTYDEF_IFLAG; 304 tp->t_oflag = TTYDEF_OFLAG; 305 tp->t_cflag = TTYDEF_CFLAG; 306 if (ISSET(cy->cy_openflags, TIOCFLAG_CLOCAL)) 307 SET(tp->t_cflag, CLOCAL); 308 if (ISSET(cy->cy_openflags, TIOCFLAG_CRTSCTS)) 309 SET(tp->t_cflag, CRTSCTS); 310 if (ISSET(cy->cy_openflags, TIOCFLAG_MDMBUF)) 311 SET(tp->t_cflag, MDMBUF); 312 tp->t_lflag = TTYDEF_LFLAG; 313 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; 314 315 s = spltty(); 316 317 /* 318 * Allocate input ring buffer if we don't already have one 319 */ 320 if (cy->cy_ibuf == NULL) { 321 cy->cy_ibuf = malloc(CY_IBUF_SIZE, M_DEVBUF, M_NOWAIT); 322 if (cy->cy_ibuf == NULL) { 323 printf("%s: port %d: can't allocate input buffer\n", 324 sc->sc_dev.dv_xname, cy->cy_port_num); 325 splx(s); 326 return ENOMEM; 327 } 328 cy->cy_ibuf_end = cy->cy_ibuf + CY_IBUF_SIZE; 329 } 330 /* mark the ring buffer as empty */ 331 cy->cy_ibuf_rd_ptr = cy->cy_ibuf_wr_ptr = cy->cy_ibuf; 332 333 /* select CD1400 channel */ 334 cd_write_reg(sc, cy->cy_chip, CD1400_CAR, 335 cy->cy_port_num & CD1400_CAR_CHAN); 336 /* reset the channel */ 337 cd1400_channel_cmd(sc, cy, CD1400_CCR_CMDRESET); 338 /* encode unit (port) number in LIVR */ 339 /* there is just enough space for 5 bits (32 ports) */ 340 cd_write_reg(sc, cy->cy_chip, CD1400_LIVR, 341 cy->cy_port_num << 3); 342 343 cy->cy_channel_control = 0; 344 345 /* hmm... need spltty() here? */ 346 if (cy_open == 0) { 347 cy_open = 1; 348 callout_reset(&cy_poll_callout, 1, cy_poll, NULL); 349 } 350 /* this sets parameters and raises DTR */ 351 cyparam(tp, &tp->t_termios); 352 353 ttsetwater(tp); 354 355 /* raise RTS too */ 356 cy_modem_control(sc, cy, TIOCM_RTS, DMBIS); 357 358 cy->cy_carrier_stat = 359 cd_read_reg(sc, cy->cy_chip, CD1400_MSVR2); 360 361 /* enable receiver and modem change interrupts */ 362 cd_write_reg(sc, cy->cy_chip, CD1400_SRER, 363 CD1400_SRER_MDMCH | CD1400_SRER_RXDATA); 364 365 if (CY_DIALOUT(dev) || 366 ISSET(cy->cy_openflags, TIOCFLAG_SOFTCAR) || 367 ISSET(tp->t_cflag, MDMBUF) || 368 ISSET(cy->cy_carrier_stat, CD1400_MSVR2_CD)) 369 SET(tp->t_state, TS_CARR_ON); 370 else 371 CLR(tp->t_state, TS_CARR_ON); 372 } else if (ISSET(tp->t_state, TS_XCLUDE) && p->p_ucred->cr_uid != 0) { 373 return EBUSY; 374 } else { 375 s = spltty(); 376 } 377 378 /* wait for carrier if necessary */ 379 if (!ISSET(flag, O_NONBLOCK)) { 380 while (!ISSET(tp->t_cflag, CLOCAL) && 381 !ISSET(tp->t_state, TS_CARR_ON)) { 382 tp->t_wopen++; 383 error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH, 384 "cydcd", 0); 385 tp->t_wopen--; 386 if (error != 0) { 387 splx(s); 388 return error; 389 } 390 } 391 } 392 splx(s); 393 394 return (*tp->t_linesw->l_open) (dev, tp); 395 } 396 397 /* 398 * close routine. returns zero if successful, else error code 399 */ 400 int 401 cyclose(dev_t dev, int flag, int mode, struct proc *p) 402 { 403 struct cy_softc *sc; 404 struct cy_port *cy; 405 struct tty *tp; 406 int s; 407 408 cy = CY_PORT(dev); 409 sc = CY_BOARD(cy); 410 tp = cy->cy_tty; 411 412 (*tp->t_linesw->l_close) (tp, flag); 413 s = spltty(); 414 415 if (ISSET(tp->t_cflag, HUPCL) && 416 !ISSET(cy->cy_openflags, TIOCFLAG_SOFTCAR)) { 417 /* 418 * drop DTR and RTS (should we wait for output buffer to 419 * become empty first?) 420 */ 421 cy_modem_control(sc, cy, 0, DMSET); 422 } 423 /* 424 * XXX should we disable modem change and 425 * receive interrupts here or somewhere ? 426 */ 427 CLR(tp->t_state, TS_BUSY | TS_FLUSH); 428 429 splx(s); 430 ttyclose(tp); 431 432 return 0; 433 } 434 435 /* 436 * Read routine 437 */ 438 int 439 cyread(dev_t dev, struct uio *uio, int flag) 440 { 441 struct cy_port *cy; 442 struct tty *tp; 443 444 cy = CY_PORT(dev); 445 tp = cy->cy_tty; 446 447 return ((*tp->t_linesw->l_read)(tp, uio, flag)); 448 } 449 450 /* 451 * Write routine 452 */ 453 int 454 cywrite(dev_t dev, struct uio *uio, int flag) 455 { 456 struct cy_port *cy; 457 struct tty *tp; 458 459 cy = CY_PORT(dev); 460 tp = cy->cy_tty; 461 462 return ((*tp->t_linesw->l_write)(tp, uio, flag)); 463 } 464 465 /* 466 * Poll routine 467 */ 468 int 469 cypoll(dev, events, p) 470 dev_t dev; 471 int events; 472 struct proc *p; 473 { 474 struct cy_port *cy; 475 struct tty *tp; 476 477 cy = CY_PORT(dev); 478 tp = cy->cy_tty; 479 480 return ((*tp->t_linesw->l_poll)(tp, events, p)); 481 } 482 483 /* 484 * return tty pointer 485 */ 486 struct tty * 487 cytty(dev_t dev) 488 { 489 struct cy_port *cy; 490 491 cy = CY_PORT(dev); 492 493 return (cy->cy_tty); 494 } 495 496 /* 497 * ioctl routine 498 */ 499 int 500 cyioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) 501 { 502 struct cy_softc *sc; 503 struct cy_port *cy; 504 struct tty *tp; 505 int error; 506 507 cy = CY_PORT(dev); 508 sc = CY_BOARD(cy); 509 tp = cy->cy_tty; 510 511 error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, p); 512 if (error != EPASSTHROUGH) 513 return error; 514 515 error = ttioctl(tp, cmd, data, flag, p); 516 if (error != EPASSTHROUGH) 517 return error; 518 519 /* XXX should not allow dropping DTR when dialin? */ 520 521 switch (cmd) { 522 case TIOCSBRK: /* start break */ 523 SET(cy->cy_flags, CY_F_START_BREAK); 524 cy_enable_transmitter(sc, cy); 525 break; 526 527 case TIOCCBRK: /* stop break */ 528 SET(cy->cy_flags, CY_F_END_BREAK); 529 cy_enable_transmitter(sc, cy); 530 break; 531 532 case TIOCSDTR: /* DTR on */ 533 cy_modem_control(sc, cy, TIOCM_DTR, DMBIS); 534 break; 535 536 case TIOCCDTR: /* DTR off */ 537 cy_modem_control(sc, cy, TIOCM_DTR, DMBIC); 538 break; 539 540 case TIOCMSET: /* set new modem control line values */ 541 cy_modem_control(sc, cy, *((int *) data), DMSET); 542 break; 543 544 case TIOCMBIS: /* turn modem control bits on */ 545 cy_modem_control(sc, cy, *((int *) data), DMBIS); 546 break; 547 548 case TIOCMBIC: /* turn modem control bits off */ 549 cy_modem_control(sc, cy, *((int *) data), DMBIC); 550 break; 551 552 case TIOCMGET: /* get modem control/status line state */ 553 *((int *) data) = cy_modem_control(sc, cy, 0, DMGET); 554 break; 555 556 case TIOCGFLAGS: 557 *((int *) data) = cy->cy_openflags | 558 (CY_DIALOUT(dev) ? TIOCFLAG_SOFTCAR : 0); 559 break; 560 561 case TIOCSFLAGS: 562 error = suser(p->p_ucred, &p->p_acflag); 563 if (error != 0) 564 return EPERM; 565 566 cy->cy_openflags = *((int *) data) & 567 (TIOCFLAG_SOFTCAR | TIOCFLAG_CLOCAL | 568 TIOCFLAG_CRTSCTS | TIOCFLAG_MDMBUF); 569 break; 570 571 default: 572 return EPASSTHROUGH; 573 } 574 575 return 0; 576 } 577 578 /* 579 * start output 580 */ 581 void 582 cystart(struct tty *tp) 583 { 584 struct cy_softc *sc; 585 struct cy_port *cy; 586 int s; 587 588 cy = CY_PORT(tp->t_dev); 589 sc = cy->cy_softc; 590 591 s = spltty(); 592 593 #ifdef CY_DEBUG1 594 cy->cy_start_count++; 595 #endif 596 597 if (!ISSET(tp->t_state, TS_TTSTOP | TS_TIMEOUT | TS_BUSY)) { 598 if (tp->t_outq.c_cc <= tp->t_lowat) { 599 if (ISSET(tp->t_state, TS_ASLEEP)) { 600 CLR(tp->t_state, TS_ASLEEP); 601 wakeup(&tp->t_outq); 602 } 603 selwakeup(&tp->t_wsel); 604 605 if (tp->t_outq.c_cc == 0) 606 goto out; 607 } 608 SET(tp->t_state, TS_BUSY); 609 cy_enable_transmitter(sc, cy); 610 } 611 out: 612 613 splx(s); 614 } 615 616 /* 617 * stop output 618 */ 619 void 620 cystop(struct tty *tp, int flag) 621 { 622 struct cy_port *cy; 623 int s; 624 625 cy = CY_PORT(tp->t_dev); 626 627 s = spltty(); 628 if (ISSET(tp->t_state, TS_BUSY)) { 629 if (!ISSET(tp->t_state, TS_TTSTOP)) 630 SET(tp->t_state, TS_FLUSH); 631 632 /* 633 * the transmit interrupt routine will disable transmit when it 634 * notices that CY_F_STOP has been set. 635 */ 636 SET(cy->cy_flags, CY_F_STOP); 637 } 638 splx(s); 639 } 640 641 /* 642 * parameter setting routine. 643 * returns 0 if successful, else returns error code 644 */ 645 int 646 cyparam(struct tty *tp, struct termios *t) 647 { 648 struct cy_softc *sc; 649 struct cy_port *cy; 650 int ibpr, obpr, i_clk_opt, o_clk_opt, s, opt; 651 652 cy = CY_PORT(tp->t_dev); 653 sc = CY_BOARD(cy); 654 655 if (t->c_ospeed != 0 && cy_speed(t->c_ospeed, &o_clk_opt, &obpr, cy->cy_clock) < 0) 656 return EINVAL; 657 658 if (t->c_ispeed != 0 && cy_speed(t->c_ispeed, &i_clk_opt, &ibpr, cy->cy_clock) < 0) 659 return EINVAL; 660 661 s = spltty(); 662 663 /* hang up the line is ospeed is zero, else turn DTR on */ 664 cy_modem_control(sc, cy, TIOCM_DTR, (t->c_ospeed == 0 ? DMBIC : DMBIS)); 665 666 /* channel was selected by the above call to cy_modem_control() */ 667 #if 0 668 cd_write_reg(sc, cy->cy_chip, CD1400_CAR, port & CD1400_CAR_CHAN); 669 #endif 670 671 /* set transmit speed */ 672 if (t->c_ospeed != 0) { 673 cd_write_reg(sc, cy->cy_chip, CD1400_TCOR, o_clk_opt); 674 cd_write_reg(sc, cy->cy_chip, CD1400_TBPR, obpr); 675 } 676 /* set receive speed */ 677 if (t->c_ispeed != 0) { 678 cd_write_reg(sc, cy->cy_chip, CD1400_RCOR, i_clk_opt); 679 cd_write_reg(sc, cy->cy_chip, CD1400_RBPR, ibpr); 680 } 681 opt = CD1400_CCR_CMDCHANCTL | CD1400_CCR_XMTEN 682 | (ISSET(t->c_cflag, CREAD) ? CD1400_CCR_RCVEN : CD1400_CCR_RCVDIS); 683 684 if (opt != cy->cy_channel_control) { 685 cy->cy_channel_control = opt; 686 cd1400_channel_cmd(sc, cy, opt); 687 } 688 /* compute COR1 contents */ 689 opt = 0; 690 if (ISSET(t->c_cflag, PARENB)) { 691 if (ISSET(t->c_cflag, PARODD)) 692 opt |= CD1400_COR1_PARODD; 693 opt |= CD1400_COR1_PARNORMAL; 694 } 695 if (!ISSET(t->c_iflag, INPCK)) 696 opt |= CD1400_COR1_NOINPCK; /* no parity checking */ 697 698 if (ISSET(t->c_cflag, CSTOPB)) 699 opt |= CD1400_COR1_STOP2; 700 701 switch (t->c_cflag & CSIZE) { 702 case CS5: 703 opt |= CD1400_COR1_CS5; 704 break; 705 706 case CS6: 707 opt |= CD1400_COR1_CS6; 708 break; 709 710 case CS7: 711 opt |= CD1400_COR1_CS7; 712 break; 713 714 default: 715 opt |= CD1400_COR1_CS8; 716 break; 717 } 718 719 cd_write_reg(sc, cy->cy_chip, CD1400_COR1, opt); 720 721 #ifdef CY_DEBUG 722 printf("cor1 = 0x%x...", opt); 723 #endif 724 725 /* 726 * use the CD1400 automatic CTS flow control if CRTSCTS is set 727 * 728 * CD1400_COR2_ETC is used because breaks are generated with 729 * embedded transmit commands 730 */ 731 cd_write_reg(sc, cy->cy_chip, CD1400_COR2, 732 CD1400_COR2_ETC | 733 (ISSET(t->c_cflag, CRTSCTS) ? CD1400_COR2_CCTS_OFLOW : 0)); 734 735 cd_write_reg(sc, cy->cy_chip, CD1400_COR3, CY_RX_FIFO_THRESHOLD); 736 737 cd1400_channel_cmd(sc, cy, CD1400_CCR_CMDCORCHG | 738 CD1400_CCR_COR1 | CD1400_CCR_COR2 | CD1400_CCR_COR3); 739 740 cd_write_reg(sc, cy->cy_chip, CD1400_COR4, CD1400_COR4_PFO_EXCEPTION); 741 cd_write_reg(sc, cy->cy_chip, CD1400_COR5, 0); 742 743 /* 744 * set modem change option registers to generate interrupts 745 * on carrier detect changes. 746 * 747 * if hardware RTS handshaking is used 748 * also set the handshaking threshold. 749 */ 750 if (cy->cy_clock == CY_CLOCK_60) { 751 cd_write_reg(sc, cy->cy_chip, CD1400_MCOR1, CD1400_MCOR1_CDzd | 752 (ISSET(t->c_cflag, CRTSCTS) ? CY_RX_DTR_THRESHOLD : 0)); 753 } else { 754 cd_write_reg(sc, cy->cy_chip, CD1400_MCOR1, CD1400_MCOR1_CDzd); 755 } 756 757 cd_write_reg(sc, cy->cy_chip, CD1400_MCOR2, CD1400_MCOR2_CDod); 758 759 /* 760 * set receive timeout to approx. 2ms 761 * could use more complex logic here... 762 * (but is it actually needed or even useful?) 763 */ 764 cd_write_reg(sc, cy->cy_chip, CD1400_RTPR, 2); 765 766 /* 767 * should do anything else here? 768 * XXX check MDMBUF handshaking like in com.c? 769 */ 770 771 splx(s); 772 return 0; 773 } 774 775 /* 776 * set/get modem line status 777 * 778 * bits can be: TIOCM_DTR, TIOCM_RTS, TIOCM_CTS, TIOCM_CD, TIOCM_RI, TIOCM_DSR 779 */ 780 int 781 cy_modem_control(struct cy_softc *sc, struct cy_port *cy, int bits, int howto) 782 { 783 struct tty *tp = cy->cy_tty; 784 int s, msvr; 785 786 s = spltty(); 787 788 /* select channel */ 789 cd_write_reg(sc, cy->cy_chip, CD1400_CAR, 790 cy->cy_port_num & CD1400_CAR_CHAN); 791 792 /* Does not manipulate RTS if it is used for flow control. */ 793 switch (howto) { 794 case DMGET: 795 bits = 0; 796 if (cy->cy_channel_control & CD1400_CCR_RCVEN) 797 bits |= TIOCM_LE; 798 msvr = cd_read_reg(sc, cy->cy_chip, CD1400_MSVR2); 799 if (cy->cy_clock == CY_CLOCK_60) { 800 if (cd_read_reg(sc, cy->cy_chip, CD1400_MSVR1) & 801 CD1400_MSVR1_RTS) 802 bits |= TIOCM_DTR; 803 if (msvr & CD1400_MSVR2_DTR) 804 bits |= TIOCM_RTS; 805 } else { 806 if (cd_read_reg(sc, cy->cy_chip, CD1400_MSVR1) & 807 CD1400_MSVR1_RTS) 808 bits |= TIOCM_RTS; 809 if (msvr & CD1400_MSVR2_DTR) 810 bits |= TIOCM_DTR; 811 } 812 if (msvr & CD1400_MSVR2_CTS) 813 bits |= TIOCM_CTS; 814 if (msvr & CD1400_MSVR2_CD) 815 bits |= TIOCM_CD; 816 /* Not connected on some Cyclom-Y boards? */ 817 if (msvr & CD1400_MSVR2_DSR) 818 bits |= TIOCM_DSR; 819 /* Not connected on some Cyclom-8Y boards? */ 820 if (msvr & CD1400_MSVR2_RI) 821 bits |= TIOCM_RI; 822 break; 823 824 case DMSET: /* replace old values with new ones */ 825 if (cy->cy_clock == CY_CLOCK_60) { 826 if (!ISSET(tp->t_cflag, CRTSCTS)) 827 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR2, 828 ((bits & TIOCM_RTS) ? CD1400_MSVR2_DTR : 0)); 829 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR1, 830 ((bits & TIOCM_DTR) ? CD1400_MSVR1_RTS : 0)); 831 } else { 832 if (!ISSET(tp->t_cflag, CRTSCTS)) 833 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR1, 834 ((bits & TIOCM_RTS) ? CD1400_MSVR1_RTS : 0)); 835 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR2, 836 ((bits & TIOCM_DTR) ? CD1400_MSVR2_DTR : 0)); 837 } 838 break; 839 840 case DMBIS: /* set bits */ 841 if (cy->cy_clock == CY_CLOCK_60) { 842 if (!ISSET(tp->t_cflag, CRTSCTS) && 843 (bits & TIOCM_RTS) != 0) 844 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR2, 845 CD1400_MSVR2_DTR); 846 if (bits & TIOCM_DTR) 847 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR1, 848 CD1400_MSVR1_RTS); 849 } else { 850 if (!ISSET(tp->t_cflag, CRTSCTS) && 851 (bits & TIOCM_RTS) != 0) 852 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR1, 853 CD1400_MSVR1_RTS); 854 if (bits & TIOCM_DTR) 855 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR2, 856 CD1400_MSVR2_DTR); 857 } 858 break; 859 860 case DMBIC: /* clear bits */ 861 if (cy->cy_clock == CY_CLOCK_60) { 862 if (!ISSET(tp->t_cflag, CRTSCTS) && (bits & TIOCM_RTS)) 863 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR2, 0); 864 if (bits & TIOCM_DTR) 865 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR1, 0); 866 } else { 867 if (!ISSET(tp->t_cflag, CRTSCTS) && (bits & TIOCM_RTS)) 868 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR1, 0); 869 if (bits & TIOCM_DTR) 870 cd_write_reg(sc, cy->cy_chip, CD1400_MSVR2, 0); 871 } 872 break; 873 } 874 splx(s); 875 return ((howto == DMGET) ? bits : 0); 876 } 877 878 /* 879 * Upper-level handler loop (called from timer interrupt?) 880 * This routine is common for multiple cards 881 */ 882 void 883 cy_poll(void *arg) 884 { 885 int card, port; 886 struct cy_softc *sc; 887 struct cy_port *cy; 888 struct tty *tp; 889 static int counter = 0; 890 #ifdef CY_DEBUG1 891 int did_something; 892 #endif 893 int s = spltty(); 894 895 if (cy_events == 0 && ++counter < 200) { 896 splx(s); 897 goto out; 898 } 899 cy_events = 0; 900 splx(s); 901 902 for (card = 0; card < cy_cd.cd_ndevs; card++) { 903 sc = device_lookup(&cy_cd, card); 904 if (sc == NULL) 905 continue; 906 907 #ifdef CY_DEBUG1 908 sc->sc_poll_count1++; 909 did_something = 0; 910 #endif 911 912 for (port = 0; port < sc->sc_nchannels; port++) { 913 cy = &sc->sc_ports[port]; 914 if ((tp = cy->cy_tty) == NULL || cy->cy_ibuf == NULL || 915 (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0)) 916 continue; 917 918 /* 919 * handle received data 920 */ 921 while (cy->cy_ibuf_rd_ptr != cy->cy_ibuf_wr_ptr) { 922 u_char line_stat; 923 int chr; 924 925 line_stat = cy->cy_ibuf_rd_ptr[0]; 926 chr = cy->cy_ibuf_rd_ptr[1]; 927 928 if (line_stat & 929 (CD1400_RDSR_BREAK | CD1400_RDSR_FE)) 930 chr |= TTY_FE; 931 if (line_stat & CD1400_RDSR_PE) 932 chr |= TTY_PE; 933 934 /* 935 * on an overrun error the data is treated as 936 * good just as it should be. 937 */ 938 939 #ifdef CY_DEBUG 940 printf("%s: port %d ttyinput 0x%x\n", 941 sc->sc_dev.dv_xname, port, chr); 942 #endif 943 944 (*tp->t_linesw->l_rint) (chr, tp); 945 946 s = spltty(); /* really necessary? */ 947 if ((cy->cy_ibuf_rd_ptr += 2) == 948 cy->cy_ibuf_end) 949 cy->cy_ibuf_rd_ptr = cy->cy_ibuf; 950 splx(s); 951 952 #ifdef CY_DEBUG1 953 did_something = 1; 954 #endif 955 } 956 957 /* 958 * If we don't have any received data in ibuf and 959 * CRTSCTS is on and RTS is turned off, it is time to 960 * turn RTS back on 961 */ 962 if (ISSET(tp->t_cflag, CRTSCTS)) { 963 /* 964 * we can't use cy_modem_control() here as it 965 * doesn't change RTS if RTSCTS is on 966 */ 967 cd_write_reg(sc, cy->cy_chip, CD1400_CAR, 968 port & CD1400_CAR_CHAN); 969 970 if (cy->cy_clock == CY_CLOCK_60) { 971 if ((cd_read_reg(sc, cy->cy_chip, 972 CD1400_MSVR2) & CD1400_MSVR2_DTR) == 0) { 973 cd_write_reg(sc, cy->cy_chip, 974 CD1400_MSVR2,CD1400_MSVR2_DTR); 975 #ifdef CY_DEBUG1 976 did_something = 1; 977 #endif 978 } 979 } else { 980 if ((cd_read_reg(sc, cy->cy_chip, 981 CD1400_MSVR1) & CD1400_MSVR1_RTS) == 0) { 982 cd_write_reg(sc, cy->cy_chip, 983 CD1400_MSVR1,CD1400_MSVR1_RTS); 984 #ifdef CY_DEBUG1 985 did_something = 1; 986 #endif 987 } 988 } 989 } 990 991 /* 992 * handle carrier changes 993 */ 994 s = spltty(); 995 if (ISSET(cy->cy_flags, CY_F_CARRIER_CHANGED)) { 996 int carrier; 997 998 CLR(cy->cy_flags, CY_F_CARRIER_CHANGED); 999 splx(s); 1000 1001 carrier = ((cy->cy_carrier_stat & 1002 CD1400_MSVR2_CD) != 0); 1003 1004 #ifdef CY_DEBUG 1005 printf("cy_poll: carrier change " 1006 "(card %d, port %d, carrier %d)\n", 1007 card, port, carrier); 1008 #endif 1009 if (CY_DIALOUT(tp->t_dev) == 0 && 1010 !(*tp->t_linesw->l_modem)(tp, carrier)) 1011 cy_modem_control(sc, cy, 1012 TIOCM_DTR, DMBIC); 1013 1014 #ifdef CY_DEBUG1 1015 did_something = 1; 1016 #endif 1017 } else 1018 splx(s); 1019 1020 s = spltty(); 1021 if (ISSET(cy->cy_flags, CY_F_START)) { 1022 CLR(cy->cy_flags, CY_F_START); 1023 splx(s); 1024 1025 (*tp->t_linesw->l_start) (tp); 1026 1027 #ifdef CY_DEBUG1 1028 did_something = 1; 1029 #endif 1030 } else 1031 splx(s); 1032 1033 /* could move this to even upper level... */ 1034 if (cy->cy_fifo_overruns) { 1035 cy->cy_fifo_overruns = 0; 1036 /* 1037 * doesn't report overrun count, but 1038 * shouldn't really matter 1039 */ 1040 log(LOG_WARNING, "%s: port %d fifo overrun\n", 1041 sc->sc_dev.dv_xname, port); 1042 } 1043 if (cy->cy_ibuf_overruns) { 1044 cy->cy_ibuf_overruns = 0; 1045 log(LOG_WARNING, "%s: port %d ibuf overrun\n", 1046 sc->sc_dev.dv_xname, port); 1047 } 1048 } /* for(port...) */ 1049 #ifdef CY_DEBUG1 1050 if (did_something && counter >= 200) 1051 sc->sc_poll_count2++; 1052 #endif 1053 } /* for(card...) */ 1054 1055 counter = 0; 1056 1057 out: 1058 callout_reset(&cy_poll_callout, 1, cy_poll, NULL); 1059 } 1060 1061 /* 1062 * hardware interrupt routine 1063 */ 1064 int 1065 cy_intr(void *arg) 1066 { 1067 struct cy_softc *sc = arg; 1068 struct cy_port *cy; 1069 int cy_chip, stat; 1070 int int_serviced = 0; 1071 1072 /* 1073 * Check interrupt status of each CD1400 chip on this card 1074 * (multiple cards cannot share the same interrupt) 1075 */ 1076 for (cy_chip = 0; cy_chip < sc->sc_nchips; cy_chip++) { 1077 1078 stat = cd_read_reg(sc, cy_chip, CD1400_SVRR); 1079 if (stat == 0) 1080 continue; 1081 1082 if (ISSET(stat, CD1400_SVRR_RXRDY)) { 1083 u_char save_car, save_rir, serv_type; 1084 u_char line_stat, recv_data, n_chars; 1085 u_char *buf_p; 1086 1087 save_rir = cd_read_reg(sc, cy_chip, CD1400_RIR); 1088 save_car = cd_read_reg(sc, cy_chip, CD1400_CAR); 1089 /* enter rx service */ 1090 cd_write_reg(sc, cy_chip, CD1400_CAR, save_rir); 1091 1092 serv_type = cd_read_reg(sc, cy_chip, CD1400_RIVR); 1093 cy = &sc->sc_ports[serv_type >> 3]; 1094 1095 #ifdef CY_DEBUG1 1096 cy->cy_rx_int_count++; 1097 #endif 1098 1099 buf_p = cy->cy_ibuf_wr_ptr; 1100 1101 if (ISSET(serv_type, CD1400_RIVR_EXCEPTION)) { 1102 line_stat = cd_read_reg(sc, cy->cy_chip, 1103 CD1400_RDSR); 1104 recv_data = cd_read_reg(sc, cy->cy_chip, 1105 CD1400_RDSR); 1106 1107 if (cy->cy_tty == NULL || 1108 !ISSET(cy->cy_tty->t_state, TS_ISOPEN)) 1109 goto end_rx_serv; 1110 1111 #ifdef CY_DEBUG 1112 printf("%s port %d recv exception, line_stat 0x%x, char 0x%x\n", 1113 sc->sc_dev.dv_xname, cy->cy_port_num, line_stat, recv_data); 1114 #endif 1115 if (ISSET(line_stat, CD1400_RDSR_OE)) 1116 cy->cy_fifo_overruns++; 1117 1118 *buf_p++ = line_stat; 1119 *buf_p++ = recv_data; 1120 if (buf_p == cy->cy_ibuf_end) 1121 buf_p = cy->cy_ibuf; 1122 1123 if (buf_p == cy->cy_ibuf_rd_ptr) { 1124 if (buf_p == cy->cy_ibuf) 1125 buf_p = cy->cy_ibuf_end; 1126 buf_p -= 2; 1127 cy->cy_ibuf_overruns++; 1128 } 1129 cy_events = 1; 1130 } else {/* no exception, received data OK */ 1131 n_chars = cd_read_reg(sc, cy->cy_chip, 1132 CD1400_RDCR); 1133 1134 /* If no tty or not open, discard data */ 1135 if (cy->cy_tty == NULL || 1136 !ISSET(cy->cy_tty->t_state, TS_ISOPEN)) { 1137 while (n_chars--) 1138 cd_read_reg(sc, cy->cy_chip, 1139 CD1400_RDSR); 1140 goto end_rx_serv; 1141 } 1142 1143 #ifdef CY_DEBUG 1144 printf("%s port %d receive ok %d chars\n", 1145 sc->sc_dev.dv_xname, cy->cy_port_num, n_chars); 1146 #endif 1147 while (n_chars--) { 1148 *buf_p++ = 0; /* status: OK */ 1149 /* data byte */ 1150 *buf_p++ = cd_read_reg(sc, 1151 cy->cy_chip, CD1400_RDSR); 1152 if (buf_p == cy->cy_ibuf_end) 1153 buf_p = cy->cy_ibuf; 1154 if (buf_p == cy->cy_ibuf_rd_ptr) { 1155 if (buf_p == cy->cy_ibuf) 1156 buf_p = cy->cy_ibuf_end; 1157 buf_p -= 2; 1158 cy->cy_ibuf_overruns++; 1159 break; 1160 } 1161 } 1162 cy_events = 1; 1163 } 1164 1165 cy->cy_ibuf_wr_ptr = buf_p; 1166 1167 /* RTS handshaking for incoming data */ 1168 if (ISSET(cy->cy_tty->t_cflag, CRTSCTS)) { 1169 int bf, msvr; 1170 1171 bf = buf_p - cy->cy_ibuf_rd_ptr; 1172 if (bf < 0) 1173 bf += CY_IBUF_SIZE; 1174 1175 if (bf > (CY_IBUF_SIZE / 2)) { 1176 /* turn RTS off */ 1177 if (cy->cy_clock == CY_CLOCK_60) 1178 msvr = CD1400_MSVR2; 1179 else 1180 msvr = CD1400_MSVR1; 1181 cd_write_reg(sc, cy->cy_chip, msvr, 0); 1182 } 1183 } 1184 1185 end_rx_serv: 1186 /* terminate service context */ 1187 cd_write_reg(sc, cy->cy_chip, CD1400_RIR, 1188 save_rir & 0x3f); 1189 cd_write_reg(sc, cy->cy_chip, CD1400_CAR, save_car); 1190 int_serviced = 1; 1191 } /* if (rx_service...) */ 1192 if (ISSET(stat, CD1400_SVRR_MDMCH)) { 1193 u_char save_car, save_mir, serv_type, modem_stat; 1194 1195 save_mir = cd_read_reg(sc, cy_chip, CD1400_MIR); 1196 save_car = cd_read_reg(sc, cy_chip, CD1400_CAR); 1197 /* enter modem service */ 1198 cd_write_reg(sc, cy_chip, CD1400_CAR, save_mir); 1199 1200 serv_type = cd_read_reg(sc, cy_chip, CD1400_MIVR); 1201 cy = &sc->sc_ports[serv_type >> 3]; 1202 1203 #ifdef CY_DEBUG1 1204 cy->cy_modem_int_count++; 1205 #endif 1206 1207 modem_stat = cd_read_reg(sc, cy->cy_chip, CD1400_MSVR2); 1208 1209 #ifdef CY_DEBUG 1210 printf("%s port %d modem line change, new stat 0x%x\n", 1211 sc->sc_dev.dv_xname, cy->cy_port_num, modem_stat); 1212 #endif 1213 if (ISSET((cy->cy_carrier_stat ^ modem_stat), CD1400_MSVR2_CD)) { 1214 SET(cy->cy_flags, CY_F_CARRIER_CHANGED); 1215 cy_events = 1; 1216 } 1217 cy->cy_carrier_stat = modem_stat; 1218 1219 /* terminate service context */ 1220 cd_write_reg(sc, cy->cy_chip, CD1400_MIR, save_mir & 0x3f); 1221 cd_write_reg(sc, cy->cy_chip, CD1400_CAR, save_car); 1222 int_serviced = 1; 1223 } /* if (modem_service...) */ 1224 if (ISSET(stat, CD1400_SVRR_TXRDY)) { 1225 u_char save_car, save_tir, serv_type, 1226 count, ch; 1227 struct tty *tp; 1228 1229 save_tir = cd_read_reg(sc, cy_chip, CD1400_TIR); 1230 save_car = cd_read_reg(sc, cy_chip, CD1400_CAR); 1231 /* enter tx service */ 1232 cd_write_reg(sc, cy_chip, CD1400_CAR, save_tir); 1233 1234 serv_type = cd_read_reg(sc, cy_chip, CD1400_TIVR); 1235 cy = &sc->sc_ports[serv_type >> 3]; 1236 1237 #ifdef CY_DEBUG1 1238 cy->cy_tx_int_count++; 1239 #endif 1240 #ifdef CY_DEBUG 1241 printf("%s port %d tx service\n", sc->sc_dev.dv_xname, 1242 cy->cy_port_num); 1243 #endif 1244 1245 /* stop transmitting if no tty or CY_F_STOP set */ 1246 tp = cy->cy_tty; 1247 if (tp == NULL || ISSET(cy->cy_flags, CY_F_STOP)) 1248 goto txdone; 1249 1250 count = 0; 1251 if (ISSET(cy->cy_flags, CY_F_SEND_NUL)) { 1252 cd_write_reg(sc, cy->cy_chip, CD1400_TDR, 0); 1253 cd_write_reg(sc, cy->cy_chip, CD1400_TDR, 0); 1254 count += 2; 1255 CLR(cy->cy_flags, CY_F_SEND_NUL); 1256 } 1257 if (tp->t_outq.c_cc > 0) { 1258 SET(tp->t_state, TS_BUSY); 1259 while (tp->t_outq.c_cc > 0 && 1260 count < CD1400_TX_FIFO_SIZE) { 1261 ch = getc(&tp->t_outq); 1262 /* 1263 * remember to double NUL characters 1264 * because embedded transmit commands 1265 * are enabled 1266 */ 1267 if (ch == 0) { 1268 if (count >= CD1400_TX_FIFO_SIZE - 2) { 1269 SET(cy->cy_flags, CY_F_SEND_NUL); 1270 break; 1271 } 1272 cd_write_reg(sc, cy->cy_chip, 1273 CD1400_TDR, ch); 1274 count++; 1275 } 1276 cd_write_reg(sc, cy->cy_chip, 1277 CD1400_TDR, ch); 1278 count++; 1279 } 1280 } else { 1281 /* 1282 * no data to send -- check if we should 1283 * start/stop a break 1284 */ 1285 /* 1286 * XXX does this cause too much delay before 1287 * breaks? 1288 */ 1289 if (ISSET(cy->cy_flags, CY_F_START_BREAK)) { 1290 cd_write_reg(sc, cy->cy_chip, 1291 CD1400_TDR, 0); 1292 cd_write_reg(sc, cy->cy_chip, 1293 CD1400_TDR, 0x81); 1294 CLR(cy->cy_flags, CY_F_START_BREAK); 1295 } 1296 if (ISSET(cy->cy_flags, CY_F_END_BREAK)) { 1297 cd_write_reg(sc, cy->cy_chip, 1298 CD1400_TDR, 0); 1299 cd_write_reg(sc, cy->cy_chip, 1300 CD1400_TDR, 0x83); 1301 CLR(cy->cy_flags, CY_F_END_BREAK); 1302 } 1303 } 1304 1305 if (tp->t_outq.c_cc == 0) { 1306 txdone: 1307 /* 1308 * No data to send or requested to stop. 1309 * Disable transmit interrupt 1310 */ 1311 cd_write_reg(sc, cy->cy_chip, CD1400_SRER, 1312 cd_read_reg(sc, cy->cy_chip, CD1400_SRER) 1313 & ~CD1400_SRER_TXRDY); 1314 CLR(cy->cy_flags, CY_F_STOP); 1315 CLR(tp->t_state, TS_BUSY); 1316 } 1317 if (tp->t_outq.c_cc <= tp->t_lowat) { 1318 SET(cy->cy_flags, CY_F_START); 1319 cy_events = 1; 1320 } 1321 /* terminate service context */ 1322 cd_write_reg(sc, cy->cy_chip, CD1400_TIR, save_tir & 0x3f); 1323 cd_write_reg(sc, cy->cy_chip, CD1400_CAR, save_car); 1324 int_serviced = 1; 1325 } /* if (tx_service...) */ 1326 } /* for(...all CD1400s on a card) */ 1327 1328 /* ensure an edge for next interrupt */ 1329 bus_space_write_1(sc->sc_memt, sc->sc_bsh, 1330 CY_CLEAR_INTR << sc->sc_bustype, 0); 1331 return int_serviced; 1332 } 1333 1334 /* 1335 * subroutine to enable CD1400 transmitter 1336 */ 1337 void 1338 cy_enable_transmitter(struct cy_softc *sc, struct cy_port *cy) 1339 { 1340 int s = spltty(); 1341 cd_write_reg(sc, cy->cy_chip, CD1400_CAR, 1342 cy->cy_port_num & CD1400_CAR_CHAN); 1343 cd_write_reg(sc, cy->cy_chip, CD1400_SRER, 1344 cd_read_reg(sc, cy->cy_chip, CD1400_SRER) | CD1400_SRER_TXRDY); 1345 splx(s); 1346 } 1347 1348 /* 1349 * Execute a CD1400 channel command 1350 */ 1351 void 1352 cd1400_channel_cmd(struct cy_softc *sc, struct cy_port *cy, int cmd) 1353 { 1354 u_int waitcnt = 5 * 8 * 1024; /* approx 5 ms */ 1355 1356 #ifdef CY_DEBUG 1357 printf("c1400_channel_cmd cy %p command 0x%x\n", cy, cmd); 1358 #endif 1359 1360 /* wait until cd1400 is ready to process a new command */ 1361 while (cd_read_reg(sc, cy->cy_chip, CD1400_CCR) != 0 && waitcnt-- > 0); 1362 1363 if (waitcnt == 0) 1364 log(LOG_ERR, "%s: channel command timeout\n", 1365 sc->sc_dev.dv_xname); 1366 1367 cd_write_reg(sc, cy->cy_chip, CD1400_CCR, cmd); 1368 } 1369 1370 /* 1371 * Compute clock option register and baud rate register values 1372 * for a given speed. Return 0 on success, -1 on failure. 1373 * 1374 * The error between requested and actual speed seems 1375 * to be well within allowed limits (less than 3%) 1376 * with every speed value between 50 and 150000 bps. 1377 */ 1378 int 1379 cy_speed(speed_t speed, int *cor, int *bpr, int cy_clock) 1380 { 1381 int c, co, br; 1382 1383 if (speed < 50 || speed > 150000) 1384 return -1; 1385 1386 for (c = 0, co = 8; co <= 2048; co <<= 2, c++) { 1387 br = (cy_clock + (co * speed) / 2) / (co * speed); 1388 if (br < 0x100) { 1389 *bpr = br; 1390 *cor = c; 1391 return 0; 1392 } 1393 } 1394 1395 return -1; 1396 } 1397