![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ps.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba|
Return to ps.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)ps.c 7.5 (Berkeley) 4/3/90 ! 7: */ ! 8: ! 9: /* ! 10: * Evans and Sutherland Picture System 2 driver -- Bill Reeves. ! 11: */ ! 12: ! 13: /* ! 14: * Still to be done: ! 15: * WAIT_HIT ! 16: */ ! 17: ! 18: #include "ps.h" ! 19: #if NPS > 0 ! 20: ! 21: #define EXTERNAL_SYNC ! 22: ! 23: #include "machine/pte.h" ! 24: ! 25: #include "param.h" ! 26: #include "systm.h" ! 27: #include "ioctl.h" ! 28: #include "map.h" ! 29: #include "buf.h" ! 30: #include "conf.h" ! 31: #include "user.h" ! 32: #include "uio.h" ! 33: ! 34: #include "ubareg.h" ! 35: #include "ubavar.h" ! 36: #include "psreg.h" ! 37: ! 38: int psprobe(), psattach(), psextsync(); ! 39: int psclockintr(), pssystemintr(), psdeviceintr(), psdmaintr(); ! 40: struct uba_device *psdinfo[NPS]; ! 41: u_short psstd[] = { 0 }; ! 42: struct uba_driver psdriver = ! 43: { psprobe, 0, psattach, 0, psstd, "ps", psdinfo }; ! 44: ! 45: #define PSUNIT(dev) (minor(dev)) ! 46: ! 47: #define MAXAUTOREFRESH 4 ! 48: #define MAXAUTOMAP 4 ! 49: #define MAXDBSIZE (0177777/2) ! 50: ! 51: #define PSPRI (PZERO+1) ! 52: ! 53: #define PSWAIT(psaddr) { \ ! 54: register short i = 20000, j; \ ! 55: while (i-- != 0 && ((j = psaddr->ps_iostat) & DIOREADY) == 0) \ ! 56: ;\ ! 57: } ! 58: ! 59: struct psrefresh { ! 60: enum { ! 61: SINGLE_STEP_RF, ! 62: AUTO_RF, ! 63: TIME_RF ! 64: } state; ! 65: enum { ! 66: RUNNING_RF, ! 67: SYNCING_RF, ! 68: WAITING_MAP, ! 69: STOPPED_RF ! 70: } mode; ! 71: u_short sraddrs[MAXAUTOREFRESH]; ! 72: short nsraddrs; ! 73: short srcntr; ! 74: char waiting; ! 75: char stop; ! 76: int icnt; ! 77: int timecnt; ! 78: }; ! 79: ! 80: struct psdbuffer { ! 81: enum { ! 82: ON_DB, ! 83: OFF_DB ! 84: } state; ! 85: u_short dbaddrs[2]; ! 86: u_short dbsize; ! 87: short rbuffer; ! 88: }; ! 89: ! 90: struct psmap { ! 91: enum { ! 92: SINGLE_STEP_MAP, ! 93: AUTO_MAP ! 94: } state; ! 95: enum { ! 96: RUNNING_MAP, ! 97: WAITING_RF, ! 98: WAITING_START, ! 99: STOPPED_MAP ! 100: } mode; ! 101: u_short maddrs[MAXAUTOMAP]; ! 102: short nmaddrs; ! 103: short mcntr; ! 104: short outputstart; ! 105: char waiting; ! 106: char stop; ! 107: int icnt; ! 108: }; ! 109: ! 110: /* ! 111: * PS2 software state. ! 112: */ ! 113: struct ps { ! 114: char ps_open; /* device is open */ ! 115: uid_t ps_uid; /* uid of device owner */ ! 116: struct psrefresh ps_refresh; /* refresh state */ ! 117: struct psdbuffer ps_dbuffer; /* double buffering state */ ! 118: struct psmap ps_map; /* segment map state */ ! 119: int ps_clockticks; /* clock ints between refresh */ ! 120: int ps_clockmiss; /* clock ints w/o refresh */ ! 121: int ps_clockcnt; /* count of clock interrupts */ ! 122: int ps_hitcnt; /* count of hit interrupts */ ! 123: int ps_strayintr; /* count of stray interrupts */ ! 124: int ps_icnt; /* count of system interrupts */ ! 125: /* BEGIN GROT */ ! 126: int ps_lastrequest; ! 127: int ps_lastrequest2; ! 128: int ps_lastfunnyrequest; ! 129: int ps_funnycnt; ! 130: /* END GROT */ ! 131: } ps[NPS]; ! 132: ! 133: psprobe(reg) ! 134: caddr_t reg; ! 135: { ! 136: register int br, cvec; ! 137: register struct psdevice *psaddr = (struct psdevice *)reg; ! 138: ! 139: #ifdef lint ! 140: br = 0; cvec = br; br = cvec; ! 141: psclockintr((dev_t)0); pssystemintr((dev_t)0); ! 142: psdeviceintr((dev_t)0); psdmaintr((dev_t)0); ! 143: psextsync(0, 0); ! 144: #endif ! 145: psaddr->ps_iostat = PSRESET; ! 146: DELAY(200); ! 147: psaddr->ps_addr = RTCIE; ! 148: PSWAIT(psaddr); psaddr->ps_data = 01; ! 149: psaddr->ps_iostat = PSIE; ! 150: psaddr->ps_addr = RTCSR; ! 151: PSWAIT(psaddr); psaddr->ps_data = SYNC|RUN; ! 152: DELAY(200000); ! 153: psaddr->ps_addr = RTCREQ; ! 154: PSWAIT(psaddr); psaddr->ps_data = 01; ! 155: psaddr->ps_iostat = 0; ! 156: psaddr->ps_iostat = PSRESET; ! 157: return (sizeof (struct psdevice)); ! 158: } ! 159: ! 160: /*ARGSUSED*/ ! 161: psattach(ui) ! 162: struct uba_device *ui; ! 163: { ! 164: ! 165: } ! 166: ! 167: psopen(dev) ! 168: dev_t dev; ! 169: { ! 170: register struct ps *psp; ! 171: register struct uba_device *ui; ! 172: register int unit = PSUNIT(dev); ! 173: ! 174: if (unit >= NPS || (psp = &ps[minor(dev)])->ps_open || ! 175: (ui = psdinfo[unit]) == 0 || ui->ui_alive == 0) ! 176: return (ENXIO); ! 177: psp->ps_open = 1; ! 178: psp->ps_uid = u.u_uid; ! 179: psp->ps_strayintr = 0; ! 180: psp->ps_refresh.state = SINGLE_STEP_RF; ! 181: psp->ps_refresh.mode = STOPPED_RF; ! 182: psp->ps_refresh.waiting = 0; ! 183: psp->ps_refresh.stop = 0; ! 184: psp->ps_dbuffer.state = OFF_DB; ! 185: psp->ps_map.state = SINGLE_STEP_MAP; ! 186: psp->ps_map.mode = STOPPED_MAP; ! 187: psp->ps_map.waiting = 0; ! 188: psp->ps_map.stop = 0; ! 189: psp->ps_clockticks = 0; ! 190: psp->ps_clockmiss = 0; ! 191: psp->ps_refresh.icnt = psp->ps_map.icnt = psp->ps_clockcnt = 0; ! 192: psp->ps_hitcnt = 0; ! 193: psp->ps_icnt = 0; ! 194: maptouser(ui->ui_addr); ! 195: return (0); ! 196: } ! 197: ! 198: psclose(dev) ! 199: dev_t dev; ! 200: { ! 201: register struct psdevice *psaddr = ! 202: (struct psdevice *)psdinfo[PSUNIT(dev)]->ui_addr; ! 203: ! 204: ps[PSUNIT(dev)].ps_open = 0; ! 205: psaddr->ps_iostat = 0; /* clear IENABLE */ ! 206: PSWAIT(psaddr); psaddr->ps_addr = RFSR; /* set in auto refresh mode */ ! 207: PSWAIT(psaddr); psaddr->ps_data = AUTOREF; ! 208: unmaptouser((caddr_t)psaddr); ! 209: return (0); ! 210: } ! 211: ! 212: /*ARGSUSED*/ ! 213: psread(dev, uio) ! 214: dev_t dev; ! 215: struct uio *uio; ! 216: { ! 217: } ! 218: ! 219: /*ARGSUSED*/ ! 220: pswrite(dev, uio) ! 221: dev_t dev; ! 222: struct uio *uio; ! 223: { ! 224: } ! 225: ! 226: /*ARGSUSED*/ ! 227: psioctl(dev, cmd, data, flag) ! 228: register caddr_t data; ! 229: { ! 230: register struct uba_device *ui = psdinfo[PSUNIT(dev)]; ! 231: register struct ps *psp = &ps[PSUNIT(dev)]; ! 232: int *waddr = *(int **)data; ! 233: int n, arg, i, error = 0; ! 234: ! 235: switch (cmd) { ! 236: ! 237: case PSIOGETADDR: ! 238: *(caddr_t *)data = ui->ui_addr; ! 239: break; ! 240: ! 241: case PSIOAUTOREFRESH: ! 242: n = fuword((caddr_t)waddr++); ! 243: if (n == -1) ! 244: return (EFAULT); ! 245: if (n < 0 || n > MAXAUTOREFRESH) ! 246: return (EINVAL); ! 247: for (i = 0; i < n; i++) { ! 248: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 249: return (EFAULT); ! 250: psp->ps_refresh.sraddrs[i] = arg; ! 251: } ! 252: psp->ps_refresh.state = AUTO_RF; ! 253: psp->ps_refresh.nsraddrs = n; ! 254: psp->ps_refresh.srcntr = 0; ! 255: psp->ps_refresh.mode = WAITING_MAP; ! 256: break; ! 257: ! 258: case PSIOAUTOMAP: ! 259: n = fuword((caddr_t)waddr++); ! 260: if (n == -1) ! 261: return (EFAULT); ! 262: if (n < 0 || n > MAXAUTOMAP) ! 263: return (EINVAL); ! 264: for (i = 0; i < n; i++) { ! 265: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 266: return (EFAULT); ! 267: psp->ps_map.maddrs[i] = arg; ! 268: } ! 269: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 270: return (EFAULT); ! 271: psp->ps_map.outputstart = arg; ! 272: psp->ps_map.state = AUTO_MAP; ! 273: psp->ps_map.nmaddrs = n; ! 274: psp->ps_map.mcntr = 0; ! 275: psp->ps_map.mode = WAITING_START; ! 276: break; ! 277: ! 278: case PSIOSINGLEREFRESH: ! 279: psp->ps_refresh.state = SINGLE_STEP_RF; ! 280: break; ! 281: ! 282: case PSIOSINGLEMAP: ! 283: psp->ps_map.state = SINGLE_STEP_MAP; ! 284: break; ! 285: ! 286: case PSIODOUBLEBUFFER: ! 287: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 288: return (EFAULT); ! 289: psp->ps_dbuffer.dbaddrs[0] = arg; ! 290: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 291: return (EFAULT); ! 292: if (arg <= 0 || arg > MAXDBSIZE) ! 293: return (EINVAL); ! 294: psp->ps_dbuffer.dbsize = arg; ! 295: psp->ps_dbuffer.dbaddrs[1] = psp->ps_dbuffer.dbaddrs[0]+arg; ! 296: psp->ps_dbuffer.state = ON_DB; ! 297: psp->ps_dbuffer.rbuffer = 0; ! 298: break; ! 299: ! 300: case PSIOSINGLEBUFFER: ! 301: psp->ps_dbuffer.state = OFF_DB; ! 302: break; ! 303: ! 304: case PSIOTIMEREFRESH: ! 305: if (psp->ps_refresh.state != SINGLE_STEP_RF) ! 306: return (EINVAL); ! 307: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 308: return (EFAULT); ! 309: psp->ps_refresh.state = TIME_RF; ! 310: psp->ps_refresh.timecnt = arg; ! 311: break; ! 312: ! 313: case PSIOWAITREFRESH: ! 314: if (psp->ps_refresh.mode != RUNNING_RF) /* not running */ ! 315: return (0); /* dont wait */ ! 316: /* fall into ... */ ! 317: ! 318: case PSIOSTOPREFRESH: ! 319: if (cmd == PSIOSTOPREFRESH) { ! 320: if (psp->ps_refresh.mode == STOPPED_RF && ! 321: psp->ps_refresh.state != TIME_RF) ! 322: return (0); ! 323: psp->ps_refresh.stop = 1; ! 324: } ! 325: (void) spl5(); ! 326: psp->ps_refresh.waiting = 1; ! 327: while (psp->ps_refresh.waiting) ! 328: if (error = tsleep(&psp->ps_refresh.waiting, ! 329: PSPRI | PCATCH, devwait, 0)) ! 330: break; ! 331: (void) spl0(); ! 332: if (error) ! 333: return (error); ! 334: if (cmd == PSIOSTOPREFRESH) ! 335: psp->ps_refresh.mode = STOPPED_RF; ! 336: if (psp->ps_refresh.state == TIME_RF) ! 337: psp->ps_refresh.state = SINGLE_STEP_RF; ! 338: break; ! 339: ! 340: case PSIOWAITMAP: ! 341: if (psp->ps_map.mode != RUNNING_MAP) /* not running */ ! 342: return (0); /* dont wait */ ! 343: /* fall into ... */ ! 344: ! 345: case PSIOSTOPMAP: ! 346: if (cmd == PSIOSTOPMAP) ! 347: psp->ps_map.stop = 1; ! 348: (void) spl5(); ! 349: psp->ps_map.waiting = 1; ! 350: while (psp->ps_map.waiting) ! 351: if (error = tsleep(&psp->ps_map.waiting, PSPRI | PCATCH, ! 352: devwait, 0)) ! 353: break; ! 354: (void) spl0(); ! 355: break; ! 356: ! 357: default: ! 358: return (ENOTTY); ! 359: break; ! 360: } ! 361: return (error); ! 362: } ! 363: ! 364: #define SAVEPSADDR(psaddr, savepsaddr) { \ ! 365: register short i, xx1; \ ! 366: xx1 = splclock(); \ ! 367: i = psaddr->ps_addr; \ ! 368: while ((psaddr->ps_iostat & DIOREADY) == 0) \ ! 369: ; \ ! 370: savepsaddr = psaddr->ps_data; \ ! 371: splx(xx1); \ ! 372: } ! 373: #define RESTORPSADDR(psaddr, savepsaddr) { \ ! 374: register short xx2; \ ! 375: xx2 = splclock(); \ ! 376: while ((psaddr->ps_iostat & DIOREADY) == 0) \ ! 377: ;\ ! 378: psaddr->ps_addr = savepsaddr; \ ! 379: splx(xx2); \ ! 380: } ! 381: ! 382: psclockintr(dev) ! 383: dev_t dev; ! 384: { ! 385: register struct psdevice *psaddr = ! 386: (struct psdevice *)psdinfo[PSUNIT(dev)]->ui_addr; ! 387: register struct ps *psp = &ps[PSUNIT(dev)]; ! 388: int savepsaddr; ! 389: ! 390: if (!psp->ps_open) ! 391: return; ! 392: psp->ps_clockcnt++; ! 393: SAVEPSADDR(psaddr, savepsaddr); ! 394: #ifndef EXTERNAL_SYNC ! 395: if (psp->ps_refresh.state == AUTO_RF) { ! 396: if (psp->ps_refresh.mode == SYNCING_RF && ! 397: psp->ps_refresh.state != TIME_RF) { ! 398: (void) psrfnext(psp, psaddr); ! 399: } else { ! 400: psp->ps_clockticks++; ! 401: psp->ps_clockmiss++; ! 402: } ! 403: } ! 404: #endif ! 405: PSWAIT(psaddr); psaddr->ps_addr = RTCREQ; ! 406: PSWAIT(psaddr); psaddr->ps_data = 01; /* clear the request bits */ ! 407: RESTORPSADDR(psaddr, savepsaddr); ! 408: } ! 409: ! 410: /*ARGSUSED*/ ! 411: pssystemintr(dev) ! 412: dev_t dev; ! 413: { ! 414: register struct psdevice *psaddr = ! 415: (struct psdevice *)psdinfo[PSUNIT(dev)]->ui_addr; ! 416: register struct ps *psp = &ps[PSUNIT(dev)]; ! 417: short request, tmp; ! 418: register int savepsaddr, x; ! 419: ! 420: if (!psp->ps_open) ! 421: return; ! 422: psp->ps_icnt++; ! 423: SAVEPSADDR(psaddr, savepsaddr); ! 424: PSWAIT(psaddr); psaddr->ps_addr = SYSREQ; ! 425: PSWAIT(psaddr); request = psaddr->ps_data; ! 426: request = request&0377; ! 427: psp->ps_lastrequest2 = psp->ps_lastrequest; ! 428: psp->ps_lastrequest = request; ! 429: if (request &~ (HALT_REQ|RFSTOP_REQ|HIT_REQ)) { ! 430: psp->ps_lastfunnyrequest = request; ! 431: psp->ps_funnycnt++; ! 432: } ! 433: PSWAIT(psaddr); psaddr->ps_addr = SYSREQ; ! 434: tmp = request&(~(HALT_REQ|MOSTOP_REQ)); /* acknowledge */ ! 435: PSWAIT(psaddr); psaddr->ps_data = tmp; ! 436: ! 437: if (request & (MOSTOP_REQ|HALT_REQ)) { /* Map stopped */ ! 438: psp->ps_map.icnt++; ! 439: psmapstop(psaddr, psp, request);/* kill it dead */ ! 440: if (psp->ps_map.waiting) { ! 441: psp->ps_map.waiting = 0; ! 442: wakeup(&psp->ps_map.waiting); ! 443: if (psp->ps_map.stop) { ! 444: psp->ps_map.stop = 0; ! 445: goto tryrf; ! 446: } ! 447: } ! 448: if (psp->ps_map.state == AUTO_MAP && !psmapnext(psp, psaddr)) { ! 449: psp->ps_map.mcntr = 0; ! 450: /* prepare for next round */ ! 451: pssetmapbounds(psp, psaddr); ! 452: if (psp->ps_refresh.state == AUTO_RF) { ! 453: if (psp->ps_refresh.mode == WAITING_MAP){ ! 454: if (psp->ps_dbuffer.state == ON_DB) ! 455: /* fill other db */ ! 456: psdbswitch(psp, psaddr); ! 457: else ! 458: psp->ps_map.mode = WAITING_RF; ! 459: #ifdef EXTERNAL_SYNC ! 460: x = splclock(); ! 461: #endif ! 462: (void) psrfnext(psp, psaddr); ! 463: #ifdef EXTERNAL_SYNC ! 464: splx(x); ! 465: #endif ! 466: } else ! 467: psp->ps_map.mode = WAITING_RF; ! 468: } else { /* no auto refresh */ ! 469: if (psp->ps_dbuffer.state == ON_DB) ! 470: /* fill other db */ ! 471: psdbswitch(psp, psaddr); ! 472: else ! 473: (void) psmapnext(psp, psaddr); ! 474: } ! 475: } ! 476: } ! 477: tryrf: ! 478: if (request & RFSTOP_REQ) { /* Refresh stopped */ ! 479: psp->ps_refresh.icnt++; ! 480: if (psp->ps_refresh.state == TIME_RF) ! 481: if (--psp->ps_refresh.timecnt > 0) ! 482: goto tryhit; ! 483: psrfstop(psaddr, psp); ! 484: if (psp->ps_refresh.waiting) { ! 485: psp->ps_refresh.waiting = 0; ! 486: wakeup(&psp->ps_refresh.waiting); ! 487: if (psp->ps_refresh.stop) { ! 488: psp->ps_refresh.stop = 0; ! 489: goto tryhit; ! 490: } ! 491: } ! 492: if (psp->ps_refresh.state == AUTO_RF) ! 493: if (!psrfnext(psp, psaddr)) { /* at end of refresh cycle */ ! 494: if (psp->ps_map.state == AUTO_MAP && ! 495: psp->ps_map.mode == WAITING_RF) { ! 496: if (psp->ps_dbuffer.state == ON_DB) ! 497: psdbswitch(psp, psaddr); ! 498: else ! 499: (void) psmapnext(psp, psaddr); ! 500: } ! 501: psp->ps_refresh.srcntr = 0; ! 502: #ifdef EXTERNAL_SYNC ! 503: x = splclock(); ! 504: #endif ! 505: psp->ps_refresh.mode = SYNCING_RF; ! 506: if (psp->ps_clockticks) ! 507: (void) psrfnext(psp, psaddr); ! 508: psp->ps_clockticks = 0; ! 509: #ifdef EXTERNAL_SYNC ! 510: splx(x); ! 511: #endif ! 512: } ! 513: } ! 514: tryhit: ! 515: if (request & HIT_REQ) /* Hit request */ ! 516: psp->ps_hitcnt++; ! 517: if (request == 0) ! 518: psp->ps_strayintr++; ! 519: RESTORPSADDR(psaddr, savepsaddr); ! 520: } ! 521: ! 522: psrfnext(psp, psaddr) ! 523: register struct ps *psp; ! 524: register struct psdevice *psaddr; ! 525: { ! 526: u_short start, last; ! 527: ! 528: if (psp->ps_refresh.srcntr < psp->ps_refresh.nsraddrs) { ! 529: psrfstart(psp->ps_refresh.sraddrs[psp->ps_refresh.srcntr++], ! 530: 0, psp, psaddr); ! 531: return (1); ! 532: } ! 533: if (psp->ps_refresh.srcntr == psp->ps_refresh.nsraddrs && ! 534: psp->ps_dbuffer.state == ON_DB) { ! 535: start = psp->ps_dbuffer.dbaddrs[psp->ps_dbuffer.rbuffer]; ! 536: last = start+psp->ps_dbuffer.dbsize; ! 537: psrfstart(start, last, psp, psaddr); ! 538: psp->ps_refresh.srcntr++; /* flag for after dbuffer */ ! 539: return (1); ! 540: } ! 541: return (0); ! 542: } ! 543: ! 544: psrfstart(dfaddr, last, psp, psaddr) ! 545: u_short dfaddr, last; ! 546: register struct ps *psp; ! 547: register struct psdevice *psaddr; ! 548: { ! 549: short dummy; ! 550: ! 551: PSWAIT(psaddr); psaddr->ps_addr = RFASA; ! 552: PSWAIT(psaddr); psaddr->ps_data = dfaddr; ! 553: PSWAIT(psaddr); ! 554: if (last != 0) ! 555: psaddr->ps_data = last; ! 556: else ! 557: dummy = psaddr->ps_data;/* just access to get to status reg */ ! 558: PSWAIT(psaddr); psaddr->ps_data = RFSTART; /* may want | here */ ! 559: psp->ps_refresh.mode = RUNNING_RF; ! 560: } ! 561: ! 562: /*ARGSUSED*/ ! 563: psrfstop(psaddr, psp) ! 564: register struct psdevice *psaddr; ! 565: register struct ps *psp; ! 566: { ! 567: ! 568: PSWAIT(psaddr); psaddr->ps_addr = RFSR; ! 569: PSWAIT(psaddr); psaddr->ps_data = 0; ! 570: } ! 571: ! 572: psdbswitch(psp, psaddr) ! 573: register struct ps *psp; ! 574: register struct psdevice *psaddr; ! 575: { ! 576: ! 577: psp->ps_dbuffer.rbuffer = !psp->ps_dbuffer.rbuffer; ! 578: pssetmapbounds(psp, psaddr); ! 579: (void) psmapnext(psp, psaddr); ! 580: } ! 581: ! 582: psmapnext(psp, psaddr) ! 583: register struct ps *psp; ! 584: register struct psdevice *psaddr; ! 585: { ! 586: ! 587: if (psp->ps_map.mcntr < psp->ps_map.nmaddrs) { ! 588: psmapstart(psp->ps_map.maddrs[psp->ps_map.mcntr++], ! 589: psp, psaddr); ! 590: return (1); ! 591: } ! 592: return (0); ! 593: } ! 594: ! 595: pssetmapbounds(psp, psaddr) ! 596: register struct ps *psp; ! 597: register struct psdevice *psaddr; ! 598: { ! 599: u_short start, last; ! 600: ! 601: PSWAIT(psaddr); psaddr->ps_addr = MAOL; ! 602: PSWAIT(psaddr); ! 603: if (psp->ps_dbuffer.state == ON_DB) { ! 604: start = psp->ps_dbuffer.dbaddrs[!psp->ps_dbuffer.rbuffer]; ! 605: last = start+psp->ps_dbuffer.dbsize-2; /* 2 for halt cmd */ ! 606: psaddr->ps_data = last; ! 607: PSWAIT(psaddr); psaddr->ps_data = start; ! 608: } else { ! 609: start = psaddr->ps_data; /* dummy: don't update limit */ ! 610: PSWAIT(psaddr); psaddr->ps_data = psp->ps_map.outputstart; ! 611: } ! 612: } ! 613: ! 614: psmapstart(dfaddr, psp, psaddr) ! 615: u_short dfaddr; ! 616: register struct ps *psp; ! 617: register struct psdevice *psaddr; ! 618: { ! 619: ! 620: PSWAIT(psaddr); psaddr->ps_addr = MAIA; ! 621: PSWAIT(psaddr); psaddr->ps_data = dfaddr; ! 622: PSWAIT(psaddr); psaddr->ps_data = MAO|MAI; /* may want more here */ ! 623: psp->ps_map.mode = RUNNING_MAP; ! 624: } ! 625: ! 626: int pskillcnt = 1; ! 627: ! 628: psmapstop(psaddr, psp, request) ! 629: register struct psdevice *psaddr; ! 630: register struct ps *psp; ! 631: short request; ! 632: { ! 633: register int i; ! 634: ! 635: request &= HALT_REQ|MOSTOP_REQ; /* overkill?? */ ! 636: for (i = 0; i < pskillcnt; i++) { ! 637: PSWAIT(psaddr); psaddr->ps_addr = MASR; ! 638: PSWAIT(psaddr); psaddr->ps_data = IOUT; /* zero MAI & MAO */ ! 639: PSWAIT(psaddr); psaddr->ps_addr = MAIA; ! 640: PSWAIT(psaddr); psaddr->ps_data = 0; /* 0 input addr reg */ ! 641: PSWAIT(psaddr); psaddr->ps_addr = MAOA; ! 642: PSWAIT(psaddr); psaddr->ps_data = 0; /* 0 output addr reg */ ! 643: PSWAIT(psaddr); psaddr->ps_addr = SYSREQ; ! 644: PSWAIT(psaddr); psaddr->ps_data = request; ! 645: } ! 646: psp->ps_map.mode = STOPPED_MAP; ! 647: } ! 648: ! 649: /*ARGSUSED*/ ! 650: psdeviceintr(dev) ! 651: dev_t dev; ! 652: { ! 653: ! 654: printf("ps device intr\n"); ! 655: } ! 656: ! 657: /*ARGSUSED*/ ! 658: psdmaintr(dev) ! 659: dev_t dev; ! 660: { ! 661: ! 662: printf("ps dma intr\n"); ! 663: } ! 664: ! 665: /*ARGSUSED*/ ! 666: psreset(uban) ! 667: int uban; ! 668: { ! 669: ! 670: } ! 671: ! 672: /*ARGSUSED*/ ! 673: psextsync(PC, PS) ! 674: { ! 675: register int n; ! 676: register struct psdevice *psaddr; ! 677: register struct ps *psp; ! 678: register int savepsaddr; ! 679: ! 680: #ifdef EXTERNAL_SYNC ! 681: for (psp = ps, n = 0; n < NPS; psp++, n++) { ! 682: if (!psp->ps_open) ! 683: continue; ! 684: if (psp->ps_refresh.mode == SYNCING_RF && ! 685: psp->ps_refresh.state != TIME_RF) { ! 686: psaddr = (struct psdevice *)psdinfo[n]->ui_addr; ! 687: SAVEPSADDR(psaddr, savepsaddr); ! 688: (void) psrfnext(psp, psaddr); ! 689: RESTORPSADDR(psaddr, savepsaddr); ! 690: } else { ! 691: psp->ps_clockticks++; ! 692: psp->ps_clockmiss++; ! 693: } ! 694: } ! 695: #endif ! 696: } ! 697: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.