msc.c revision 1.13
1 /* $NetBSD: msc.c,v 1.13 1996/12/23 09:10:26 veego Exp $ */ 2 3 /* 4 * Copyright (c) 1993 Zik. 5 * Copyright (c) 1995 Jukka Marin <jmarin (at) jmp.fi>. 6 * Copyright (c) 1995 Timo Rossi <trossi (at) jyu.fi>. 7 * Copyright (c) 1995 Rob Healey <rhealey (at) kas.helios.mn.org>. 8 * Copyright (c) 1982, 1986, 1990 The Regents of the University of California. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the University of 22 * California, Berkeley and its contributors. 23 * 4. Neither the name of the University nor the names of its contributors 24 * may be used to endorse or promote products derived from this software 25 * without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 37 * SUCH DAMAGE. 38 * 39 * - converted from NetBSD Amiga serial driver to A2232 serial driver 40 * by zik 931207 41 * - added ttyflags hooks rfh 940419 42 * - added new style config support rfh 940601 43 * - added code to halt board during memory load so board doesn't flip 44 * out. /dev/reload works now. Also created mschwiflow function so BSD can 45 * attempt to use board RTS flow control now. rfh 950108 46 * - Integrated work from Jukka Marin <jmarin (at) jmp.fi> and 47 * Timo Rossi <trossi (at) jyu.fi> The mscmint() code is Jukka's. 950916 48 * Integrated more bug fixes by Jukka Marin <jmarin (at) jmp.fi> 950918 49 * Also added Jukka's turbo board code. 950918 50 * - Reformatted to NetBSD style format. 51 * - Rewritten the carrier detect system to prevent lock-ups (jm 951029) 52 */ 53 54 #include "msc.h" 55 56 #if NMSC > 0 57 #include <sys/param.h> 58 #include <sys/systm.h> 59 #include <sys/ioctl.h> 60 #include <sys/tty.h> 61 #include <sys/proc.h> 62 #include <sys/file.h> 63 #include <sys/malloc.h> 64 #include <sys/uio.h> 65 #include <sys/kernel.h> 66 #include <sys/syslog.h> 67 #include <sys/device.h> 68 69 #include <amiga/amiga/device.h> 70 #include <amiga/dev/zbusvar.h> 71 #include <amiga/dev/mscreg.h> 72 #include <machine/cpu.h> 73 74 #include <amiga/amiga/custom.h> 75 #include <amiga/amiga/cia.h> 76 #include <amiga/amiga/cc.h> 77 78 #include <sys/conf.h> 79 #include <machine/conf.h> 80 81 /* 6502 code for A2232 card */ 82 #include "msc6502.h" 83 84 /* 85 * Note: These are Zik's original comments: 86 * There is a bit of a "gotcha" concerning the numbering 87 * of msc devices and the specification of the number of serial 88 * lines in the kernel. 89 * 90 * Each board has seven lines, but for programming convenience 91 * and compatibility with Amiga UNIX the boards' minor device 92 * numbers are allocated in groups of sixteen: 93 * 94 * minor device numbers 95 * First board 0 2 4 6 8 10 12 96 * Second board 16 18 20 22 24 26 28 97 * Third board 32 34 36 38 40 42 44 98 * 99 * The intermediate minor device numbers are dialin versions 100 * of the same devices. ie. 10 is dialout line 6 and 11 is 101 * the dialin version of line 6. 102 * 103 * On the other hand, I have made the NMSC config option refer 104 * to the total number of a2232 cards, not the maximum 105 * minor device number. So you might have NMSC=3, in which case 106 * you have three boards with minor device numbers from 0 to 45. 107 */ 108 109 int mscparam __P((struct tty *, struct termios *)); 110 void mscstart __P((struct tty *)); 111 int mschwiflow __P((struct tty *, int)); 112 int mscinitcard __P((struct zbus_args *)); 113 114 int mscdefaultrate = TTYDEF_SPEED; 115 116 struct mscdevice mscdev[MSCSLOTS]; /* device structs for all lines */ 117 struct tty *msc_tty[MSCTTYS]; /* ttys for all lines */ 118 119 struct vbl_node msc_vbl_node[NMSC]; /* vbl interrupt node per board */ 120 121 struct speedtab mscspeedtab_normal[] = { 122 { 0, 0 }, 123 { 50, MSCPARAM_B50 }, 124 { 75, MSCPARAM_B75 }, 125 { 110, MSCPARAM_B110 }, 126 { 134, MSCPARAM_B134 }, 127 { 150, MSCPARAM_B150 }, 128 { 300, MSCPARAM_B300 }, 129 { 600, MSCPARAM_B600 }, 130 { 1200, MSCPARAM_B1200 }, 131 { 1800, MSCPARAM_B1800 }, 132 { 2400, MSCPARAM_B2400 }, 133 { 3600, MSCPARAM_B3600 }, 134 { 4800, MSCPARAM_B4800 }, 135 { 7200, MSCPARAM_B7200 }, 136 { 9600, MSCPARAM_B9600 }, 137 { 19200, MSCPARAM_B19200 }, 138 { 115200, MSCPARAM_B115200 }, 139 { -1, -1 } 140 }; 141 142 struct speedtab mscspeedtab_turbo[] = { 143 { 0, 0 }, 144 { 100, MSCPARAM_B50 }, 145 { 150, MSCPARAM_B75 }, 146 { 220, MSCPARAM_B110 }, 147 { 269, MSCPARAM_B134 }, 148 { 300, MSCPARAM_B150 }, 149 { 600, MSCPARAM_B300 }, 150 { 1200, MSCPARAM_B600 }, 151 { 2400, MSCPARAM_B1200 }, 152 { 3600, MSCPARAM_B1800 }, 153 { 4800, MSCPARAM_B2400 }, 154 { 7200, MSCPARAM_B3600 }, 155 { 9600, MSCPARAM_B4800 }, 156 { 14400, MSCPARAM_B7200 }, 157 { 19200, MSCPARAM_B9600 }, 158 { 38400, MSCPARAM_B19200 }, 159 { 230400, MSCPARAM_B115200 }, 160 { -1, -1 } 161 }; 162 163 struct speedtab *mscspeedtab; 164 165 int mscmctl __P((dev_t dev, int bits, int howto)); 166 void mscmint __P((register void *data)); 167 168 int mscmatch __P((struct device *, struct cfdata *, void *)); 169 void mscattach __P((struct device *, struct device *, void *)); 170 171 #define SWFLAGS(dev) (msc->openflags | (MSCDIALIN(dev) ? 0 : TIOCFLAG_SOFTCAR)) 172 #define DEBUG_CD 0 173 174 struct cfattach msc_ca = { 175 sizeof(struct device), mscmatch, mscattach 176 }; 177 178 struct cfdriver msc_cd = { 179 NULL, "msc",DV_TTY, NULL, 0 180 }; 181 182 183 int 184 mscmatch(pdp, cfp, auxp) 185 struct device *pdp; 186 struct cfdata *cfp; 187 void *auxp; 188 { 189 struct zbus_args *zap; 190 191 zap = auxp; 192 if (zap->manid == 514 && (zap->prodid == 70 || zap->prodid == 69)) 193 return(1); 194 195 return (0); 196 } 197 198 void 199 mscattach(pdp, dp, auxp) 200 struct device *pdp, *dp; 201 void *auxp; 202 { 203 volatile struct mscmemory *mscmem; 204 struct mscdevice *msc; 205 struct zbus_args *zap; 206 int unit; 207 int Count; 208 209 zap = (struct zbus_args *)auxp; 210 unit = dp->dv_unit; 211 212 /* 213 * Make config msgs look nicer. 214 */ 215 printf("\n"); 216 217 if (mscinitcard(zap) != 0) { 218 printf("msc%d: Board initialize failed, bad download code.\n", unit); 219 return; 220 } 221 222 printf("msc%d: Board successfully initialized.\n", unit); 223 224 mscmem = (struct mscmemory *) zap->va; 225 226 if (mscmem->Common.Crystal == MSC_UNKNOWN) { 227 printf("msc%d: Unable to detect crystal frequency.\n", unit); 228 return; 229 } 230 231 if (mscmem->Common.Crystal == MSC_TURBO) { 232 printf("msc%d: Turbo version detected (%02x%02x:%d)\n", unit, 233 mscmem->Common.TimerH, mscmem->Common.TimerL, 234 mscmem->Common.Pad_a); 235 mscspeedtab = mscspeedtab_turbo; 236 } else { 237 printf("msc%d: Normal version detected (%02x%02x:%d)\n", unit, 238 mscmem->Common.TimerH, mscmem->Common.TimerL, 239 mscmem->Common.Pad_a); 240 mscspeedtab = mscspeedtab_normal; 241 } 242 243 mscmem->Common.CDStatus = 0; /* common status for all 7 ports */ 244 245 /* XXX 8 is a constant */ 246 for (Count = 0; Count < 8 && MSCSLOTUL(unit, Count) < MSCSLOTS; Count++) { 247 msc = &mscdev[MSCSLOTUL(unit, Count)]; 248 msc->board = mscmem; 249 msc->port = Count; 250 msc->flags = 0; 251 msc->openflags = 0; 252 msc->active = 1; 253 msc->unit = unit; 254 msc->closing = FALSE; 255 msc_tty[MSCTTYSLOT(MSCSLOTUL(unit, Count))] = NULL; 256 msc_tty[MSCTTYSLOT(MSCSLOTUL(unit, Count)) + 1] = NULL; 257 } 258 259 /* disable the non-existant eighth port */ 260 if (MSCSLOTUL(unit, NUMLINES) < MSCSLOTS) 261 mscdev[MSCSLOTUL(unit, NUMLINES)].active = 0; 262 263 msc_vbl_node[unit].function = (void (*) (void *)) mscmint; 264 msc_vbl_node[unit].data = (void *) unit; 265 266 add_vbl_function (&msc_vbl_node[unit], MSC_VBL_PRIORITY, (void *)unit); 267 268 return; 269 } 270 271 /* ARGSUSED */ 272 int 273 mscopen(dev, flag, mode, p) 274 dev_t dev; 275 int flag, mode; 276 struct proc *p; 277 { 278 register struct tty *tp; 279 struct mscdevice *msc; 280 volatile struct mscstatus *ms; 281 int error = 0; 282 int s, slot, ttyn; 283 284 /* get the device structure */ 285 slot = MSCSLOT(dev); 286 ttyn = MSCTTY(dev); 287 288 if (slot >= MSCSLOTS) 289 return ENXIO; 290 291 if (MSCLINE(dev) >= NUMLINES) 292 return ENXIO; 293 294 msc = &mscdev[slot]; 295 ms = &msc->board->Status[msc->port]; 296 297 if (!msc->active) 298 return ENXIO; 299 300 /* 301 * RFH: WHY here? Put down by while like other serial drivers 302 * But if we do that it makes things bomb. 303 */ 304 s = spltty(); 305 306 if (!msc_tty[ttyn]) { 307 308 tp = ttymalloc(); 309 tty_attach(tp); 310 msc_tty[ttyn] = tp; 311 msc_tty[ttyn+1] = (struct tty *)NULL; 312 313 #if 0 314 /* default values are not optimal for this device, increase buffers. */ 315 clfree(&tp->t_rawq); 316 clfree(&tp->t_canq); 317 clfree(&tp->t_outq); 318 clalloc(&tp->t_rawq, 8192, 1); 319 clalloc(&tp->t_canq, 8192, 1); 320 clalloc(&tp->t_outq, 8192, 0); 321 #endif 322 323 } else 324 tp = msc_tty[ttyn]; 325 326 tp->t_oproc = (void (*) (struct tty *)) mscstart; 327 tp->t_param = mscparam; 328 tp->t_dev = dev; 329 tp->t_hwiflow = mschwiflow; 330 331 /* if port is still closing, just bitbucket remaining characters */ 332 if (msc->closing) { 333 ms->OutFlush = TRUE; 334 msc->closing = FALSE; 335 } 336 337 /* initialize tty */ 338 if ((tp->t_state & TS_ISOPEN) == 0) { 339 tp->t_state |= TS_WOPEN; 340 ttychars(tp); 341 if (tp->t_ispeed == 0) { 342 tp->t_iflag = TTYDEF_IFLAG; 343 tp->t_oflag = TTYDEF_OFLAG; 344 tp->t_cflag = TTYDEF_CFLAG; 345 tp->t_lflag = TTYDEF_LFLAG; 346 tp->t_ispeed = tp->t_ospeed = mscdefaultrate; 347 } 348 349 /* flags changed to be private to every unit by JM */ 350 if (msc->openflags & TIOCFLAG_CLOCAL) 351 tp->t_cflag |= CLOCAL; 352 if (msc->openflags & TIOCFLAG_CRTSCTS) 353 tp->t_cflag |= CRTSCTS; 354 if (msc->openflags & TIOCFLAG_MDMBUF) 355 tp->t_cflag |= MDMBUF; 356 357 mscparam(tp, &tp->t_termios); 358 ttsetwater(tp); 359 360 (void) mscmctl(dev, TIOCM_DTR | TIOCM_RTS, DMSET); 361 362 if ((SWFLAGS(dev) & TIOCFLAG_SOFTCAR) || 363 (mscmctl(dev, 0, DMGET) & TIOCM_CD)) 364 tp->t_state |= TS_CARR_ON; 365 else 366 tp->t_state &= ~TS_CARR_ON; 367 368 } else { 369 if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0) { 370 splx(s); 371 return (EBUSY); 372 } 373 } 374 375 /* 376 * if NONBLOCK requested, ignore carrier 377 */ 378 if (flag & O_NONBLOCK) { 379 #if DEBUG_CD 380 printf("msc%d: %d open nonblock\n", msc->unit, MSCLINE(dev)); 381 #endif 382 goto done; 383 } 384 385 /* 386 * s = spltty(); 387 * 388 * This causes hangs when put here, like other TTY drivers do, rather than 389 * above, WHY? RFH 390 * 391 */ 392 393 while ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) { 394 tp->t_state |= TS_WOPEN; 395 396 #if DEBUG_CD 397 printf("msc%d: %d waiting for CD\n", msc->unit, MSCLINE(dev)); 398 #endif 399 error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH, ttopen, 0); 400 401 if (error) { 402 splx(s); 403 return(error); 404 } 405 } 406 407 #if DEBUG_CD 408 printf("msc%d: %d got CD\n", msc->unit, MSCLINE(dev)); 409 #endif 410 411 done: 412 /* This is a way to handle lost XON characters */ 413 if ((flag & O_TRUNC) && (tp->t_state & TS_TTSTOP)) { 414 tp->t_state &= ~TS_TTSTOP; 415 ttstart (tp); 416 } 417 418 splx(s); 419 420 /* 421 * Reset the tty pointer, as there could have been a dialout 422 * use of the tty with a dialin open waiting. 423 */ 424 tp->t_dev = dev; 425 426 return((*linesw[tp->t_line].l_open)(dev, tp)); 427 } 428 429 430 int 431 mscclose(dev, flag, mode, p) 432 dev_t dev; 433 int flag, mode; 434 struct proc *p; 435 { 436 register struct tty *tp; 437 int slot; 438 volatile struct mscstatus *ms; 439 struct mscdevice *msc; 440 441 /* get the device structure */ 442 slot = MSCSLOT(dev); 443 444 if (slot >= MSCSLOTS) 445 return ENXIO; 446 447 msc = &mscdev[slot]; 448 449 if (!msc->active) 450 return ENXIO; 451 452 ms = &msc->board->Status[msc->port]; 453 454 tp = msc_tty[MSCTTY(dev)]; 455 (*linesw[tp->t_line].l_close)(tp, flag); 456 457 (void) mscmctl(dev, 0, DMSET); 458 459 ttyclose(tp); 460 461 if (msc->flags & TIOCM_DTR) 462 msc->closing = TRUE; /* flush remaining characters before dropping DTR */ 463 else 464 ms->OutFlush = TRUE; /* just bitbucket remaining characters */ 465 466 return (0); 467 } 468 469 470 int 471 mscread(dev, uio, flag) 472 dev_t dev; 473 struct uio *uio; 474 int flag; 475 { 476 register struct tty *tp; 477 478 tp = msc_tty[MSCTTY(dev)]; 479 480 if (! tp) 481 return ENXIO; 482 483 return((*linesw[tp->t_line].l_read)(tp, uio, flag)); 484 } 485 486 487 int 488 mscwrite(dev, uio, flag) 489 dev_t dev; 490 struct uio *uio; 491 int flag; 492 { 493 register struct tty *tp; 494 495 tp = msc_tty[MSCTTY(dev)]; 496 497 if (! tp) 498 return ENXIO; 499 500 return ((*linesw[tp->t_line].l_write)(tp, uio, flag)); 501 } 502 503 504 /* 505 * This interrupt is periodically invoked in the vertical blank 506 * interrupt. It's used to keep track of the modem control lines 507 * and (new with the fast_int code) to move accumulated data up in 508 * to the tty layer. 509 * 510 * NOTE: MSCCDHACK is an invention of mine for dubious purposes. If you 511 * want to activate it add 512 * options MSCCDHACK 513 * in the kernel conf file. Basically it forces CD->Low transitions 514 * to ALWAYS send a signal to the process, even if the device is in 515 * clocal mode or an outdial device. RFH 516 */ 517 void 518 mscmint (data) 519 register void *data; 520 { 521 register struct tty *tp; 522 struct mscdevice *msc; 523 volatile struct mscstatus *ms; 524 volatile u_char *ibuf, *cbuf; 525 unsigned char newhead; /* was int */ 526 unsigned char bufpos; /* was int */ 527 unsigned char ncd, ocd, ccd; 528 int unit, slot, maxslot; 529 int s, i; 530 531 unit = (int) data; 532 533 /* check each line on this board */ 534 maxslot = MSCSLOTUL(unit, NUMLINES); 535 if (maxslot > MSCSLOTS) 536 maxslot = MSCSLOTS; 537 538 msc = &mscdev[MSCSLOTUL(unit, 0)]; 539 540 newhead = msc->board->Common.CDHead; 541 bufpos = msc->board->Common.CDTail; 542 if (newhead != bufpos) { /* CD events in queue */ 543 /* set interrupt priority level */ 544 s = spltty(); 545 ocd = msc->board->Common.CDStatus; /* get old status bits */ 546 while (newhead != bufpos) { /* read all events */ 547 ncd = msc->board->CDBuf[bufpos++]; /* get one event */ 548 ccd = ncd ^ ocd; /* mask of changed lines*/ 549 ocd = ncd; /* save new status bits */ 550 #if DEBUG_CD 551 printf("ocd %02x ncd %02x ccd %02x\n", ocd, ncd, ccd); 552 #endif 553 for(i = 0; i < NUMLINES; i++) { /* do for all lines */ 554 if (ccd & 1) { /* this one changed */ 555 msc = &mscdev[MSCSLOTUL(unit, i)]; 556 if (ncd & 1) { /* CD is now OFF */ 557 #if DEBUG_CD 558 printf("msc%d: CD OFF %d\n", unit, msc->port); 559 #endif 560 msc->flags &= ~TIOCM_CD; 561 if ((tp = msc_tty[MSCTTYSLOT(MSCSLOTUL(unit, i))]) && 562 (tp->t_state & (TS_ISOPEN | TS_WOPEN))) { 563 564 #ifndef MSCCDHACK 565 if (MSCDIALIN(tp->t_dev)) 566 #endif 567 { 568 if ((*linesw[tp->t_line].l_modem)(tp, 0) == 0) { 569 /* clear RTS and DTR, bitbucket output */ 570 ms = &msc->board->Status[msc->port]; 571 ms->Command = (ms->Command & ~MSCCMD_CMask) | 572 MSCCMD_Close; 573 ms->Setup = TRUE; 574 msc->flags &= ~(TIOCM_DTR | TIOCM_RTS); 575 ms->OutFlush = TRUE; 576 } 577 } 578 } 579 } else { /* CD is now ON */ 580 #if DEBUG_CD 581 printf("msc%d: CD ON %d\n", unit, msc->port); 582 #endif 583 msc->flags |= TIOCM_CD; 584 if ((tp = msc_tty[MSCTTYSLOT(MSCSLOTUL(unit, i))]) && 585 (tp->t_state & (TS_ISOPEN | TS_WOPEN))) { 586 if (MSCDIALIN(tp->t_dev)) 587 (*linesw[tp->t_line].l_modem)(tp, 1); 588 } /* if tp valid and port open */ 589 } /* CD on/off */ 590 } /* if CD changed for this line */ 591 ccd >>= 1; ncd >>= 1; /* bit for next line */ 592 } /* for every line */ 593 } /* while events in queue */ 594 msc->board->Common.CDStatus = ocd; /* save new status */ 595 msc->board->Common.CDTail = bufpos; /* remove events */ 596 splx(s); 597 } /* if events in CD queue */ 598 599 for (slot = MSCSLOTUL(unit, 0); slot < maxslot; slot++) { 600 msc = &mscdev[slot]; 601 602 if (!msc->active) 603 continue; 604 605 tp = msc_tty[MSCTTYSLOT(slot)]; 606 ms = &msc->board->Status[msc->port]; 607 608 newhead = ms->InHead; /* 65c02 write pointer */ 609 610 /* yoohoo, is the port open? */ 611 if (tp && (tp->t_state & (TS_ISOPEN|TS_WOPEN))) { 612 /* port is open, handle all type of events */ 613 614 /* set interrupt priority level */ 615 s = spltty(); 616 617 /* check for input for this port */ 618 if (newhead != (bufpos = ms->InTail)) { 619 /* buffer for input chars/events */ 620 ibuf = &msc->board->InBuf[msc->port][0]; 621 622 /* data types of bytes in ibuf */ 623 cbuf = &msc->board->InCtl[msc->port][0]; 624 625 /* do for all chars, if room */ 626 while (bufpos != newhead) { 627 /* which type of input data? */ 628 switch (cbuf[bufpos]) { 629 /* input event (CD, BREAK, etc.) */ 630 case MSCINCTL_EVENT: 631 switch (ibuf[bufpos++]) { 632 case MSCEVENT_Break: 633 (*linesw[tp->t_line].l_rint)(TTY_FE, tp); 634 break; 635 636 default: 637 printf("msc%d: unknown event type %d\n", 638 msc->unit, ibuf[(bufpos-1)&0xff]); 639 } /* event type switch */ 640 break; 641 642 case MSCINCTL_CHAR: 643 if (tp->t_state & TS_TBLOCK) { 644 goto NoRoomForYa; 645 } 646 (*linesw[tp->t_line].l_rint)((int)ibuf[bufpos++], tp); 647 break; 648 649 default: 650 printf("msc%d: unknown data type %d\n", 651 msc->unit, cbuf[bufpos]); 652 bufpos++; 653 } /* switch on input data type */ 654 } /* while there's something in the buffer */ 655 NoRoomForYa: 656 ms->InTail = bufpos; /* tell 65C02 what we've read */ 657 } /* if there was something in the buffer */ 658 659 /* we get here only when the port is open */ 660 /* send output */ 661 if (tp->t_state & (TS_BUSY|TS_FLUSH)) { 662 663 bufpos = ms->OutHead - ms->OutTail; 664 665 /* busy and below low water mark? */ 666 if (tp->t_state & TS_BUSY) { 667 if (bufpos < IOBUFLOWWATER) { 668 tp->t_state &= ~TS_BUSY; /* not busy any more */ 669 if (tp->t_line) 670 (*linesw[tp->t_line].l_start)(tp); 671 else 672 mscstart(tp); 673 } 674 } 675 676 /* waiting for flush and buffer empty? */ 677 if (tp->t_state & TS_FLUSH) { 678 if (bufpos == 0) 679 tp->t_state &= ~TS_FLUSH; /* finished flushing */ 680 } 681 } /* BUSY or FLUSH */ 682 683 splx(s); 684 685 } else { /* End of port open */ 686 /* port is closed, don't pass on the chars from it */ 687 688 /* check for input for this port */ 689 if (newhead != (bufpos = ms->InTail)) { 690 /* buffer for input chars/events */ 691 ibuf = &msc->board->InBuf[msc->port][0]; 692 693 /* data types of bytes in ibuf */ 694 cbuf = &msc->board->InCtl[msc->port][0]; 695 696 /* do for all chars, if room */ 697 while (bufpos != newhead) { 698 /* which type of input data? */ 699 switch (cbuf[bufpos]) { 700 /* input event (BREAK, etc.) */ 701 case MSCINCTL_EVENT: 702 switch (ibuf[bufpos++]) { 703 default: 704 printf("msc: unknown event type %d\n", 705 ibuf[(bufpos-1)&0xff]); 706 } /* event type switch */ 707 break; 708 709 default: 710 bufpos++; 711 } /* switch on input data type */ 712 } /* while there's something in the buffer */ 713 714 ms->InTail = bufpos; /* tell 65C02 what we've read */ 715 } /* if there was something in the buffer */ 716 } /* End of port open/close */ 717 718 /* is this port closing? */ 719 if (msc->closing) { 720 /* if DTR is off, just bitbucket remaining characters */ 721 if ( (msc->flags & TIOCM_DTR) == 0) { 722 ms->OutFlush = TRUE; 723 msc->closing = FALSE; 724 } 725 /* if output has drained, drop DTR */ 726 else if (ms->OutHead == ms->OutTail) { 727 (void) mscmctl(tp->t_dev, 0, DMSET); 728 msc->closing = FALSE; 729 } 730 } 731 } /* For all ports */ 732 } 733 734 735 int 736 mscioctl(dev, cmd, data, flag, p) 737 dev_t dev; 738 u_long cmd; 739 caddr_t data; 740 int flag; 741 struct proc *p; 742 { 743 register struct tty *tp; 744 register int slot; 745 register int error; 746 struct mscdevice *msc; 747 volatile struct mscstatus *ms; 748 int s; 749 750 /* get the device structure */ 751 slot = MSCSLOT(dev); 752 753 if (slot >= MSCSLOTS) 754 return ENXIO; 755 756 msc = &mscdev[slot]; 757 758 if (!msc->active) 759 return ENXIO; 760 761 ms = &msc->board->Status[msc->port]; 762 if (!(tp = msc_tty[MSCTTY(dev)])) 763 return ENXIO; 764 765 error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p); 766 767 if (error >= 0) 768 return (error); 769 770 error = ttioctl(tp, cmd, data, flag, p); 771 772 if (error >= 0) 773 return (error); 774 775 switch (cmd) { 776 777 /* send break */ 778 case TIOCSBRK: 779 s = spltty(); 780 ms->Command = (ms->Command & (~MSCCMD_RTSMask)) | MSCCMD_Break; 781 ms->Setup = TRUE; 782 splx(s); 783 break; 784 785 /* clear break */ 786 case TIOCCBRK: 787 s = spltty(); 788 ms->Command = (ms->Command & (~MSCCMD_RTSMask)) | MSCCMD_RTSOn; 789 ms->Setup = TRUE; 790 splx(s); 791 break; 792 793 case TIOCSDTR: 794 (void) mscmctl(dev, TIOCM_DTR | TIOCM_RTS, DMBIS); 795 break; 796 797 case TIOCCDTR: 798 if (!MSCDIALIN(dev)) /* don't let dialins drop DTR */ 799 (void) mscmctl(dev, TIOCM_DTR | TIOCM_RTS, DMBIC); 800 break; 801 802 case TIOCMSET: 803 (void) mscmctl(dev, *(int *)data, DMSET); 804 break; 805 806 case TIOCMBIS: 807 (void) mscmctl(dev, *(int *)data, DMBIS); 808 break; 809 810 case TIOCMBIC: 811 if (MSCDIALIN(dev)) /* don't let dialins drop DTR */ 812 (void) mscmctl(dev, *(int *)data & TIOCM_DTR, DMBIC); 813 else 814 (void) mscmctl(dev, *(int *)data, DMBIC); 815 break; 816 817 case TIOCMGET: 818 *(int *)data = mscmctl(dev, 0, DMGET); 819 break; 820 821 case TIOCGFLAGS: 822 *(int *)data = SWFLAGS(dev); 823 break; 824 825 case TIOCSFLAGS: 826 error = suser(p->p_ucred, &p->p_acflag); 827 if (error != 0) 828 return(EPERM); 829 msc->openflags = *(int *)data; 830 /* only allow valid flags */ 831 msc->openflags &= 832 (TIOCFLAG_SOFTCAR | TIOCFLAG_CLOCAL | TIOCFLAG_CRTSCTS); 833 break; 834 835 default: 836 return (ENOTTY); 837 } 838 839 return (0); 840 } 841 842 843 int 844 mscparam(tp, t) 845 register struct tty *tp; 846 register struct termios *t; 847 { 848 register int cflag = t->c_cflag; 849 struct mscdevice *msc; 850 volatile struct mscstatus *ms; 851 int s, slot; 852 int ospeed = ttspeedtab(t->c_ospeed, mscspeedtab); 853 854 /* get the device structure */ 855 slot = MSCSLOT(tp->t_dev); 856 857 if (slot >= MSCSLOTS) 858 return ENXIO; 859 860 msc = &mscdev[slot]; 861 862 if (!msc->active) 863 return ENXIO; 864 865 ms = &msc->board->Status[msc->port]; 866 867 /* check requested parameters */ 868 if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed)) 869 return (EINVAL); 870 871 /* and copy to tty */ 872 tp->t_ispeed = t->c_ispeed; 873 tp->t_ospeed = t->c_ospeed; 874 tp->t_cflag = cflag; 875 876 /* hang up if baud is zero */ 877 if (t->c_ospeed == 0) { 878 if (!MSCDIALIN(tp->t_dev)) /* don't let dialins drop DTR */ 879 (void) mscmctl(tp->t_dev, 0, DMSET); 880 } else { 881 /* set the baud rate */ 882 s = spltty(); 883 ms->Param = (ms->Param & ~MSCPARAM_BaudMask) | ospeed | MSCPARAM_RcvBaud; 884 885 /* 886 * Make sure any previous hangup is undone, ie. reenable DTR. 887 * also mscmctl will cause the speed to be set 888 */ 889 (void) mscmctl (tp->t_dev, TIOCM_DTR | TIOCM_RTS, DMSET); 890 891 splx(s); 892 } 893 894 return(0); 895 } 896 897 898 /* 899 * Jukka's code initializes alot of stuff that other drivers don't 900 * I'm including it here so that this code is a common set of work 901 * done by both of us. rfh 902 */ 903 int 904 mschwiflow(tp, flag) 905 struct tty *tp; 906 int flag; 907 { 908 909 /* Rob's version */ 910 #if 1 911 if (flag) 912 mscmctl( tp->t_dev, TIOCM_RTS, DMBIC); /* Clear/Lower RTS */ 913 else 914 mscmctl( tp->t_dev, TIOCM_RTS, DMBIS); /* Set/Raise RTS */ 915 916 #else /* Jukka's version */ 917 918 int s, slot; 919 struct mscdevice *msc; 920 volatile struct mscstatus *ms; 921 922 /* get the device structure */ 923 slot = MSCSLOT(tp->t_dev); 924 if (slot >= MSCSLOTS) 925 return ENXIO; 926 msc = &mscdev[slot]; 927 if (!msc->active) 928 return ENXIO; 929 ms = &msc->board->Status[msc->port]; 930 931 /* Well, we should really _do_ something here, but the 65c02 code 932 * manages the RTS signal on its own now, so... This will probably 933 * change in the future. 934 */ 935 #endif 936 return 1; 937 } 938 939 940 void 941 mscstart(tp) 942 register struct tty *tp; 943 { 944 register int cc; 945 register char *cp; 946 register int mhead; 947 int s, slot; 948 struct mscdevice *msc; 949 volatile struct mscstatus *ms; 950 volatile char *mob; 951 int hiwat = 0; 952 int maxout; 953 954 if (! (tp->t_state & TS_ISOPEN)) 955 return; 956 957 slot = MSCSLOT(tp->t_dev); 958 959 #if 0 960 printf("starting msc%d\n", slot); 961 #endif 962 963 s = spltty(); 964 965 /* don't start if explicitly stopped */ 966 if (tp->t_state & (TS_TIMEOUT|TS_TTSTOP)) 967 goto out; 968 969 /* wake up if below low water */ 970 cc = tp->t_outq.c_cc; 971 972 if (cc <= tp->t_lowat) { 973 if (tp->t_state & TS_ASLEEP) { 974 tp->t_state &= ~TS_ASLEEP; 975 wakeup((caddr_t)&tp->t_outq); 976 } 977 selwakeup(&tp->t_wsel); 978 } 979 980 /* don't bother if no characters or busy */ 981 if (cc == 0 || (tp->t_state & TS_BUSY)) 982 goto out; 983 984 /* 985 * Limit the amount of output we do in one burst 986 */ 987 msc = &mscdev[slot]; 988 ms = &msc->board->Status[msc->port]; 989 mhead = ms->OutHead; 990 maxout = mhead - ms->OutTail; 991 992 if (maxout < 0) 993 maxout += IOBUFLEN; 994 995 maxout = IOBUFLEN - 1 - maxout; 996 997 if (cc >= maxout) { 998 hiwat++; 999 cc = maxout; 1000 } 1001 1002 cc = q_to_b (&tp->t_outq, msc->tmpbuf, cc); 1003 1004 if (cc > 0) { 1005 tp->t_state |= TS_BUSY; 1006 1007 mob = &msc->board->OutBuf[msc->port][0]; 1008 cp = &msc->tmpbuf[0]; 1009 1010 /* enable output */ 1011 ms->OutDisable = FALSE; 1012 1013 #if 0 1014 msc->tmpbuf[cc] = 0; 1015 printf("sending '%s'\n", msctmpbuf); 1016 #endif 1017 1018 /* send the first char across to reduce latency */ 1019 mob[mhead++] = *cp++; 1020 mhead &= IOBUFLENMASK; 1021 ms->OutHead = mhead; 1022 cc--; 1023 1024 /* copy the rest of the chars across quickly */ 1025 while (cc > 0) { 1026 mob[mhead++] = *cp++; 1027 mhead &= IOBUFLENMASK; 1028 cc--; 1029 } 1030 ms->OutHead = mhead; 1031 1032 /* leave the device busy if we've filled the buffer */ 1033 if (!hiwat) 1034 tp->t_state &= ~TS_BUSY; 1035 } 1036 1037 out: 1038 splx(s); 1039 } 1040 1041 1042 /* XXX */ 1043 /* 1044 * Stop output on a line. 1045 */ 1046 /*ARGSUSED*/ 1047 void 1048 mscstop(tp, flag) 1049 register struct tty *tp; 1050 int flag; /* defaulted to int anyway */ 1051 { 1052 register int s; 1053 #if 0 1054 struct mscdevice *msc; 1055 volatile struct mscstatus *ms; 1056 #endif 1057 1058 s = spltty(); 1059 if (tp->t_state & TS_BUSY) { 1060 if ((tp->t_state & TS_TTSTOP) == 0) { 1061 tp->t_state |= TS_FLUSH; 1062 #if 0 1063 msc = &mscdev[MSCSLOT(tp->t_dev)]; 1064 ms = &msc->board->Status[msc->port]; 1065 printf("stopped output on msc%d\n", MSCSLOT(tp->t_dev)); 1066 ms->OutDisable = TRUE; 1067 #endif 1068 } 1069 } 1070 splx(s); 1071 } 1072 1073 1074 /* 1075 * bits can be: TIOCM_DTR, TIOCM_RTS, TIOCM_CTS, TIOCM_CD, TIOCM_RI, TIOCM_DSR 1076 */ 1077 int 1078 mscmctl(dev, bits, how) 1079 dev_t dev; 1080 int bits, how; 1081 { 1082 struct mscdevice *msc; 1083 volatile struct mscstatus *ms; 1084 int slot; 1085 int s; 1086 u_char newcmd; 1087 int OldFlags; 1088 1089 /* get the device structure */ 1090 slot = MSCSLOT(dev); 1091 1092 if (slot >= MSCSLOTS) 1093 return ENXIO; 1094 1095 msc = &mscdev[slot]; 1096 1097 if (!msc->active) 1098 return ENXIO; 1099 1100 s = spltty(); 1101 1102 if (how != DMGET) { 1103 OldFlags = msc->flags; 1104 bits &= TIOCM_DTR | TIOCM_RTS; /* can only modify DTR and RTS */ 1105 1106 switch (how) { 1107 case DMSET: 1108 msc->flags = (bits | (msc->flags & ~(TIOCM_DTR | TIOCM_RTS))); 1109 break; 1110 1111 case DMBIC: 1112 msc->flags &= ~bits; 1113 break; 1114 1115 case DMBIS: 1116 msc->flags |= bits; 1117 break; 1118 } 1119 1120 /* modify modem control state */ 1121 ms = &msc->board->Status[msc->port]; 1122 1123 if (msc->flags & TIOCM_RTS) /* was bits & */ 1124 newcmd = MSCCMD_RTSOn; 1125 else /* this doesn't actually work now */ 1126 newcmd = MSCCMD_RTSOff; 1127 1128 if (msc->flags & TIOCM_DTR) /* was bits & */ 1129 newcmd |= MSCCMD_Enable; 1130 1131 ms->Command = (ms->Command & (~MSCCMD_RTSMask & ~MSCCMD_Enable)) | newcmd; 1132 ms->Setup = TRUE; 1133 1134 /* if we've dropped DTR, bitbucket any pending output */ 1135 if ( (OldFlags & TIOCM_DTR) && ((bits & TIOCM_DTR) == 0)) 1136 ms->OutFlush = TRUE; 1137 } 1138 1139 bits = msc->flags; 1140 1141 (void) splx(s); 1142 1143 return(bits); 1144 } 1145 1146 1147 struct tty * 1148 msctty(dev) 1149 dev_t dev; 1150 { 1151 return(msc_tty[MSCTTY(dev)]); 1152 } 1153 1154 1155 /* 1156 * Load JM's freely redistributable A2232 6502c code. Let turbo detector 1157 * run for a while too. 1158 */ 1159 1160 int 1161 mscinitcard(zap) 1162 struct zbus_args *zap; 1163 { 1164 int bcount; 1165 short start; 1166 u_char *from; 1167 volatile u_char *to; 1168 volatile struct mscmemory *mlm; 1169 1170 mlm = (volatile struct mscmemory *)zap->va; 1171 (void)mlm->Enable6502Reset; 1172 1173 /* copy the code across to the board */ 1174 to = (u_char *)mlm; 1175 from = msc6502code; bcount = sizeof(msc6502code) - 2; 1176 start = *(short *)from; from += sizeof(start); 1177 to += start; 1178 1179 while(bcount--) *to++ = *from++; 1180 1181 mlm->Common.Crystal = MSC_UNKNOWN; /* use automatic speed check */ 1182 1183 /* start 6502 running */ 1184 (void)mlm->ResetBoard; 1185 1186 /* wait until speed detector has finished */ 1187 for (bcount = 0; bcount < 200; bcount++) { 1188 delay(10000); 1189 if (mlm->Common.Crystal) 1190 break; 1191 } 1192 1193 return(0); 1194 } 1195 1196 #endif /* NMSC > 0 */ 1197
Indexes created Mon Sep 22 21:09:42 GMT 2025