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